LCOV - code coverage report
Current view: top level - gcc/jit - jit-playback.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 1239 1380 89.8 %
Date: 2021-11-27 14:51:55 Functions: 109 115 94.8 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Internals of libgccjit: classes for playing back recorded API calls.
       2                 :            :    Copyright (C) 2013-2021 Free Software Foundation, Inc.
       3                 :            :    Contributed by David Malcolm <dmalcolm@redhat.com>.
       4                 :            : 
       5                 :            : This file is part of GCC.
       6                 :            : 
       7                 :            : GCC is free software; you can redistribute it and/or modify it
       8                 :            : under the terms of the GNU General Public License as published by
       9                 :            : the Free Software Foundation; either version 3, or (at your option)
      10                 :            : any later version.
      11                 :            : 
      12                 :            : GCC is distributed in the hope that it will be useful, but
      13                 :            : WITHOUT ANY WARRANTY; without even the implied warranty of
      14                 :            : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15                 :            : General Public License for more details.
      16                 :            : 
      17                 :            : You should have received a copy of the GNU General Public License
      18                 :            : along with GCC; see the file COPYING3.  If not see
      19                 :            : <http://www.gnu.org/licenses/>.  */
      20                 :            : 
      21                 :            : #include "config.h"
      22                 :            : #include "system.h"
      23                 :            : #include "coretypes.h"
      24                 :            : #include "target.h"
      25                 :            : #include "tree.h"
      26                 :            : #include "stringpool.h"
      27                 :            : #include "cgraph.h"
      28                 :            : #include "dumpfile.h"
      29                 :            : #include "toplev.h"
      30                 :            : #include "tree-cfg.h"
      31                 :            : #include "convert.h"
      32                 :            : #include "stor-layout.h"
      33                 :            : #include "print-tree.h"
      34                 :            : #include "gimplify.h"
      35                 :            : #include "gcc-driver-name.h"
      36                 :            : #include "attribs.h"
      37                 :            : #include "context.h"
      38                 :            : #include "fold-const.h"
      39                 :            : #include "opt-suggestions.h"
      40                 :            : #include "gcc.h"
      41                 :            : #include "diagnostic.h"
      42                 :            : #include "stmt.h"
      43                 :            : 
      44                 :            : #include <pthread.h>
      45                 :            : 
      46                 :            : #include "jit-playback.h"
      47                 :            : #include "jit-result.h"
      48                 :            : #include "jit-builtins.h"
      49                 :            : #include "jit-tempdir.h"
      50                 :            : 
      51                 :            : #ifdef _WIN32
      52                 :            : #include "jit-w32.h"
      53                 :            : #endif
      54                 :            : 
      55                 :            : /* Compare with gcc/c-family/c-common.h: DECL_C_BIT_FIELD,
      56                 :            :    SET_DECL_C_BIT_FIELD.
      57                 :            :    These are redefined here to avoid depending from the C frontend.  */
      58                 :            : #define DECL_JIT_BIT_FIELD(NODE) \
      59                 :            :   (DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) == 1)
      60                 :            : #define SET_DECL_JIT_BIT_FIELD(NODE) \
      61                 :            :   (DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) = 1)
      62                 :            : 
      63                 :            : /* gcc::jit::playback::context::build_cast uses the convert.h API,
      64                 :            :    which in turn requires the frontend to provide a "convert"
      65                 :            :    function, apparently as a fallback for casts that can be simplified
      66                 :            :    (truncation, extension). */
      67                 :            : extern tree convert (tree type, tree expr);
      68                 :            : 
      69                 :            : tree
      70                 :         15 : convert (tree dst_type, tree expr)
      71                 :            : {
      72                 :         15 :   tree t_ret = NULL;
      73                 :         15 :   t_ret = targetm.convert_to_type (dst_type, expr);
      74                 :         15 :   if (t_ret)
      75                 :            :       return t_ret;
      76                 :         15 :   switch (TREE_CODE (dst_type))
      77                 :            :     {
      78                 :         15 :     case INTEGER_TYPE:
      79                 :         15 :     case ENUMERAL_TYPE:
      80                 :         15 :       return fold (convert_to_integer (dst_type, expr));
      81                 :            : 
      82                 :          0 :     default:
      83                 :          0 :       gcc_assert (gcc::jit::active_playback_ctxt);
      84                 :          0 :       gcc::jit::active_playback_ctxt->add_error (NULL, "unhandled conversion");
      85                 :          0 :       fprintf (stderr, "input expression:\n");
      86                 :          0 :       debug_tree (expr);
      87                 :          0 :       fprintf (stderr, "requested type:\n");
      88                 :          0 :       debug_tree (dst_type);
      89                 :          0 :       return error_mark_node;
      90                 :            :     }
      91                 :            : }
      92                 :            : 
      93                 :            : namespace gcc {
      94                 :            : namespace jit {
      95                 :            : 
      96                 :            : /**********************************************************************
      97                 :            :  Playback.
      98                 :            :  **********************************************************************/
      99                 :            : 
     100                 :            : /* Build a STRING_CST tree for STR, or return NULL if it is NULL.
     101                 :            :    The TREE_TYPE is not initialized.  */
     102                 :            : 
     103                 :            : static tree
     104                 :        340 : build_string (const char *str)
     105                 :            : {
     106                 :        340 :   if (str)
     107                 :        260 :     return ::build_string (strlen (str), str);
     108                 :            :   else
     109                 :            :     return NULL_TREE;
     110                 :            : }
     111                 :            : 
     112                 :            : /* The constructor for gcc::jit::playback::context.  */
     113                 :            : 
     114                 :        983 : playback::context::context (recording::context *ctxt)
     115                 :            :   : log_user (ctxt->get_logger ()),
     116                 :        983 :     m_recording_ctxt (ctxt),
     117                 :        983 :     m_tempdir (NULL),
     118                 :        983 :     m_const_char_ptr (NULL)
     119                 :            : {
     120                 :        983 :   JIT_LOG_SCOPE (get_logger ());
     121                 :        983 :   m_functions.create (0);
     122                 :        983 :   m_globals.create (0);
     123                 :        983 :   m_source_files.create (0);
     124                 :        983 :   m_cached_locations.create (0);
     125                 :        983 : }
     126                 :            : 
     127                 :            : /* The destructor for gcc::jit::playback::context.  */
     128                 :            : 
     129                 :        983 : playback::context::~context ()
     130                 :            : {
     131                 :        983 :   JIT_LOG_SCOPE (get_logger ());
     132                 :            : 
     133                 :            :   /* Normally the playback::context is responsible for cleaning up the
     134                 :            :      tempdir (including "fake.so" within the filesystem).
     135                 :            : 
     136                 :            :      In the normal case, clean it up now.
     137                 :            : 
     138                 :            :      However m_tempdir can be NULL if the context has handed over
     139                 :            :      responsibility for the tempdir cleanup to the jit::result object, so
     140                 :            :      that the cleanup can be delayed (see PR jit/64206).  If that's the
     141                 :            :      case this "delete NULL;" is a no-op. */
     142                 :        983 :   delete m_tempdir;
     143                 :            : 
     144                 :        983 :   m_functions.release ();
     145                 :        983 : }
     146                 :            : 
     147                 :            : /* A playback::context can reference GC-managed pointers.  Mark them
     148                 :            :    ("by hand", rather than by gengtype).
     149                 :            : 
     150                 :            :    This is called on the active playback context (if any) by the
     151                 :            :    my_ggc_walker hook in the jit_root_table in dummy-frontend.c.  */
     152                 :            : 
     153                 :            : void
     154                 :     362651 : playback::context::
     155                 :            : gt_ggc_mx ()
     156                 :            : {
     157                 :     362651 :   int i;
     158                 :     362651 :   function *func;
     159                 :   17579430 :   FOR_EACH_VEC_ELT (m_functions, i, func)
     160                 :            :     {
     161                 :   17216779 :       if (ggc_test_and_set_mark (func))
     162                 :   17216779 :         func->gt_ggc_mx ();
     163                 :            :     }
     164                 :     362651 : }
     165                 :            : 
     166                 :            : /* Given an enum gcc_jit_types value, get a "tree" type.  */
     167                 :            : 
     168                 :            : tree
     169                 :       3284 : playback::context::
     170                 :            : get_tree_node_for_type (enum gcc_jit_types type_)
     171                 :            : {
     172                 :       3284 :   switch (type_)
     173                 :            :     {
     174                 :        968 :     case GCC_JIT_TYPE_VOID:
     175                 :        968 :       return void_type_node;
     176                 :            : 
     177                 :         55 :     case GCC_JIT_TYPE_VOID_PTR:
     178                 :         55 :       return ptr_type_node;
     179                 :            : 
     180                 :        597 :     case GCC_JIT_TYPE_BOOL:
     181                 :        597 :       return boolean_type_node;
     182                 :            : 
     183                 :        101 :     case GCC_JIT_TYPE_CHAR:
     184                 :        101 :       return char_type_node;
     185                 :         30 :     case GCC_JIT_TYPE_SIGNED_CHAR:
     186                 :         30 :       return signed_char_type_node;
     187                 :         41 :     case GCC_JIT_TYPE_UNSIGNED_CHAR:
     188                 :         41 :       return unsigned_char_type_node;
     189                 :            : 
     190                 :         30 :     case GCC_JIT_TYPE_SHORT:
     191                 :         30 :       return short_integer_type_node;
     192                 :         25 :     case GCC_JIT_TYPE_UNSIGNED_SHORT:
     193                 :         25 :       return short_unsigned_type_node;
     194                 :            : 
     195                 :        107 :     case GCC_JIT_TYPE_CONST_CHAR_PTR:
     196                 :        107 :       return m_const_char_ptr;
     197                 :            : 
     198                 :        863 :     case GCC_JIT_TYPE_INT:
     199                 :        863 :       return integer_type_node;
     200                 :         60 :     case GCC_JIT_TYPE_UNSIGNED_INT:
     201                 :         60 :       return unsigned_type_node;
     202                 :            : 
     203                 :         55 :     case GCC_JIT_TYPE_LONG:
     204                 :         55 :       return long_integer_type_node;
     205                 :         33 :     case GCC_JIT_TYPE_UNSIGNED_LONG:
     206                 :         33 :       return long_unsigned_type_node;
     207                 :            : 
     208                 :         25 :     case GCC_JIT_TYPE_LONG_LONG:
     209                 :         25 :       return long_long_integer_type_node;
     210                 :         27 :     case GCC_JIT_TYPE_UNSIGNED_LONG_LONG:
     211                 :         27 :       return long_long_unsigned_type_node;
     212                 :            : 
     213                 :         65 :     case GCC_JIT_TYPE_FLOAT:
     214                 :         65 :       return float_type_node;
     215                 :        102 :     case GCC_JIT_TYPE_DOUBLE:
     216                 :        102 :       return double_type_node;
     217                 :         15 :     case GCC_JIT_TYPE_LONG_DOUBLE:
     218                 :         15 :       return long_double_type_node;
     219                 :            : 
     220                 :         55 :     case GCC_JIT_TYPE_SIZE_T:
     221                 :         55 :       return size_type_node;
     222                 :            : 
     223                 :         15 :     case GCC_JIT_TYPE_FILE_PTR:
     224                 :         15 :       return fileptr_type_node;
     225                 :            : 
     226                 :          0 :     case GCC_JIT_TYPE_COMPLEX_FLOAT:
     227                 :          0 :       return complex_float_type_node;
     228                 :         15 :     case GCC_JIT_TYPE_COMPLEX_DOUBLE:
     229                 :         15 :       return complex_double_type_node;
     230                 :          0 :     case GCC_JIT_TYPE_COMPLEX_LONG_DOUBLE:
     231                 :          0 :       return complex_long_double_type_node;
     232                 :            :     }
     233                 :            : 
     234                 :            :   return NULL;
     235                 :            : }
     236                 :            : 
     237                 :            : /* Construct a playback::type instance (wrapping a tree) for the given
     238                 :            :    enum value.  */
     239                 :            : 
     240                 :            : playback::type *
     241                 :       3284 : playback::context::
     242                 :            : get_type (enum gcc_jit_types type_)
     243                 :            : {
     244                 :       3284 :   tree type_node = get_tree_node_for_type (type_);
     245                 :       3284 :   if (type_node == NULL)
     246                 :            :     {
     247                 :          0 :       add_error (NULL, "unrecognized (enum gcc_jit_types) value: %i", type_);
     248                 :          0 :       return NULL;
     249                 :            :     }
     250                 :            : 
     251                 :       3284 :   return new type (type_node);
     252                 :            : }
     253                 :            : 
     254                 :            : /* Construct a playback::type instance (wrapping a tree) for the given
     255                 :            :    array type.  */
     256                 :            : 
     257                 :            : playback::type *
     258                 :         75 : playback::context::
     259                 :            : new_array_type (playback::location *loc,
     260                 :            :                 playback::type *element_type,
     261                 :            :                 int num_elements)
     262                 :            : {
     263                 :         75 :   gcc_assert (element_type);
     264                 :            : 
     265                 :         75 :   tree t = build_array_type_nelts (element_type->as_tree (),
     266                 :            :                                    num_elements);
     267                 :         75 :   layout_type (t);
     268                 :            : 
     269                 :         75 :   if (loc)
     270                 :          0 :     set_tree_location (t, loc);
     271                 :            : 
     272                 :         75 :   return new type (t);
     273                 :            : }
     274                 :            : 
     275                 :            : /* Construct a playback::field instance (wrapping a tree).  */
     276                 :            : 
     277                 :            : playback::field *
     278                 :       1113 : playback::context::
     279                 :            : new_field (location *loc,
     280                 :            :            type *type,
     281                 :            :            const char *name)
     282                 :            : {
     283                 :       1113 :   gcc_assert (type);
     284                 :       1113 :   gcc_assert (name);
     285                 :            : 
     286                 :            :   /* compare with c/c-decl.c:grokfield and grokdeclarator.  */
     287                 :       1113 :   tree decl = build_decl (UNKNOWN_LOCATION, FIELD_DECL,
     288                 :            :                           get_identifier (name), type->as_tree ());
     289                 :            : 
     290                 :       1113 :   if (loc)
     291                 :          0 :     set_tree_location (decl, loc);
     292                 :            : 
     293                 :       1113 :   return new field (decl);
     294                 :            : }
     295                 :            : 
     296                 :            : /* Construct a playback::bitfield instance (wrapping a tree).  */
     297                 :            : 
     298                 :            : playback::field *
     299                 :         95 : playback::context::
     300                 :            : new_bitfield (location *loc,
     301                 :            :               type *type,
     302                 :            :               int width,
     303                 :            :               const char *name)
     304                 :            : {
     305                 :         95 :   gcc_assert (type);
     306                 :         95 :   gcc_assert (name);
     307                 :         95 :   gcc_assert (width);
     308                 :            : 
     309                 :            :   /* compare with c/c-decl.c:grokfield,  grokdeclarator and
     310                 :            :      check_bitfield_type_and_width.  */
     311                 :            : 
     312                 :         95 :   tree tree_type = type->as_tree ();
     313                 :         95 :   gcc_assert (INTEGRAL_TYPE_P (tree_type));
     314                 :         95 :   tree tree_width = build_int_cst (integer_type_node, width);
     315                 :         95 :   if (compare_tree_int (tree_width, TYPE_PRECISION (tree_type)) > 0)
     316                 :            :     {
     317                 :         10 :       add_error (
     318                 :            :         loc,
     319                 :            :         "width of bit-field %s (width: %i) is wider than its type (width: %i)",
     320                 :          5 :         name, width, TYPE_PRECISION (tree_type));
     321                 :          5 :       return NULL;
     322                 :            :     }
     323                 :            : 
     324                 :         90 :   tree decl = build_decl (UNKNOWN_LOCATION, FIELD_DECL,
     325                 :            :                           get_identifier (name), type->as_tree ());
     326                 :         90 :   DECL_NONADDRESSABLE_P (decl) = true;
     327                 :         90 :   DECL_INITIAL (decl) = tree_width;
     328                 :         90 :   SET_DECL_JIT_BIT_FIELD (decl);
     329                 :            : 
     330                 :         90 :   if (loc)
     331                 :          0 :     set_tree_location (decl, loc);
     332                 :            : 
     333                 :         90 :   return new field (decl);
     334                 :            : }
     335                 :            : 
     336                 :            : /* Construct a playback::compound_type instance (wrapping a tree).  */
     337                 :            : 
     338                 :            : playback::compound_type *
     339                 :        397 : playback::context::
     340                 :            : new_compound_type (location *loc,
     341                 :            :                    const char *name,
     342                 :            :                    bool is_struct) /* else is union */
     343                 :            : {
     344                 :        397 :   gcc_assert (name);
     345                 :            : 
     346                 :            :   /* Compare with c/c-decl.c: start_struct. */
     347                 :            : 
     348                 :        427 :   tree t = make_node (is_struct ? RECORD_TYPE : UNION_TYPE);
     349                 :        397 :   TYPE_NAME (t) = get_identifier (name);
     350                 :        397 :   TYPE_SIZE (t) = 0;
     351                 :            : 
     352                 :        397 :   if (loc)
     353                 :          0 :     set_tree_location (t, loc);
     354                 :            : 
     355                 :        397 :   return new compound_type (t);
     356                 :            : }
     357                 :            : 
     358                 :            : void
     359                 :        367 : playback::compound_type::set_fields (const auto_vec<playback::field *> *fields)
     360                 :            : {
     361                 :            :   /* Compare with c/c-decl.c: finish_struct. */
     362                 :        367 :   tree t = as_tree ();
     363                 :            : 
     364                 :        367 :   tree fieldlist = NULL;
     365                 :       3130 :   for (unsigned i = 0; i < fields->length (); i++)
     366                 :            :     {
     367                 :       1198 :       field *f = (*fields)[i];
     368                 :       1198 :       tree x = f->as_tree ();
     369                 :       1198 :       DECL_CONTEXT (x) = t;
     370                 :       1198 :       if (DECL_JIT_BIT_FIELD (x))
     371                 :            :         {
     372                 :         85 :           unsigned HOST_WIDE_INT width = tree_to_uhwi (DECL_INITIAL (x));
     373                 :         85 :           DECL_SIZE (x) = bitsize_int (width);
     374                 :         85 :           DECL_BIT_FIELD (x) = 1;
     375                 :            :         }
     376                 :       1198 :       fieldlist = chainon (x, fieldlist);
     377                 :            :     }
     378                 :        367 :   fieldlist = nreverse (fieldlist);
     379                 :        367 :   TYPE_FIELDS (t) = fieldlist;
     380                 :            : 
     381                 :        367 :   layout_type (t);
     382                 :        367 : }
     383                 :            : 
     384                 :            : /* Construct a playback::type instance (wrapping a tree) for a function
     385                 :            :    type.  */
     386                 :            : 
     387                 :            : playback::type *
     388                 :       1143 : playback::context::
     389                 :            : new_function_type (type *return_type,
     390                 :            :                    const auto_vec<type *> *param_types,
     391                 :            :                    int is_variadic)
     392                 :            : {
     393                 :       1143 :   int i;
     394                 :       1143 :   type *param_type;
     395                 :            : 
     396                 :       1143 :   tree *arg_types = (tree *)xcalloc(param_types->length (), sizeof(tree*));
     397                 :            : 
     398                 :       2646 :   FOR_EACH_VEC_ELT (*param_types, i, param_type)
     399                 :        360 :     arg_types[i] = param_type->as_tree ();
     400                 :            : 
     401                 :       1143 :   tree fn_type;
     402                 :       1143 :   if (is_variadic)
     403                 :         15 :     fn_type =
     404                 :         15 :       build_varargs_function_type_array (return_type->as_tree (),
     405                 :         15 :                                          param_types->length (),
     406                 :            :                                          arg_types);
     407                 :            :   else
     408                 :       2256 :     fn_type = build_function_type_array (return_type->as_tree (),
     409                 :       1288 :                                          param_types->length (),
     410                 :            :                                          arg_types);
     411                 :       1143 :   free (arg_types);
     412                 :            : 
     413                 :       1143 :   return new type (fn_type);
     414                 :            : }
     415                 :            : 
     416                 :            : /* Construct a playback::param instance (wrapping a tree).  */
     417                 :            : 
     418                 :            : playback::param *
     419                 :       4264 : playback::context::
     420                 :            : new_param (location *loc,
     421                 :            :            type *type,
     422                 :            :            const char *name)
     423                 :            : {
     424                 :       4264 :   gcc_assert (type);
     425                 :       4264 :   gcc_assert (name);
     426                 :       4264 :   tree inner = build_decl (UNKNOWN_LOCATION, PARM_DECL,
     427                 :            :                            get_identifier (name), type->as_tree ());
     428                 :       4264 :   if (loc)
     429                 :         29 :     set_tree_location (inner, loc);
     430                 :            : 
     431                 :       4264 :   return new param (this, inner);
     432                 :            : }
     433                 :            : 
     434                 :            : /* Construct a playback::function instance.  */
     435                 :            : 
     436                 :            : playback::function *
     437                 :       3910 : playback::context::
     438                 :            : new_function (location *loc,
     439                 :            :               enum gcc_jit_function_kind kind,
     440                 :            :               type *return_type,
     441                 :            :               const char *name,
     442                 :            :               const auto_vec<param *> *params,
     443                 :            :               int is_variadic,
     444                 :            :               enum built_in_function builtin_id)
     445                 :            : {
     446                 :       3910 :   int i;
     447                 :       3910 :   param *param;
     448                 :            : 
     449                 :            :   //can return_type be NULL?
     450                 :       3910 :   gcc_assert (name);
     451                 :            : 
     452                 :       3910 :   tree *arg_types = (tree *)xcalloc(params->length (), sizeof(tree*));
     453                 :      12084 :   FOR_EACH_VEC_ELT (*params, i, param)
     454                 :       4264 :     arg_types[i] = TREE_TYPE (param->as_tree ());
     455                 :            : 
     456                 :       3910 :   tree fn_type;
     457                 :       3910 :   if (is_variadic)
     458                 :        204 :     fn_type = build_varargs_function_type_array (return_type->as_tree (),
     459                 :        154 :                                                  params->length (), arg_types);
     460                 :            :   else
     461                 :       7616 :     fn_type = build_function_type_array (return_type->as_tree (),
     462                 :       6197 :                                          params->length (), arg_types);
     463                 :       3910 :   free (arg_types);
     464                 :            : 
     465                 :            :   /* FIXME: this uses input_location: */
     466                 :       3910 :   tree fndecl = build_fn_decl (name, fn_type);
     467                 :            : 
     468                 :       3910 :   if (loc)
     469                 :         56 :     set_tree_location (fndecl, loc);
     470                 :            : 
     471                 :       3910 :   tree resdecl = build_decl (UNKNOWN_LOCATION, RESULT_DECL,
     472                 :            :                              NULL_TREE, return_type->as_tree ());
     473                 :       3910 :   DECL_ARTIFICIAL (resdecl) = 1;
     474                 :       3910 :   DECL_IGNORED_P (resdecl) = 1;
     475                 :       3910 :   DECL_RESULT (fndecl) = resdecl;
     476                 :            : 
     477                 :       3910 :   if (builtin_id)
     478                 :            :     {
     479                 :       1148 :       gcc_assert (loc == NULL);
     480                 :       1148 :       DECL_SOURCE_LOCATION (fndecl) = BUILTINS_LOCATION;
     481                 :            : 
     482                 :       1148 :       built_in_class fclass = builtins_manager::get_class (builtin_id);
     483                 :       1148 :       set_decl_built_in_function (fndecl, fclass, builtin_id);
     484                 :       1148 :       set_builtin_decl (builtin_id, fndecl,
     485                 :       1148 :                         builtins_manager::implicit_p (builtin_id));
     486                 :            : 
     487                 :       1148 :       builtins_manager *bm = get_builtins_manager ();
     488                 :       1148 :       tree attrs = bm->get_attrs_tree (builtin_id);
     489                 :       1148 :       if (attrs)
     490                 :       1148 :         decl_attributes (&fndecl, attrs, ATTR_FLAG_BUILT_IN);
     491                 :            :       else
     492                 :          0 :         decl_attributes (&fndecl, NULL_TREE, 0);
     493                 :            :     }
     494                 :            : 
     495                 :       3910 :   if (kind != GCC_JIT_FUNCTION_IMPORTED)
     496                 :            :     {
     497                 :            :       tree param_decl_list = NULL;
     498                 :       6290 :       FOR_EACH_VEC_ELT (*params, i, param)
     499                 :            :         {
     500                 :       3704 :           param_decl_list = chainon (param->as_tree (), param_decl_list);
     501                 :            :         }
     502                 :            : 
     503                 :            :       /* The param list was created in reverse order; fix it: */
     504                 :       2586 :       param_decl_list = nreverse (param_decl_list);
     505                 :            : 
     506                 :       2586 :       tree t;
     507                 :       8876 :       for (t = param_decl_list; t; t = DECL_CHAIN (t))
     508                 :            :         {
     509                 :       3704 :           DECL_CONTEXT (t) = fndecl;
     510                 :       3704 :           DECL_ARG_TYPE (t) = TREE_TYPE (t);
     511                 :            :         }
     512                 :            : 
     513                 :            :       /* Set it up on DECL_ARGUMENTS */
     514                 :       2586 :       DECL_ARGUMENTS(fndecl) = param_decl_list;
     515                 :            :     }
     516                 :            : 
     517                 :       3910 :   if (kind == GCC_JIT_FUNCTION_ALWAYS_INLINE)
     518                 :            :     {
     519                 :         15 :       DECL_DECLARED_INLINE_P (fndecl) = 1;
     520                 :            : 
     521                 :            :       /* Add attribute "always_inline": */
     522                 :         15 :       DECL_ATTRIBUTES (fndecl) =
     523                 :         15 :         tree_cons (get_identifier ("always_inline"),
     524                 :            :                    NULL,
     525                 :         15 :                    DECL_ATTRIBUTES (fndecl));
     526                 :            :     }
     527                 :            : 
     528                 :       3910 :   function *func = new function (this, fndecl, kind);
     529                 :       3910 :   m_functions.safe_push (func);
     530                 :       3910 :   return func;
     531                 :            : }
     532                 :            : 
     533                 :            : /* In use by new_global and new_global_initialized.  */
     534                 :            : 
     535                 :            : tree
     536                 :        136 : playback::context::
     537                 :            : global_new_decl (location *loc,
     538                 :            :                  enum gcc_jit_global_kind kind,
     539                 :            :                  type *type,
     540                 :            :                  const char *name)
     541                 :            : {
     542                 :        136 :   gcc_assert (type);
     543                 :        136 :   gcc_assert (name);
     544                 :        136 :   tree inner = build_decl (UNKNOWN_LOCATION, VAR_DECL,
     545                 :            :                            get_identifier (name),
     546                 :            :                            type->as_tree ());
     547                 :        136 :   TREE_PUBLIC (inner) = (kind != GCC_JIT_GLOBAL_INTERNAL);
     548                 :        136 :   DECL_COMMON (inner) = 1;
     549                 :        136 :   switch (kind)
     550                 :            :     {
     551                 :          0 :     default:
     552                 :          0 :       gcc_unreachable ();
     553                 :            : 
     554                 :         55 :     case GCC_JIT_GLOBAL_EXPORTED:
     555                 :         55 :       TREE_STATIC (inner) = 1;
     556                 :         55 :       break;
     557                 :            : 
     558                 :         36 :     case GCC_JIT_GLOBAL_INTERNAL:
     559                 :         36 :       TREE_STATIC (inner) = 1;
     560                 :         36 :       break;
     561                 :            : 
     562                 :         45 :     case GCC_JIT_GLOBAL_IMPORTED:
     563                 :         45 :       DECL_EXTERNAL (inner) = 1;
     564                 :         45 :       break;
     565                 :            :     }
     566                 :            : 
     567                 :        136 :   if (loc)
     568                 :          5 :     set_tree_location (inner, loc);
     569                 :            : 
     570                 :        136 :   return inner;
     571                 :            : }
     572                 :            : 
     573                 :            : /* In use by new_global and new_global_initialized.  */
     574                 :            : 
     575                 :            : playback::lvalue *
     576                 :        136 : playback::context::
     577                 :            : global_finalize_lvalue (tree inner)
     578                 :            : {
     579                 :        136 :   m_globals.safe_push (inner);
     580                 :            : 
     581                 :        136 :   return new lvalue (this, inner);
     582                 :            : }
     583                 :            : 
     584                 :            : /* Construct a playback::lvalue instance (wrapping a tree).  */
     585                 :            : 
     586                 :            : playback::lvalue *
     587                 :        121 : playback::context::
     588                 :            : new_global (location *loc,
     589                 :            :             enum gcc_jit_global_kind kind,
     590                 :            :             type *type,
     591                 :            :             const char *name)
     592                 :            : {
     593                 :        121 :   tree inner = global_new_decl (loc, kind, type, name);
     594                 :            : 
     595                 :        121 :   return global_finalize_lvalue (inner);
     596                 :            : }
     597                 :            : 
     598                 :            : /* Fill 'constructor_elements' with the memory content of
     599                 :            :    'initializer'.  Each element of the initializer is of the size of
     600                 :            :    type T.  In use by new_global_initialized.*/
     601                 :            : 
     602                 :            : template<typename T>
     603                 :            : static void
     604                 :         15 : load_blob_in_ctor (vec<constructor_elt, va_gc> *&constructor_elements,
     605                 :            :                    size_t num_elem,
     606                 :            :                    const void *initializer)
     607                 :            : {
     608                 :            :   /* Loosely based on 'output_init_element' c-typeck.c:9691.  */
     609                 :         15 :   const T *p = (const T *)initializer;
     610                 :         15 :   tree node = make_unsigned_type (BITS_PER_UNIT * sizeof (T));
     611                 :      20555 :   for (size_t i = 0; i < num_elem; i++)
     612                 :            :     {
     613                 :      41080 :       constructor_elt celt =
     614                 :      20540 :         { build_int_cst (long_unsigned_type_node, i),
     615                 :      20540 :           build_int_cst (node, p[i]) };
     616                 :      20540 :       vec_safe_push (constructor_elements, celt);
     617                 :            :     }
     618                 :         15 : }
     619                 :            : 
     620                 :            : /* Construct an initialized playback::lvalue instance (wrapping a
     621                 :            :    tree).  */
     622                 :            : 
     623                 :            : playback::lvalue *
     624                 :         15 : playback::context::
     625                 :            : new_global_initialized (location *loc,
     626                 :            :                         enum gcc_jit_global_kind kind,
     627                 :            :                         type *type,
     628                 :            :                         size_t element_size,
     629                 :            :                         size_t initializer_num_elem,
     630                 :            :                         const void *initializer,
     631                 :            :                         const char *name)
     632                 :            : {
     633                 :         15 :   tree inner = global_new_decl (loc, kind, type, name);
     634                 :            : 
     635                 :         15 :   vec<constructor_elt, va_gc> *constructor_elements = NULL;
     636                 :            : 
     637                 :         15 :   switch (element_size)
     638                 :            :     {
     639                 :         10 :     case 1:
     640                 :         10 :       load_blob_in_ctor<uint8_t> (constructor_elements, initializer_num_elem,
     641                 :            :                                   initializer);
     642                 :         10 :       break;
     643                 :          0 :     case 2:
     644                 :          0 :       load_blob_in_ctor<uint16_t> (constructor_elements, initializer_num_elem,
     645                 :            :                                    initializer);
     646                 :          0 :       break;
     647                 :          5 :     case 4:
     648                 :          5 :       load_blob_in_ctor<uint32_t> (constructor_elements, initializer_num_elem,
     649                 :            :                                    initializer);
     650                 :          5 :       break;
     651                 :          0 :     case 8:
     652                 :          0 :       load_blob_in_ctor<uint64_t> (constructor_elements, initializer_num_elem,
     653                 :            :                                    initializer);
     654                 :          0 :       break;
     655                 :          0 :     default:
     656                 :            :       /* This function is serving on sizes returned by 'get_size',
     657                 :            :          these are all covered by the previous cases.  */
     658                 :          0 :       gcc_unreachable ();
     659                 :            :     }
     660                 :            :   /* Compare with 'pop_init_level' c-typeck.c:8780.  */
     661                 :         15 :   tree ctor = build_constructor (type->as_tree (), constructor_elements);
     662                 :         15 :   constructor_elements = NULL;
     663                 :            : 
     664                 :            :   /* Compare with 'store_init_value' c-typeck.c:7555.  */
     665                 :         15 :   DECL_INITIAL (inner) = ctor;
     666                 :            : 
     667                 :         15 :   return global_finalize_lvalue (inner);
     668                 :            : }
     669                 :            : 
     670                 :            : /* Implementation of the various
     671                 :            :       gcc::jit::playback::context::new_rvalue_from_const <HOST_TYPE>
     672                 :            :    methods.
     673                 :            :    Each of these constructs a playback::rvalue instance (wrapping a tree).
     674                 :            : 
     675                 :            :    These specializations are required to be in the same namespace
     676                 :            :    as the template, hence we now have to enter the gcc::jit::playback
     677                 :            :    namespace.  */
     678                 :            : 
     679                 :            : namespace playback
     680                 :            : {
     681                 :            : 
     682                 :            : /* Specialization of making an rvalue from a const, for host <int>.  */
     683                 :            : 
     684                 :            : template <>
     685                 :            : rvalue *
     686                 :       3844 : context::
     687                 :            : new_rvalue_from_const <int> (type *type,
     688                 :            :                              int value)
     689                 :            : {
     690                 :            :   // FIXME: type-checking, or coercion?
     691                 :       3844 :   tree inner_type = type->as_tree ();
     692                 :       3844 :   if (INTEGRAL_TYPE_P (inner_type))
     693                 :            :     {
     694                 :       3642 :       tree inner = build_int_cst (inner_type, value);
     695                 :       3642 :       return new rvalue (this, inner);
     696                 :            :     }
     697                 :            :   else
     698                 :            :     {
     699                 :        202 :       REAL_VALUE_TYPE real_value;
     700                 :        202 :       real_from_integer (&real_value, VOIDmode, value, SIGNED);
     701                 :        202 :       tree inner = build_real (inner_type, real_value);
     702                 :        202 :       return new rvalue (this, inner);
     703                 :            :     }
     704                 :            : }
     705                 :            : 
     706                 :            : /* Specialization of making an rvalue from a const, for host <long>.  */
     707                 :            : 
     708                 :            : template <>
     709                 :            : rvalue *
     710                 :         45 : context::
     711                 :            : new_rvalue_from_const <long> (type *type,
     712                 :            :                               long value)
     713                 :            : {
     714                 :            :   // FIXME: type-checking, or coercion?
     715                 :         45 :   tree inner_type = type->as_tree ();
     716                 :         45 :   if (INTEGRAL_TYPE_P (inner_type))
     717                 :            :     {
     718                 :         45 :       tree inner = build_int_cst (inner_type, value);
     719                 :         45 :       return new rvalue (this, inner);
     720                 :            :     }
     721                 :            :   else
     722                 :            :     {
     723                 :          0 :       REAL_VALUE_TYPE real_value;
     724                 :          0 :       real_from_integer (&real_value, VOIDmode, value, SIGNED);
     725                 :          0 :       tree inner = build_real (inner_type, real_value);
     726                 :          0 :       return new rvalue (this, inner);
     727                 :            :     }
     728                 :            : }
     729                 :            : 
     730                 :            : /* Specialization of making an rvalue from a const, for host <double>.  */
     731                 :            : 
     732                 :            : template <>
     733                 :            : rvalue *
     734                 :        105 : context::
     735                 :            : new_rvalue_from_const <double> (type *type,
     736                 :            :                                 double value)
     737                 :            : {
     738                 :            :   // FIXME: type-checking, or coercion?
     739                 :        105 :   tree inner_type = type->as_tree ();
     740                 :            : 
     741                 :            :   /* We have a "double", we want a REAL_VALUE_TYPE.
     742                 :            : 
     743                 :            :      real.c:real_from_target appears to require the representation to be
     744                 :            :      split into 32-bit values, and then sent as an pair of host long
     745                 :            :      ints.  */
     746                 :        105 :   REAL_VALUE_TYPE real_value;
     747                 :        105 :   union
     748                 :            :   {
     749                 :            :     double as_double;
     750                 :            :     uint32_t as_uint32s[2];
     751                 :            :   } u;
     752                 :        105 :   u.as_double = value;
     753                 :        105 :   long int as_long_ints[2];
     754                 :        105 :   as_long_ints[0] = u.as_uint32s[0];
     755                 :        105 :   as_long_ints[1] = u.as_uint32s[1];
     756                 :        105 :   real_from_target (&real_value, as_long_ints, DFmode);
     757                 :        105 :   tree inner = build_real (inner_type, real_value);
     758                 :        105 :   return new rvalue (this, inner);
     759                 :            : }
     760                 :            : 
     761                 :            : /* Specialization of making an rvalue from a const, for host <void *>.  */
     762                 :            : 
     763                 :            : template <>
     764                 :            : rvalue *
     765                 :        110 : context::
     766                 :            : new_rvalue_from_const <void *> (type *type,
     767                 :            :                                 void *value)
     768                 :            : {
     769                 :        110 :   tree inner_type = type->as_tree ();
     770                 :            :   /* FIXME: how to ensure we have a wide enough type?  */
     771                 :        110 :   tree inner = build_int_cstu (inner_type, (unsigned HOST_WIDE_INT)value);
     772                 :        110 :   return new rvalue (this, inner);
     773                 :            : }
     774                 :            : 
     775                 :            : /* We're done implementing the specializations of
     776                 :            :       gcc::jit::playback::context::new_rvalue_from_const <T>
     777                 :            :    so we can exit the gcc::jit::playback namespace.  */
     778                 :            : 
     779                 :            : } // namespace playback
     780                 :            : 
     781                 :            : /* Construct a playback::rvalue instance (wrapping a tree).  */
     782                 :            : 
     783                 :            : playback::rvalue *
     784                 :        157 : playback::context::
     785                 :            : new_string_literal (const char *value)
     786                 :            : {
     787                 :            :   /* Compare with c-family/c-common.c: fix_string_type.  */
     788                 :        157 :   size_t len = strlen (value);
     789                 :        157 :   tree i_type = build_index_type (size_int (len));
     790                 :        157 :   tree a_type = build_array_type (char_type_node, i_type);
     791                 :            :   /* build_string len parameter must include NUL terminator when
     792                 :            :      building C strings.  */
     793                 :        157 :   tree t_str = ::build_string (len + 1, value);
     794                 :        157 :   TREE_TYPE (t_str) = a_type;
     795                 :            : 
     796                 :            :   /* Convert to (const char*), loosely based on
     797                 :            :      c/c-typeck.c: array_to_pointer_conversion,
     798                 :            :      by taking address of start of string.  */
     799                 :        157 :   tree t_addr = build1 (ADDR_EXPR, m_const_char_ptr, t_str);
     800                 :            : 
     801                 :        157 :   return new rvalue (this, t_addr);
     802                 :            : }
     803                 :            : 
     804                 :            : /* Construct a playback::rvalue instance (wrapping a tree) for a
     805                 :            :    vector.  */
     806                 :            : 
     807                 :            : playback::rvalue *
     808                 :         75 : playback::context::new_rvalue_from_vector (location *,
     809                 :            :                                            type *type,
     810                 :            :                                            const auto_vec<rvalue *> &elements)
     811                 :            : {
     812                 :         75 :   vec<constructor_elt, va_gc> *v;
     813                 :        150 :   vec_alloc (v, elements.length ());
     814                 :        750 :   for (unsigned i = 0; i < elements.length (); ++i)
     815                 :        300 :     CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, elements[i]->as_tree ());
     816                 :         75 :   tree t_ctor = build_constructor (type->as_tree (), v);
     817                 :         75 :   return new rvalue (this, t_ctor);
     818                 :            : }
     819                 :            : 
     820                 :            : /* Coerce a tree expression into a boolean tree expression.  */
     821                 :            : 
     822                 :            : tree
     823                 :        615 : playback::context::
     824                 :            : as_truth_value (tree expr, location *loc)
     825                 :            : {
     826                 :            :   /* Compare to c-typeck.c:c_objc_common_truthvalue_conversion */
     827                 :        615 :   tree typed_zero = fold_build1 (CONVERT_EXPR,
     828                 :            :                                  TREE_TYPE (expr),
     829                 :            :                                  integer_zero_node);
     830                 :        615 :   if (loc)
     831                 :          0 :     set_tree_location (typed_zero, loc);
     832                 :            : 
     833                 :        615 :   expr = build2 (NE_EXPR, integer_type_node, expr, typed_zero);
     834                 :        615 :   if (loc)
     835                 :          0 :     set_tree_location (expr, loc);
     836                 :            : 
     837                 :        615 :   return expr;
     838                 :            : }
     839                 :            : 
     840                 :            : /* Add a "top-level" basic asm statement (i.e. one outside of any functions)
     841                 :            :    containing ASM_STMTS.
     842                 :            : 
     843                 :            :    Compare with c_parser_asm_definition.  */
     844                 :            : 
     845                 :            : void
     846                 :         10 : playback::context::add_top_level_asm (const char *asm_stmts)
     847                 :            : {
     848                 :         10 :   tree asm_str = build_string (asm_stmts);
     849                 :         10 :   symtab->finalize_toplevel_asm (asm_str);
     850                 :         10 : }
     851                 :            : 
     852                 :            : /* Construct a playback::rvalue instance (wrapping a tree) for a
     853                 :            :    unary op.  */
     854                 :            : 
     855                 :            : playback::rvalue *
     856                 :         93 : playback::context::
     857                 :            : new_unary_op (location *loc,
     858                 :            :               enum gcc_jit_unary_op op,
     859                 :            :               type *result_type,
     860                 :            :               rvalue *a)
     861                 :            : {
     862                 :            :   // FIXME: type-checking, or coercion?
     863                 :         93 :   enum tree_code inner_op;
     864                 :            : 
     865                 :         93 :   gcc_assert (result_type);
     866                 :         93 :   gcc_assert (a);
     867                 :            : 
     868                 :         93 :   tree node = a->as_tree ();
     869                 :         93 :   tree inner_result = NULL;
     870                 :            : 
     871                 :         93 :   switch (op)
     872                 :            :     {
     873                 :          0 :     default:
     874                 :          0 :       add_error (loc, "unrecognized (enum gcc_jit_unary_op) value: %i", op);
     875                 :          0 :       return NULL;
     876                 :            : 
     877                 :            :     case GCC_JIT_UNARY_OP_MINUS:
     878                 :            :       inner_op = NEGATE_EXPR;
     879                 :            :       break;
     880                 :            : 
     881                 :         15 :     case GCC_JIT_UNARY_OP_BITWISE_NEGATE:
     882                 :         15 :       inner_op = BIT_NOT_EXPR;
     883                 :         15 :       break;
     884                 :            : 
     885                 :         15 :     case GCC_JIT_UNARY_OP_LOGICAL_NEGATE:
     886                 :         15 :       node = as_truth_value (node, loc);
     887                 :         15 :       inner_result = invert_truthvalue (node);
     888                 :         15 :       if (loc)
     889                 :          0 :         set_tree_location (inner_result, loc);
     890                 :         15 :       return new rvalue (this, inner_result);
     891                 :            : 
     892                 :         15 :     case GCC_JIT_UNARY_OP_ABS:
     893                 :         15 :       inner_op = ABS_EXPR;
     894                 :         15 :       break;
     895                 :            :     }
     896                 :            : 
     897                 :         78 :   inner_result = build1 (inner_op,
     898                 :            :                          result_type->as_tree (),
     899                 :            :                          node);
     900                 :         78 :   if (loc)
     901                 :          0 :     set_tree_location (inner_result, loc);
     902                 :            : 
     903                 :         78 :   return new rvalue (this, inner_result);
     904                 :            : }
     905                 :            : 
     906                 :            : /* Construct a playback::rvalue instance (wrapping a tree) for a
     907                 :            :    binary op.  */
     908                 :            : 
     909                 :            : playback::rvalue *
     910                 :       3469 : playback::context::
     911                 :            : new_binary_op (location *loc,
     912                 :            :                enum gcc_jit_binary_op op,
     913                 :            :                type *result_type,
     914                 :            :                rvalue *a, rvalue *b)
     915                 :            : {
     916                 :            :   // FIXME: type-checking, or coercion?
     917                 :       3469 :   enum tree_code inner_op;
     918                 :            : 
     919                 :       3469 :   gcc_assert (result_type);
     920                 :       3469 :   gcc_assert (a);
     921                 :       3469 :   gcc_assert (b);
     922                 :            : 
     923                 :       3469 :   tree node_a = a->as_tree ();
     924                 :       3469 :   tree node_b = b->as_tree ();
     925                 :            : 
     926                 :       3469 :   switch (op)
     927                 :            :     {
     928                 :          0 :     default:
     929                 :          0 :       add_error (loc, "unrecognized (enum gcc_jit_binary_op) value: %i", op);
     930                 :          0 :       return NULL;
     931                 :            : 
     932                 :            :     case GCC_JIT_BINARY_OP_PLUS:
     933                 :            :       inner_op = PLUS_EXPR;
     934                 :            :       break;
     935                 :            : 
     936                 :        248 :     case GCC_JIT_BINARY_OP_MINUS:
     937                 :        248 :       inner_op = MINUS_EXPR;
     938                 :        248 :       break;
     939                 :            : 
     940                 :       1160 :     case GCC_JIT_BINARY_OP_MULT:
     941                 :       1160 :       inner_op = MULT_EXPR;
     942                 :       1160 :       break;
     943                 :            : 
     944                 :        144 :     case GCC_JIT_BINARY_OP_DIVIDE:
     945                 :        144 :       if (FLOAT_TYPE_P (result_type->as_tree ()))
     946                 :            :         /* Floating-point division: */
     947                 :            :         inner_op = RDIV_EXPR;
     948                 :            :       else
     949                 :            :         /* Truncating to zero: */
     950                 :            :         inner_op = TRUNC_DIV_EXPR;
     951                 :            :       break;
     952                 :            : 
     953                 :         15 :     case GCC_JIT_BINARY_OP_MODULO:
     954                 :         15 :       inner_op = TRUNC_MOD_EXPR;
     955                 :         15 :       break;
     956                 :            : 
     957                 :        180 :     case GCC_JIT_BINARY_OP_BITWISE_AND:
     958                 :        180 :       inner_op = BIT_AND_EXPR;
     959                 :        180 :       break;
     960                 :            : 
     961                 :         15 :     case GCC_JIT_BINARY_OP_BITWISE_XOR:
     962                 :         15 :       inner_op = BIT_XOR_EXPR;
     963                 :         15 :       break;
     964                 :            : 
     965                 :         15 :     case GCC_JIT_BINARY_OP_BITWISE_OR:
     966                 :         15 :       inner_op = BIT_IOR_EXPR;
     967                 :         15 :       break;
     968                 :            : 
     969                 :        240 :     case GCC_JIT_BINARY_OP_LOGICAL_AND:
     970                 :        240 :       node_a = as_truth_value (node_a, loc);
     971                 :        240 :       node_b = as_truth_value (node_b, loc);
     972                 :        240 :       inner_op = TRUTH_ANDIF_EXPR;
     973                 :        240 :       break;
     974                 :            : 
     975                 :         60 :     case GCC_JIT_BINARY_OP_LOGICAL_OR:
     976                 :         60 :       node_a = as_truth_value (node_a, loc);
     977                 :         60 :       node_b = as_truth_value (node_b, loc);
     978                 :         60 :       inner_op = TRUTH_ORIF_EXPR;
     979                 :         60 :       break;
     980                 :            : 
     981                 :         15 :     case GCC_JIT_BINARY_OP_LSHIFT:
     982                 :         15 :       inner_op = LSHIFT_EXPR;
     983                 :         15 :       break;
     984                 :            : 
     985                 :         15 :     case GCC_JIT_BINARY_OP_RSHIFT:
     986                 :         15 :       inner_op = RSHIFT_EXPR;
     987                 :         15 :       break;
     988                 :            :     }
     989                 :            : 
     990                 :       3469 :   tree inner_expr = build2 (inner_op,
     991                 :            :                             result_type->as_tree (),
     992                 :            :                             node_a,
     993                 :            :                             node_b);
     994                 :       3469 :   if (loc)
     995                 :        265 :     set_tree_location (inner_expr, loc);
     996                 :            : 
     997                 :       3469 :   return new rvalue (this, inner_expr);
     998                 :            : }
     999                 :            : 
    1000                 :            : /* Construct a playback::rvalue instance (wrapping a tree) for a
    1001                 :            :    comparison.  */
    1002                 :            : 
    1003                 :            : playback::rvalue *
    1004                 :       1244 : playback::context::
    1005                 :            : new_comparison (location *loc,
    1006                 :            :                 enum gcc_jit_comparison op,
    1007                 :            :                 rvalue *a, rvalue *b)
    1008                 :            : {
    1009                 :            :   // FIXME: type-checking, or coercion?
    1010                 :       1244 :   enum tree_code inner_op;
    1011                 :            : 
    1012                 :       1244 :   gcc_assert (a);
    1013                 :       1244 :   gcc_assert (b);
    1014                 :            : 
    1015                 :       1244 :   switch (op)
    1016                 :            :     {
    1017                 :          0 :     default:
    1018                 :          0 :       add_error (loc, "unrecognized (enum gcc_jit_comparison) value: %i", op);
    1019                 :          0 :       return NULL;
    1020                 :            : 
    1021                 :            :     case GCC_JIT_COMPARISON_EQ:
    1022                 :            :       inner_op = EQ_EXPR;
    1023                 :            :       break;
    1024                 :            :     case GCC_JIT_COMPARISON_NE:
    1025                 :            :       inner_op = NE_EXPR;
    1026                 :            :       break;
    1027                 :            :     case GCC_JIT_COMPARISON_LT:
    1028                 :            :       inner_op = LT_EXPR;
    1029                 :            :       break;
    1030                 :            :     case GCC_JIT_COMPARISON_LE:
    1031                 :            :       inner_op = LE_EXPR;
    1032                 :            :       break;
    1033                 :            :     case GCC_JIT_COMPARISON_GT:
    1034                 :            :       inner_op = GT_EXPR;
    1035                 :            :       break;
    1036                 :            :     case GCC_JIT_COMPARISON_GE:
    1037                 :            :       inner_op = GE_EXPR;
    1038                 :            :       break;
    1039                 :            :     }
    1040                 :            : 
    1041                 :       1244 :   tree inner_expr = build2 (inner_op,
    1042                 :            :                             boolean_type_node,
    1043                 :            :                             a->as_tree (),
    1044                 :            :                             b->as_tree ());
    1045                 :       1244 :   if (loc)
    1046                 :         21 :     set_tree_location (inner_expr, loc);
    1047                 :       1244 :   return new rvalue (this, inner_expr);
    1048                 :            : }
    1049                 :            : 
    1050                 :            : /* Construct a playback::rvalue instance (wrapping a tree) for a
    1051                 :            :    function call.  */
    1052                 :            : 
    1053                 :            : playback::rvalue *
    1054                 :        715 : playback::context::
    1055                 :            : build_call (location *loc,
    1056                 :            :             tree fn_ptr,
    1057                 :            :             const auto_vec<rvalue *> *args,
    1058                 :            :             bool require_tail_call)
    1059                 :            : {
    1060                 :        715 :   vec<tree, va_gc> *tree_args;
    1061                 :       1375 :   vec_alloc (tree_args, args->length ());
    1062                 :       3549 :   for (unsigned i = 0; i < args->length (); i++)
    1063                 :       1087 :     tree_args->quick_push ((*args)[i]->as_tree ());
    1064                 :            : 
    1065                 :        715 :   if (loc)
    1066                 :         37 :     set_tree_location (fn_ptr, loc);
    1067                 :            : 
    1068                 :        715 :   tree fn = TREE_TYPE (fn_ptr);
    1069                 :        715 :   tree fn_type = TREE_TYPE (fn);
    1070                 :        715 :   tree return_type = TREE_TYPE (fn_type);
    1071                 :            : 
    1072                 :        715 :   tree call = build_call_vec (return_type,
    1073                 :            :                               fn_ptr, tree_args);
    1074                 :            : 
    1075                 :        715 :   if (require_tail_call)
    1076                 :         20 :     CALL_EXPR_MUST_TAIL_CALL (call) = 1;
    1077                 :            : 
    1078                 :        715 :   return new rvalue (this, call);
    1079                 :            : 
    1080                 :            :   /* see c-typeck.c: build_function_call
    1081                 :            :      which calls build_function_call_vec
    1082                 :            : 
    1083                 :            :      which does lots of checking, then:
    1084                 :            :     result = build_call_array_loc (loc, TREE_TYPE (fntype),
    1085                 :            :                                    function, nargs, argarray);
    1086                 :            :     which is in tree.c
    1087                 :            :     (see also build_call_vec)
    1088                 :            :    */
    1089                 :            : }
    1090                 :            : 
    1091                 :            : /* Construct a playback::rvalue instance (wrapping a tree) for a
    1092                 :            :    call to a specific function.  */
    1093                 :            : 
    1094                 :            : playback::rvalue *
    1095                 :        700 : playback::context::
    1096                 :            : new_call (location *loc,
    1097                 :            :           function *func,
    1098                 :            :           const auto_vec<rvalue *> *args,
    1099                 :            :           bool require_tail_call)
    1100                 :            : {
    1101                 :        700 :   tree fndecl;
    1102                 :            : 
    1103                 :        700 :   gcc_assert (func);
    1104                 :            : 
    1105                 :        700 :   fndecl = func->as_fndecl ();
    1106                 :            : 
    1107                 :        700 :   tree fntype = TREE_TYPE (fndecl);
    1108                 :            : 
    1109                 :        700 :   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
    1110                 :            : 
    1111                 :        700 :   return build_call (loc, fn, args, require_tail_call);
    1112                 :            : }
    1113                 :            : 
    1114                 :            : /* Construct a playback::rvalue instance (wrapping a tree) for a
    1115                 :            :    call through a function pointer.  */
    1116                 :            : 
    1117                 :            : playback::rvalue *
    1118                 :         15 : playback::context::
    1119                 :            : new_call_through_ptr (location *loc,
    1120                 :            :                       rvalue *fn_ptr,
    1121                 :            :                       const auto_vec<rvalue *> *args,
    1122                 :            :                       bool require_tail_call)
    1123                 :            : {
    1124                 :         15 :   gcc_assert (fn_ptr);
    1125                 :         15 :   tree t_fn_ptr = fn_ptr->as_tree ();
    1126                 :            : 
    1127                 :         15 :   return build_call (loc, t_fn_ptr, args, require_tail_call);
    1128                 :            : }
    1129                 :            : 
    1130                 :            : /* Construct a tree for a cast.  */
    1131                 :            : 
    1132                 :            : tree
    1133                 :        309 : playback::context::build_cast (playback::location *loc,
    1134                 :            :                                playback::rvalue *expr,
    1135                 :            :                                playback::type *type_)
    1136                 :            : {
    1137                 :            :   /* For comparison, see:
    1138                 :            :      - c/c-typeck.c:build_c_cast
    1139                 :            :      - c/c-convert.c: convert
    1140                 :            :      - convert.h
    1141                 :            : 
    1142                 :            :      Only some kinds of cast are currently supported here.  */
    1143                 :        309 :   tree t_expr = expr->as_tree ();
    1144                 :        309 :   tree t_dst_type = type_->as_tree ();
    1145                 :        309 :   tree t_ret = NULL;
    1146                 :        309 :   t_ret = targetm.convert_to_type (t_dst_type, t_expr);
    1147                 :        309 :   if (t_ret)
    1148                 :            :       return t_ret;
    1149                 :        309 :   enum tree_code dst_code = TREE_CODE (t_dst_type);
    1150                 :        309 :   switch (dst_code)
    1151                 :            :     {
    1152                 :        125 :     case INTEGER_TYPE:
    1153                 :        125 :     case ENUMERAL_TYPE:
    1154                 :        125 :       t_ret = convert_to_integer (t_dst_type, t_expr);
    1155                 :        125 :       goto maybe_fold;
    1156                 :            : 
    1157                 :         34 :     case BOOLEAN_TYPE:
    1158                 :            :       /* Compare with c_objc_common_truthvalue_conversion and
    1159                 :            :          c_common_truthvalue_conversion. */
    1160                 :            :       /* For now, convert to: (t_expr != 0)  */
    1161                 :         34 :       t_ret = build2 (NE_EXPR, t_dst_type,
    1162                 :            :                       t_expr,
    1163                 :         34 :                       build_int_cst (TREE_TYPE (t_expr), 0));
    1164                 :         34 :       goto maybe_fold;
    1165                 :            : 
    1166                 :         15 :     case REAL_TYPE:
    1167                 :         15 :       t_ret = convert_to_real (t_dst_type, t_expr);
    1168                 :         15 :       goto maybe_fold;
    1169                 :            : 
    1170                 :        135 :     case POINTER_TYPE:
    1171                 :        135 :       t_ret = build1 (NOP_EXPR, t_dst_type, t_expr);
    1172                 :        135 :       goto maybe_fold;
    1173                 :            : 
    1174                 :          0 :     default:
    1175                 :          0 :       add_error (loc, "couldn't handle cast during playback");
    1176                 :          0 :       fprintf (stderr, "input expression:\n");
    1177                 :          0 :       debug_tree (t_expr);
    1178                 :          0 :       fprintf (stderr, "requested type:\n");
    1179                 :          0 :       debug_tree (t_dst_type);
    1180                 :          0 :       return error_mark_node;
    1181                 :            : 
    1182                 :        309 :     maybe_fold:
    1183                 :        309 :       if (TREE_CODE (t_ret) != C_MAYBE_CONST_EXPR)
    1184                 :        309 :         t_ret = fold (t_ret);
    1185                 :            :       return t_ret;
    1186                 :            :     }
    1187                 :            : }
    1188                 :            : 
    1189                 :            : /* Construct a playback::rvalue instance (wrapping a tree) for a
    1190                 :            :    cast.  */
    1191                 :            : 
    1192                 :            : playback::rvalue *
    1193                 :        309 : playback::context::
    1194                 :            : new_cast (playback::location *loc,
    1195                 :            :           playback::rvalue *expr,
    1196                 :            :           playback::type *type_)
    1197                 :            : {
    1198                 :            : 
    1199                 :        309 :   tree t_cast = build_cast (loc, expr, type_);
    1200                 :        309 :   if (loc)
    1201                 :          9 :     set_tree_location (t_cast, loc);
    1202                 :        309 :   return new rvalue (this, t_cast);
    1203                 :            : }
    1204                 :            : 
    1205                 :            : /* Construct a playback::lvalue instance (wrapping a tree) for an
    1206                 :            :    array access.  */
    1207                 :            : 
    1208                 :            : playback::lvalue *
    1209                 :        399 : playback::context::
    1210                 :            : new_array_access (location *loc,
    1211                 :            :                   rvalue *ptr,
    1212                 :            :                   rvalue *index)
    1213                 :            : {
    1214                 :        399 :   gcc_assert (ptr);
    1215                 :        399 :   gcc_assert (index);
    1216                 :            : 
    1217                 :            :   /* For comparison, see:
    1218                 :            :        c/c-typeck.c: build_array_ref
    1219                 :            :        c-family/c-common.c: pointer_int_sum
    1220                 :            :   */
    1221                 :        399 :   tree t_ptr = ptr->as_tree ();
    1222                 :        399 :   tree t_index = index->as_tree ();
    1223                 :        399 :   tree t_type_ptr = TREE_TYPE (t_ptr);
    1224                 :        399 :   tree t_type_star_ptr = TREE_TYPE (t_type_ptr);
    1225                 :            : 
    1226                 :        399 :   if (TREE_CODE (t_type_ptr) == ARRAY_TYPE)
    1227                 :            :     {
    1228                 :        254 :       tree t_result = build4 (ARRAY_REF, t_type_star_ptr, t_ptr, t_index,
    1229                 :            :                               NULL_TREE, NULL_TREE);
    1230                 :        254 :       if (loc)
    1231                 :        209 :         set_tree_location (t_result, loc);
    1232                 :        254 :       return new lvalue (this, t_result);
    1233                 :            :     }
    1234                 :            :   else
    1235                 :            :     {
    1236                 :            :       /* Convert index to an offset in bytes.  */
    1237                 :        145 :       tree t_sizeof = size_in_bytes (t_type_star_ptr);
    1238                 :        145 :       t_index = fold_build1 (CONVERT_EXPR, sizetype, t_index);
    1239                 :        145 :       tree t_offset = build2 (MULT_EXPR, sizetype, t_index, t_sizeof);
    1240                 :            : 
    1241                 :            :       /* Locate (ptr + offset).  */
    1242                 :        145 :       tree t_address = build2 (POINTER_PLUS_EXPR, t_type_ptr, t_ptr, t_offset);
    1243                 :            : 
    1244                 :        145 :       tree t_indirection = build1 (INDIRECT_REF, t_type_star_ptr, t_address);
    1245                 :        145 :       if (loc)
    1246                 :            :         {
    1247                 :          0 :           set_tree_location (t_sizeof, loc);
    1248                 :          0 :           set_tree_location (t_offset, loc);
    1249                 :          0 :           set_tree_location (t_address, loc);
    1250                 :          0 :           set_tree_location (t_indirection, loc);
    1251                 :            :         }
    1252                 :            : 
    1253                 :        145 :       return new lvalue (this, t_indirection);
    1254                 :            :     }
    1255                 :            : }
    1256                 :            : 
    1257                 :            : /* Construct a tree for a field access.  */
    1258                 :            : 
    1259                 :            : tree
    1260                 :       1591 : playback::context::
    1261                 :            : new_field_access (location *loc,
    1262                 :            :                   tree datum,
    1263                 :            :                   field *field)
    1264                 :            : {
    1265                 :       1591 :   gcc_assert (datum);
    1266                 :       1591 :   gcc_assert (field);
    1267                 :            : 
    1268                 :            :   /* Compare with c/c-typeck.c:lookup_field, build_indirect_ref, and
    1269                 :            :      build_component_ref. */
    1270                 :       1591 :   tree type = TREE_TYPE (datum);
    1271                 :       1591 :   gcc_assert (type);
    1272                 :       1591 :   gcc_assert (TREE_CODE (type) != POINTER_TYPE);
    1273                 :            : 
    1274                 :       1591 :  tree t_field = field->as_tree ();
    1275                 :       1591 :  tree ref = build3 (COMPONENT_REF, TREE_TYPE (t_field), datum,
    1276                 :            :                      t_field, NULL_TREE);
    1277                 :       1591 :   if (loc)
    1278                 :          0 :     set_tree_location (ref, loc);
    1279                 :       1591 :   return ref;
    1280                 :            : }
    1281                 :            : 
    1282                 :            : /* Construct a tree for a dereference.  */
    1283                 :            : 
    1284                 :            : tree
    1285                 :       1892 : playback::context::
    1286                 :            : new_dereference (tree ptr,
    1287                 :            :                  location *loc)
    1288                 :            : {
    1289                 :       1892 :   gcc_assert (ptr);
    1290                 :            : 
    1291                 :       1892 :   tree type = TREE_TYPE (TREE_TYPE(ptr));
    1292                 :       1892 :   tree datum = build1 (INDIRECT_REF, type, ptr);
    1293                 :       1892 :   if (loc)
    1294                 :          0 :     set_tree_location (datum, loc);
    1295                 :       1892 :   return datum;
    1296                 :            : }
    1297                 :            : 
    1298                 :            : /* Construct a playback::type instance (wrapping a tree)
    1299                 :            :    with the given alignment.  */
    1300                 :            : 
    1301                 :            : playback::type *
    1302                 :        140 : playback::type::
    1303                 :            : get_aligned (size_t alignment_in_bytes) const
    1304                 :            : {
    1305                 :        140 :   tree t_new_type = build_variant_type_copy (m_inner);
    1306                 :            : 
    1307                 :        140 :   SET_TYPE_ALIGN (t_new_type, alignment_in_bytes * BITS_PER_UNIT);
    1308                 :        140 :   TYPE_USER_ALIGN (t_new_type) = 1;
    1309                 :            : 
    1310                 :        140 :   return new type (t_new_type);
    1311                 :            : }
    1312                 :            : 
    1313                 :            : /* Construct a playback::type instance (wrapping a tree)
    1314                 :            :    for the given vector type.  */
    1315                 :            : 
    1316                 :            : playback::type *
    1317                 :         45 : playback::type::
    1318                 :            : get_vector (size_t num_units) const
    1319                 :            : {
    1320                 :         45 :   tree t_new_type = build_vector_type (m_inner, num_units);
    1321                 :         45 :   return new type (t_new_type);
    1322                 :            : }
    1323                 :            : 
    1324                 :            : /* Construct a playback::lvalue instance (wrapping a tree) for a
    1325                 :            :    field access.  */
    1326                 :            : 
    1327                 :            : playback::lvalue *
    1328                 :        179 : playback::lvalue::
    1329                 :            : access_field (location *loc,
    1330                 :            :               field *field)
    1331                 :            : {
    1332                 :        179 :   tree datum = as_tree ();
    1333                 :        179 :   tree ref = get_context ()->new_field_access (loc, datum, field);
    1334                 :        179 :   if (!ref)
    1335                 :            :     return NULL;
    1336                 :        179 :   return new lvalue (get_context (), ref);
    1337                 :            : }
    1338                 :            : 
    1339                 :            : /* Construct a playback::rvalue instance (wrapping a tree) for a
    1340                 :            :    field access.  */
    1341                 :            : 
    1342                 :            : playback::rvalue *
    1343                 :        119 : playback::rvalue::
    1344                 :            : access_field (location *loc,
    1345                 :            :               field *field)
    1346                 :            : {
    1347                 :        119 :   tree datum = as_tree ();
    1348                 :        119 :   tree ref = get_context ()->new_field_access (loc, datum, field);
    1349                 :        119 :   if (!ref)
    1350                 :            :     return NULL;
    1351                 :        119 :   return new rvalue (get_context (), ref);
    1352                 :            : }
    1353                 :            : 
    1354                 :            : /* Construct a playback::lvalue instance (wrapping a tree) for a
    1355                 :            :    dereferenced field access.  */
    1356                 :            : 
    1357                 :            : playback::lvalue *
    1358                 :       1293 : playback::rvalue::
    1359                 :            : dereference_field (location *loc,
    1360                 :            :                    field *field)
    1361                 :            : {
    1362                 :       1293 :   tree ptr = as_tree ();
    1363                 :       1293 :   tree datum = get_context ()->new_dereference (ptr, loc);
    1364                 :       1293 :   if (!datum)
    1365                 :            :     return NULL;
    1366                 :       1293 :   tree ref = get_context ()->new_field_access (loc, datum, field);
    1367                 :       1293 :   if (!ref)
    1368                 :            :     return NULL;
    1369                 :       1293 :   return new lvalue (get_context (), ref);
    1370                 :            : }
    1371                 :            : 
    1372                 :            : /* Construct a playback::lvalue instance (wrapping a tree) for a
    1373                 :            :    dereference.  */
    1374                 :            : 
    1375                 :            : playback::lvalue *
    1376                 :        599 : playback::rvalue::
    1377                 :            : dereference (location *loc)
    1378                 :            : {
    1379                 :        599 :   tree ptr = as_tree ();
    1380                 :        599 :   tree datum = get_context ()->new_dereference (ptr, loc);
    1381                 :        599 :   return new lvalue (get_context (), datum);
    1382                 :            : }
    1383                 :            : 
    1384                 :            : /* Mark the lvalue saying that we need to be able to take the
    1385                 :            :    address of it; it should not be allocated in a register.
    1386                 :            :    Compare with e.g. c/c-typeck.c: c_mark_addressable really_atomic_lvalue.
    1387                 :            :    Returns false if a failure occurred (an error will already have been
    1388                 :            :    added to the active context for this case).  */
    1389                 :            : 
    1390                 :            : bool
    1391                 :        248 : playback::lvalue::
    1392                 :            : mark_addressable (location *loc)
    1393                 :            : {
    1394                 :        248 :   tree x = as_tree ();;
    1395                 :            : 
    1396                 :        248 :   while (1)
    1397                 :        248 :     switch (TREE_CODE (x))
    1398                 :            :       {
    1399                 :          5 :       case COMPONENT_REF:
    1400                 :          5 :         if (DECL_JIT_BIT_FIELD (TREE_OPERAND (x, 1)))
    1401                 :            :           {
    1402                 :          5 :             gcc_assert (gcc::jit::active_playback_ctxt);
    1403                 :          5 :             gcc::jit::
    1404                 :          5 :               active_playback_ctxt->add_error (loc,
    1405                 :            :                                                "cannot take address of "
    1406                 :            :                                                "bit-field");
    1407                 :          5 :             return false;
    1408                 :            :           }
    1409                 :            :         /* fallthrough */
    1410                 :          0 :       case ADDR_EXPR:
    1411                 :          0 :       case ARRAY_REF:
    1412                 :          0 :       case REALPART_EXPR:
    1413                 :          0 :       case IMAGPART_EXPR:
    1414                 :          0 :         x = TREE_OPERAND (x, 0);
    1415                 :          0 :         break;
    1416                 :            : 
    1417                 :          0 :       case COMPOUND_LITERAL_EXPR:
    1418                 :          0 :       case CONSTRUCTOR:
    1419                 :          0 :         TREE_ADDRESSABLE (x) = 1;
    1420                 :          0 :         return true;
    1421                 :            : 
    1422                 :        213 :       case VAR_DECL:
    1423                 :        213 :       case CONST_DECL:
    1424                 :        213 :       case PARM_DECL:
    1425                 :        213 :       case RESULT_DECL:
    1426                 :            :         /* (we don't have a concept of a "register" declaration) */
    1427                 :            :         /* fallthrough */
    1428                 :        213 :       case FUNCTION_DECL:
    1429                 :        213 :         TREE_ADDRESSABLE (x) = 1;
    1430                 :            :         /* fallthrough */
    1431                 :            :       default:
    1432                 :            :         return true;
    1433                 :            :       }
    1434                 :            : }
    1435                 :            : 
    1436                 :            : /* Construct a playback::rvalue instance (wrapping a tree) for an
    1437                 :            :    address-lookup.  */
    1438                 :            : 
    1439                 :            : playback::rvalue *
    1440                 :        248 : playback::lvalue::
    1441                 :            : get_address (location *loc)
    1442                 :            : {
    1443                 :        248 :   tree t_lvalue = as_tree ();
    1444                 :        248 :   tree t_thistype = TREE_TYPE (t_lvalue);
    1445                 :        248 :   tree t_ptrtype = build_pointer_type (t_thistype);
    1446                 :        248 :   tree ptr = build1 (ADDR_EXPR, t_ptrtype, t_lvalue);
    1447                 :        248 :   if (loc)
    1448                 :          0 :     get_context ()->set_tree_location (ptr, loc);
    1449                 :        248 :   if (mark_addressable (loc))
    1450                 :        243 :     return new rvalue (get_context (), ptr);
    1451                 :            :   else
    1452                 :            :     return NULL;
    1453                 :            : }
    1454                 :            : 
    1455                 :            : /* The wrapper subclasses are GC-managed, but can own non-GC memory.
    1456                 :            :    Provide this finalization hook for calling then they are collected,
    1457                 :            :    which calls the finalizer vfunc.  This allows them to call "release"
    1458                 :            :    on any vec<> within them.  */
    1459                 :            : 
    1460                 :            : static void
    1461                 :      35635 : wrapper_finalizer (void *ptr)
    1462                 :            : {
    1463                 :      35635 :   playback::wrapper *wrapper = reinterpret_cast <playback::wrapper *> (ptr);
    1464                 :      35635 :   wrapper->finalizer ();
    1465                 :      35635 : }
    1466                 :            : 
    1467                 :            : /* gcc::jit::playback::wrapper subclasses are GC-managed:
    1468                 :            :    allocate them using ggc_internal_cleared_alloc.  */
    1469                 :            : 
    1470                 :            : void *
    1471                 :      37452 : playback::wrapper::
    1472                 :            : operator new (size_t sz)
    1473                 :            : {
    1474                 :      37452 :   return ggc_internal_cleared_alloc (sz, wrapper_finalizer, 0, 1);
    1475                 :            : 
    1476                 :            : }
    1477                 :            : 
    1478                 :            : /* Constructor for gcc:jit::playback::function.  */
    1479                 :            : 
    1480                 :       3910 : playback::function::
    1481                 :            : function (context *ctxt,
    1482                 :            :           tree fndecl,
    1483                 :       3910 :           enum gcc_jit_function_kind kind)
    1484                 :       3910 : : m_ctxt(ctxt),
    1485                 :       3910 :   m_inner_fndecl (fndecl),
    1486                 :       3910 :   m_inner_bind_expr (NULL),
    1487                 :       3910 :   m_kind (kind),
    1488                 :       3910 :   m_blocks ()
    1489                 :            : {
    1490                 :       3910 :   if (m_kind != GCC_JIT_FUNCTION_IMPORTED)
    1491                 :            :     {
    1492                 :            :       /* Create a BIND_EXPR, and within it, a statement list.  */
    1493                 :       2586 :       m_stmt_list = alloc_stmt_list ();
    1494                 :       2586 :       m_stmt_iter = tsi_start (m_stmt_list);
    1495                 :       2586 :       m_inner_block = make_node (BLOCK);
    1496                 :       2586 :       m_inner_bind_expr =
    1497                 :       2586 :         build3 (BIND_EXPR, void_type_node, NULL, m_stmt_list, m_inner_block);
    1498                 :            :     }
    1499                 :            :   else
    1500                 :            :     {
    1501                 :       1324 :       m_inner_block = NULL;
    1502                 :       1324 :       m_stmt_list = NULL;
    1503                 :            :     }
    1504                 :       3910 : }
    1505                 :            : 
    1506                 :            : /* Hand-written GC-marking hook for playback functions.  */
    1507                 :            : 
    1508                 :            : void
    1509                 :   17216779 : playback::function::
    1510                 :            : gt_ggc_mx ()
    1511                 :            : {
    1512                 :   17216779 :   gt_ggc_m_9tree_node (m_inner_fndecl);
    1513                 :   17216779 :   gt_ggc_m_9tree_node (m_inner_bind_expr);
    1514                 :   17216779 :   gt_ggc_m_9tree_node (m_stmt_list);
    1515                 :   17216779 :   gt_ggc_m_9tree_node (m_inner_block);
    1516                 :   17216779 : }
    1517                 :            : 
    1518                 :            : /* Don't leak vec's internal buffer (in non-GC heap) when we are
    1519                 :            :    GC-ed.  */
    1520                 :            : 
    1521                 :            : void
    1522                 :       3443 : playback::function::finalizer ()
    1523                 :            : {
    1524                 :       3443 :   m_blocks.release ();
    1525                 :       3443 : }
    1526                 :            : 
    1527                 :            : /* Get the return type of a playback function, in tree form.  */
    1528                 :            : 
    1529                 :            : tree
    1530                 :       2952 : playback::function::
    1531                 :            : get_return_type_as_tree () const
    1532                 :            : {
    1533                 :       2952 :   return TREE_TYPE (TREE_TYPE(m_inner_fndecl));
    1534                 :            : }
    1535                 :            : 
    1536                 :            : /* Construct a new local within this playback::function.  */
    1537                 :            : 
    1538                 :            : playback::lvalue *
    1539                 :       1882 : playback::function::
    1540                 :            : new_local (location *loc,
    1541                 :            :            type *type,
    1542                 :            :            const char *name)
    1543                 :            : {
    1544                 :       1882 :   gcc_assert (type);
    1545                 :       1882 :   gcc_assert (name);
    1546                 :       1882 :   tree inner = build_decl (UNKNOWN_LOCATION, VAR_DECL,
    1547                 :            :                            get_identifier (name),
    1548                 :            :                            type->as_tree ());
    1549                 :       1882 :   DECL_CONTEXT (inner) = this->m_inner_fndecl;
    1550                 :            : 
    1551                 :            :   /* Prepend to BIND_EXPR_VARS: */
    1552                 :       1882 :   DECL_CHAIN (inner) = BIND_EXPR_VARS (m_inner_bind_expr);
    1553                 :       1882 :   BIND_EXPR_VARS (m_inner_bind_expr) = inner;
    1554                 :            : 
    1555                 :       1882 :   if (loc)
    1556                 :         21 :     set_tree_location (inner, loc);
    1557                 :       1882 :   return new lvalue (m_ctxt, inner);
    1558                 :            : }
    1559                 :            : 
    1560                 :            : /* Construct a new block within this playback::function.  */
    1561                 :            : 
    1562                 :            : playback::block *
    1563                 :       4933 : playback::function::
    1564                 :            : new_block (const char *name)
    1565                 :            : {
    1566                 :       4933 :   gcc_assert (m_kind != GCC_JIT_FUNCTION_IMPORTED);
    1567                 :            : 
    1568                 :       4933 :   block *result = new playback::block (this, name);
    1569                 :       4933 :   m_blocks.safe_push (result);
    1570                 :       4933 :   return result;
    1571                 :            : }
    1572                 :            : 
    1573                 :            : /* Construct a playback::rvalue instance wrapping an ADDR_EXPR for
    1574                 :            :    this playback::function.  */
    1575                 :            : 
    1576                 :            : playback::rvalue *
    1577                 :         15 : playback::function::get_address (location *loc)
    1578                 :            : {
    1579                 :         15 :   tree t_fndecl = as_fndecl ();
    1580                 :         15 :   tree t_fntype = TREE_TYPE (t_fndecl);
    1581                 :         15 :   tree t_fnptr = build1 (ADDR_EXPR, build_pointer_type (t_fntype), t_fndecl);
    1582                 :         15 :   if (loc)
    1583                 :          0 :     m_ctxt->set_tree_location (t_fnptr, loc);
    1584                 :         15 :   return new rvalue (m_ctxt, t_fnptr);
    1585                 :            : }
    1586                 :            : 
    1587                 :            : /* Build a statement list for the function as a whole out of the
    1588                 :            :    lists of statements for the individual blocks, building labels
    1589                 :            :    for each block.  */
    1590                 :            : 
    1591                 :            : void
    1592                 :       3910 : playback::function::
    1593                 :            : build_stmt_list ()
    1594                 :            : {
    1595                 :       3910 :   int i;
    1596                 :       3910 :   block *b;
    1597                 :            : 
    1598                 :       3910 :   JIT_LOG_SCOPE (m_ctxt->get_logger ());
    1599                 :            : 
    1600                 :       8843 :   FOR_EACH_VEC_ELT (m_blocks, i, b)
    1601                 :            :     {
    1602                 :       4933 :       int j;
    1603                 :       4933 :       tree stmt;
    1604                 :            : 
    1605                 :       4933 :       b->m_label_expr = build1 (LABEL_EXPR,
    1606                 :            :                                 void_type_node,
    1607                 :            :                                 b->as_label_decl ());
    1608                 :       4933 :       tsi_link_after (&m_stmt_iter, b->m_label_expr, TSI_CONTINUE_LINKING);
    1609                 :            : 
    1610                 :      19757 :       FOR_EACH_VEC_ELT (b->m_stmts, j, stmt)
    1611                 :       9891 :         tsi_link_after (&m_stmt_iter, stmt, TSI_CONTINUE_LINKING);
    1612                 :            :     }
    1613                 :       3910 : }
    1614                 :            : 
    1615                 :            : /* Finish compiling the given function, potentially running the
    1616                 :            :    garbage-collector.
    1617                 :            :    The function will have a statement list by now.
    1618                 :            :    Amongst other things, this gimplifies the statement list,
    1619                 :            :    and calls cgraph_node::finalize_function on the function.  */
    1620                 :            : 
    1621                 :            : void
    1622                 :       3910 : playback::function::
    1623                 :            : postprocess ()
    1624                 :            : {
    1625                 :       3910 :   JIT_LOG_SCOPE (m_ctxt->get_logger ());
    1626                 :            : 
    1627                 :       3910 :   if (m_ctxt->get_bool_option (GCC_JIT_BOOL_OPTION_DUMP_INITIAL_TREE))
    1628                 :          0 :     debug_tree (m_stmt_list);
    1629                 :            : 
    1630                 :            :   /* Do we need this to force cgraphunit.c to output the function? */
    1631                 :       3910 :   if (m_kind == GCC_JIT_FUNCTION_EXPORTED)
    1632                 :            :     {
    1633                 :       2481 :       DECL_EXTERNAL (m_inner_fndecl) = 0;
    1634                 :       2481 :       DECL_PRESERVE_P (m_inner_fndecl) = 1;
    1635                 :            :     }
    1636                 :            : 
    1637                 :       3910 :   if (m_kind == GCC_JIT_FUNCTION_INTERNAL
    1638                 :       3910 :       ||m_kind == GCC_JIT_FUNCTION_ALWAYS_INLINE)
    1639                 :            :     {
    1640                 :        105 :       DECL_EXTERNAL (m_inner_fndecl) = 0;
    1641                 :        105 :       TREE_PUBLIC (m_inner_fndecl) = 0;
    1642                 :            :     }
    1643                 :            : 
    1644                 :       3910 :   if (m_kind != GCC_JIT_FUNCTION_IMPORTED)
    1645                 :            :     {
    1646                 :            :       /* Seem to need this in gimple-low.c: */
    1647                 :       2586 :       gcc_assert (m_inner_block);
    1648                 :       2586 :       DECL_INITIAL (m_inner_fndecl) = m_inner_block;
    1649                 :            : 
    1650                 :            :       /* how to add to function? the following appears to be how to
    1651                 :            :          set the body of a m_inner_fndecl: */
    1652                 :       2586 :       DECL_SAVED_TREE(m_inner_fndecl) = m_inner_bind_expr;
    1653                 :            : 
    1654                 :            :       /* Ensure that locals appear in the debuginfo.  */
    1655                 :       2586 :       BLOCK_VARS (m_inner_block) = BIND_EXPR_VARS (m_inner_bind_expr);
    1656                 :            : 
    1657                 :            :       //debug_tree (m_inner_fndecl);
    1658                 :            : 
    1659                 :            :       /* Convert to gimple: */
    1660                 :            :       //printf("about to gimplify_function_tree\n");
    1661                 :       2586 :       gimplify_function_tree (m_inner_fndecl);
    1662                 :            :       //printf("finished gimplify_function_tree\n");
    1663                 :            : 
    1664                 :       2586 :       current_function_decl = m_inner_fndecl;
    1665                 :       2586 :       if (m_ctxt->get_bool_option (GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE))
    1666                 :          0 :         dump_function_to_file (m_inner_fndecl, stderr, TDF_VOPS|TDF_MEMSYMS|TDF_LINENO);
    1667                 :            :       //debug_tree (m_inner_fndecl);
    1668                 :            : 
    1669                 :            :       //printf("about to add to cgraph\n");
    1670                 :            :       /* Add to cgraph: */
    1671                 :       2586 :       cgraph_node::finalize_function (m_inner_fndecl, false);
    1672                 :            :       /* This can trigger a collection, so we need to have all of
    1673                 :            :          the funcs as roots.  */
    1674                 :            : 
    1675                 :       2586 :       current_function_decl = NULL;
    1676                 :            :     }
    1677                 :       3910 : }
    1678                 :            : 
    1679                 :            : /* Don't leak vec's internal buffer (in non-GC heap) when we are
    1680                 :            :    GC-ed.  */
    1681                 :            : 
    1682                 :            : void
    1683                 :       4857 : playback::block::finalizer ()
    1684                 :            : {
    1685                 :       4857 :   m_stmts.release ();
    1686                 :       4857 : }
    1687                 :            : 
    1688                 :            : /* Add an eval of the rvalue to the function's statement list.  */
    1689                 :            : 
    1690                 :            : void
    1691                 :        256 : playback::block::
    1692                 :            : add_eval (location *loc,
    1693                 :            :           rvalue *rvalue)
    1694                 :            : {
    1695                 :        256 :   gcc_assert (rvalue);
    1696                 :            : 
    1697                 :        256 :   if (loc)
    1698                 :          9 :     set_tree_location (rvalue->as_tree (), loc);
    1699                 :            : 
    1700                 :        256 :   add_stmt (rvalue->as_tree ());
    1701                 :        256 : }
    1702                 :            : 
    1703                 :            : /* Add an assignment to the function's statement list.  */
    1704                 :            : 
    1705                 :            : void
    1706                 :       4214 : playback::block::
    1707                 :            : add_assignment (location *loc,
    1708                 :            :                 lvalue *lvalue,
    1709                 :            :                 rvalue *rvalue)
    1710                 :            : {
    1711                 :       4214 :   gcc_assert (lvalue);
    1712                 :       4214 :   gcc_assert (rvalue);
    1713                 :            : 
    1714                 :       4214 :   tree t_lvalue = lvalue->as_tree ();
    1715                 :       4214 :   tree t_rvalue = rvalue->as_tree ();
    1716                 :       4214 :   if (TREE_TYPE (t_rvalue) != TREE_TYPE (t_lvalue))
    1717                 :            :     {
    1718                 :        280 :       t_rvalue = build1 (CONVERT_EXPR,
    1719                 :        280 :                          TREE_TYPE (t_lvalue),
    1720                 :            :                          t_rvalue);
    1721                 :        280 :       if (loc)
    1722                 :          0 :         set_tree_location (t_rvalue, loc);
    1723                 :            :     }
    1724                 :            : 
    1725                 :       4214 :   tree stmt =
    1726                 :       4214 :     build2 (MODIFY_EXPR, TREE_TYPE (t_lvalue),
    1727                 :            :             t_lvalue, t_rvalue);
    1728                 :       4214 :   if (loc)
    1729                 :        390 :     set_tree_location (stmt, loc);
    1730                 :       4214 :   add_stmt (stmt);
    1731                 :       4214 : }
    1732                 :            : 
    1733                 :            : /* Add a comment to the function's statement list.
    1734                 :            :    For now this is done by adding a dummy label.  */
    1735                 :            : 
    1736                 :            : void
    1737                 :        428 : playback::block::
    1738                 :            : add_comment (location *loc,
    1739                 :            :              const char *text)
    1740                 :            : {
    1741                 :            :   /* Wrap the text in C-style comment delimiters.  */
    1742                 :        428 :   size_t sz =
    1743                 :            :     (3 /* opening delim */
    1744                 :        428 :      + strlen (text)
    1745                 :            :      + 3 /* closing delim */
    1746                 :            :      + 1 /* terminator */);
    1747                 :        428 :   char *wrapped = (char *)ggc_internal_alloc (sz);
    1748                 :        428 :   snprintf (wrapped, sz, "/* %s */", text);
    1749                 :            : 
    1750                 :            :   /* For now we simply implement this by adding a dummy label with a name
    1751                 :            :      containing the given text.  */
    1752                 :        428 :   tree identifier = get_identifier (wrapped);
    1753                 :        428 :   tree label_decl = build_decl (UNKNOWN_LOCATION, LABEL_DECL,
    1754                 :            :                                 identifier, void_type_node);
    1755                 :        428 :   DECL_CONTEXT (label_decl) = m_func->as_fndecl ();
    1756                 :            : 
    1757                 :        428 :   tree label_expr = build1 (LABEL_EXPR, void_type_node, label_decl);
    1758                 :        428 :   if (loc)
    1759                 :        202 :     set_tree_location (label_expr, loc);
    1760                 :        428 :   add_stmt (label_expr);
    1761                 :        428 : }
    1762                 :            : 
    1763                 :            : /* Add a conditional jump statement to the function's statement list.  */
    1764                 :            : 
    1765                 :            : void
    1766                 :        824 : playback::block::
    1767                 :            : add_conditional (location *loc,
    1768                 :            :                  rvalue *boolval,
    1769                 :            :                  block *on_true,
    1770                 :            :                  block *on_false)
    1771                 :            : {
    1772                 :        824 :   gcc_assert (boolval);
    1773                 :        824 :   gcc_assert (on_true);
    1774                 :        824 :   gcc_assert (on_false);
    1775                 :            : 
    1776                 :            :   /* COND_EXPR wants statement lists for the true/false operands, but we
    1777                 :            :      want labels.
    1778                 :            :      Shim it by creating jumps to the labels */
    1779                 :        824 :   tree true_jump = build1 (GOTO_EXPR, void_type_node,
    1780                 :            :                            on_true->as_label_decl ());
    1781                 :        824 :   if (loc)
    1782                 :         37 :     set_tree_location (true_jump, loc);
    1783                 :            : 
    1784                 :        824 :   tree false_jump = build1 (GOTO_EXPR, void_type_node,
    1785                 :            :                             on_false->as_label_decl ());
    1786                 :        824 :   if (loc)
    1787                 :         37 :     set_tree_location (false_jump, loc);
    1788                 :            : 
    1789                 :        824 :   tree stmt =
    1790                 :        824 :     build3 (COND_EXPR, void_type_node, boolval->as_tree (),
    1791                 :            :             true_jump, false_jump);
    1792                 :        824 :   if (loc)
    1793                 :         37 :     set_tree_location (stmt, loc);
    1794                 :        824 :   add_stmt (stmt);
    1795                 :        824 : }
    1796                 :            : 
    1797                 :            : /* Add an unconditional jump statement to the function's statement list.  */
    1798                 :            : 
    1799                 :            : void
    1800                 :       1137 : playback::block::
    1801                 :            : add_jump (location *loc,
    1802                 :            :           block *target)
    1803                 :            : {
    1804                 :       1137 :   gcc_assert (target);
    1805                 :            : 
    1806                 :            :   // see c_finish_loop
    1807                 :            :   //tree top = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
    1808                 :            :   //add_stmt (top);
    1809                 :            : 
    1810                 :            :   //tree stmt = build_and_jump (&LABEL_EXPR_LABEL (target->label_));
    1811                 :       1137 :   TREE_USED (target->as_label_decl ()) = 1;
    1812                 :       1137 :   tree stmt = build1 (GOTO_EXPR, void_type_node, target->as_label_decl ());
    1813                 :       1137 :   if (loc)
    1814                 :         48 :     set_tree_location (stmt, loc);
    1815                 :       1137 :   add_stmt (stmt);
    1816                 :            : 
    1817                 :            :   /*
    1818                 :            :   from c-typeck.c:
    1819                 :            : tree
    1820                 :            : c_finish_goto_label (location_t loc, tree label)
    1821                 :            : {
    1822                 :            :   tree decl = lookup_label_for_goto (loc, label);
    1823                 :            :   if (!decl)
    1824                 :            :     return NULL_TREE;
    1825                 :            :   TREE_USED (decl) = 1;
    1826                 :            :   {
    1827                 :            :     tree t = build1 (GOTO_EXPR, void_type_node, decl);
    1828                 :            :     SET_EXPR_LOCATION (t, loc);
    1829                 :            :     return add_stmt (t);
    1830                 :            :   }
    1831                 :            : }
    1832                 :            :   */
    1833                 :            : 
    1834                 :       1137 : }
    1835                 :            : 
    1836                 :            : /* Add a return statement to the function's statement list.  */
    1837                 :            : 
    1838                 :            : void
    1839                 :       2952 : playback::block::
    1840                 :            : add_return (location *loc,
    1841                 :            :             rvalue *rvalue)
    1842                 :            : {
    1843                 :       2952 :   tree modify_retval = NULL;
    1844                 :       2952 :   tree return_type = m_func->get_return_type_as_tree ();
    1845                 :       2952 :   if (rvalue)
    1846                 :            :     {
    1847                 :       2508 :       tree t_lvalue = DECL_RESULT (m_func->as_fndecl ());
    1848                 :       2508 :       tree t_rvalue = rvalue->as_tree ();
    1849                 :       2508 :       if (TREE_TYPE (t_rvalue) != TREE_TYPE (t_lvalue))
    1850                 :         65 :         t_rvalue = build1 (CONVERT_EXPR,
    1851                 :         65 :                            TREE_TYPE (t_lvalue),
    1852                 :            :                            t_rvalue);
    1853                 :       2508 :       modify_retval = build2 (MODIFY_EXPR, return_type,
    1854                 :            :                               t_lvalue, t_rvalue);
    1855                 :       2508 :       if (loc)
    1856                 :         68 :         set_tree_location (modify_retval, loc);
    1857                 :            :     }
    1858                 :       2952 :   tree return_stmt = build1 (RETURN_EXPR, return_type,
    1859                 :            :                              modify_retval);
    1860                 :       2952 :   if (loc)
    1861                 :         80 :     set_tree_location (return_stmt, loc);
    1862                 :            : 
    1863                 :       2952 :   add_stmt (return_stmt);
    1864                 :       2952 : }
    1865                 :            : 
    1866                 :            : /* Helper function for playback::block::add_switch.
    1867                 :            :    Construct a case label for the given range, followed by a goto stmt
    1868                 :            :    to the given block, appending them to stmt list *ptr_t_switch_body.  */
    1869                 :            : 
    1870                 :            : static void
    1871                 :        100 : add_case (tree *ptr_t_switch_body,
    1872                 :            :           tree t_low_value,
    1873                 :            :           tree t_high_value,
    1874                 :            :           playback::block *dest_block)
    1875                 :            : {
    1876                 :        100 :   tree t_label = create_artificial_label (UNKNOWN_LOCATION);
    1877                 :        100 :   DECL_CONTEXT (t_label) = dest_block->get_function ()->as_fndecl ();
    1878                 :            : 
    1879                 :        100 :   tree t_case_label =
    1880                 :        100 :     build_case_label (t_low_value, t_high_value, t_label);
    1881                 :        100 :   append_to_statement_list (t_case_label, ptr_t_switch_body);
    1882                 :            : 
    1883                 :        100 :   tree t_goto_stmt =
    1884                 :        100 :     build1 (GOTO_EXPR, void_type_node, dest_block->as_label_decl ());
    1885                 :        100 :   append_to_statement_list (t_goto_stmt, ptr_t_switch_body);
    1886                 :        100 : }
    1887                 :            : 
    1888                 :            : /* Add a switch statement to the function's statement list.
    1889                 :            : 
    1890                 :            :    We create a switch body, and populate it with case labels, each
    1891                 :            :    followed by a goto to the desired block.  */
    1892                 :            : 
    1893                 :            : void
    1894                 :         20 : playback::block::
    1895                 :            : add_switch (location *loc,
    1896                 :            :             rvalue *expr,
    1897                 :            :             block *default_block,
    1898                 :            :             const auto_vec <case_> *cases)
    1899                 :            : {
    1900                 :            :   /* Compare with:
    1901                 :            :      - c/c-typeck.c: c_start_case
    1902                 :            :      - c-family/c-common.c:c_add_case_label
    1903                 :            :      - java/expr.c:expand_java_switch and expand_java_add_case
    1904                 :            :      We've already rejected overlaps and duplicates in
    1905                 :            :      libgccjit.c:case_range_validator::validate.  */
    1906                 :            : 
    1907                 :         20 :   tree t_expr = expr->as_tree ();
    1908                 :         20 :   tree t_type = TREE_TYPE (t_expr);
    1909                 :            : 
    1910                 :         20 :   tree t_switch_body = alloc_stmt_list ();
    1911                 :            : 
    1912                 :         20 :   int i;
    1913                 :         20 :   case_ *c;
    1914                 :        100 :   FOR_EACH_VEC_ELT (*cases, i, c)
    1915                 :            :     {
    1916                 :         80 :       tree t_low_value = c->m_min_value->as_tree ();
    1917                 :         80 :       tree t_high_value = c->m_max_value->as_tree ();
    1918                 :         80 :       add_case (&t_switch_body, t_low_value, t_high_value, c->m_dest_block);
    1919                 :            :     }
    1920                 :            :   /* Default label. */
    1921                 :         20 :   add_case (&t_switch_body, NULL_TREE, NULL_TREE, default_block);
    1922                 :            : 
    1923                 :         20 :   tree switch_stmt = build2 (SWITCH_EXPR, t_type, t_expr, t_switch_body);
    1924                 :         20 :   if (loc)
    1925                 :          0 :     set_tree_location (switch_stmt, loc);
    1926                 :         20 :   add_stmt (switch_stmt);
    1927                 :         20 : }
    1928                 :            : 
    1929                 :            : /* Convert OPERANDS to a tree-based chain suitable for creating an
    1930                 :            :    extended asm stmt.
    1931                 :            :    Compare with c_parser_asm_operands.  */
    1932                 :            : 
    1933                 :            : static tree
    1934                 :        120 : build_operand_chain (const auto_vec <playback::asm_operand> *operands)
    1935                 :            : {
    1936                 :        120 :   tree result = NULL_TREE;
    1937                 :        120 :   unsigned i;
    1938                 :        120 :   playback::asm_operand *asm_op;
    1939                 :        220 :   FOR_EACH_VEC_ELT (*operands, i, asm_op)
    1940                 :            :     {
    1941                 :        100 :       tree name = build_string (asm_op->m_asm_symbolic_name);
    1942                 :        100 :       tree str = build_string (asm_op->m_constraint);
    1943                 :        100 :       tree value = asm_op->m_expr;
    1944                 :        100 :       result = chainon (result,
    1945                 :            :                         build_tree_list (build_tree_list (name, str),
    1946                 :            :                                          value));
    1947                 :            :     }
    1948                 :        120 :   return result;
    1949                 :            : }
    1950                 :            : 
    1951                 :            : /* Convert CLOBBERS to a tree-based list suitable for creating an
    1952                 :            :    extended asm stmt.
    1953                 :            :    Compare with c_parser_asm_clobbers.  */
    1954                 :            : 
    1955                 :            : static tree
    1956                 :         60 : build_clobbers (const auto_vec <const char *> *clobbers)
    1957                 :            : {
    1958                 :         60 :   tree list = NULL_TREE;
    1959                 :         60 :   unsigned i;
    1960                 :         60 :   const char *clobber;
    1961                 :        110 :   FOR_EACH_VEC_ELT (*clobbers, i, clobber)
    1962                 :            :     {
    1963                 :         50 :       tree str = build_string (clobber);
    1964                 :         50 :       list = tree_cons (NULL_TREE, str, list);
    1965                 :            :     }
    1966                 :         60 :   return list;
    1967                 :            : }
    1968                 :            : 
    1969                 :            : /* Convert BLOCKS to a tree-based list suitable for creating an
    1970                 :            :    extended asm stmt.
    1971                 :            :    Compare with c_parser_asm_goto_operands.  */
    1972                 :            : 
    1973                 :            : static tree
    1974                 :         60 : build_goto_operands (const auto_vec <playback::block *> *blocks)
    1975                 :            : {
    1976                 :         60 :   tree list = NULL_TREE;
    1977                 :         60 :   unsigned i;
    1978                 :         60 :   playback::block *b;
    1979                 :         80 :   FOR_EACH_VEC_ELT (*blocks, i, b)
    1980                 :            :     {
    1981                 :         20 :       tree label = b->as_label_decl ();
    1982                 :         20 :       tree name = build_string (IDENTIFIER_POINTER (DECL_NAME (label)));
    1983                 :         20 :       TREE_USED (label) = 1;
    1984                 :         20 :       list = tree_cons (name, label, list);
    1985                 :            :     }
    1986                 :         60 :   return nreverse (list);
    1987                 :            : }
    1988                 :            : 
    1989                 :            : /* Add an extended asm statement to this block.
    1990                 :            : 
    1991                 :            :    Compare with c_parser_asm_statement (in c/c-parser.c)
    1992                 :            :    and build_asm_expr (in c/c-typeck.c).  */
    1993                 :            : 
    1994                 :            : void
    1995                 :         60 : playback::block::add_extended_asm (location *loc,
    1996                 :            :                                    const char *asm_template,
    1997                 :            :                                    bool is_volatile,
    1998                 :            :                                    bool is_inline,
    1999                 :            :                                    const auto_vec <asm_operand> *outputs,
    2000                 :            :                                    const auto_vec <asm_operand> *inputs,
    2001                 :            :                                    const auto_vec <const char *> *clobbers,
    2002                 :            :                                    const auto_vec <block *> *goto_blocks)
    2003                 :            : {
    2004                 :         60 :   tree t_string = build_string (asm_template);
    2005                 :         60 :   tree t_outputs = build_operand_chain (outputs);
    2006                 :         60 :   tree t_inputs = build_operand_chain (inputs);
    2007                 :         60 :   tree t_clobbers = build_clobbers (clobbers);
    2008                 :         60 :   tree t_labels = build_goto_operands (goto_blocks);
    2009                 :         60 :   t_string
    2010                 :         60 :     = resolve_asm_operand_names (t_string, t_outputs, t_inputs, t_labels);
    2011                 :         60 :   tree asm_stmt
    2012                 :         60 :     = build5 (ASM_EXPR, void_type_node,
    2013                 :            :               t_string, t_outputs, t_inputs, t_clobbers, t_labels);
    2014                 :            : 
    2015                 :            :   /* asm statements without outputs, including simple ones, are treated
    2016                 :            :      as volatile.  */
    2017                 :        100 :   ASM_VOLATILE_P (asm_stmt) = (outputs->length () == 0);
    2018                 :         60 :   ASM_INPUT_P (asm_stmt) = 0; /* extended asm stmts are not "simple".  */
    2019                 :         60 :   ASM_INLINE_P (asm_stmt) = is_inline;
    2020                 :         60 :   if (is_volatile)
    2021                 :         20 :     ASM_VOLATILE_P (asm_stmt) = 1;
    2022                 :         60 :   if (loc)
    2023                 :          0 :     set_tree_location (asm_stmt, loc);
    2024                 :         60 :   add_stmt (asm_stmt);
    2025                 :         60 : }
    2026                 :            : 
    2027                 :            : /* Constructor for gcc::jit::playback::block.  */
    2028                 :            : 
    2029                 :       4933 : playback::block::
    2030                 :            : block (function *func,
    2031                 :       4933 :        const char *name)
    2032                 :       4933 : : m_func (func),
    2033                 :       4933 :   m_stmts ()
    2034                 :            : {
    2035                 :       4933 :   tree identifier;
    2036                 :            : 
    2037                 :       4933 :   gcc_assert (func);
    2038                 :            :   // name can be NULL
    2039                 :       4933 :   if (name)
    2040                 :       4171 :     identifier = get_identifier (name);
    2041                 :            :   else
    2042                 :            :     identifier = NULL;
    2043                 :       4933 :   m_label_decl = build_decl (UNKNOWN_LOCATION, LABEL_DECL,
    2044                 :            :                             identifier, void_type_node);
    2045                 :       4933 :   DECL_CONTEXT (m_label_decl) = func->as_fndecl ();
    2046                 :       4933 :   m_label_expr = NULL;
    2047                 :       4933 : }
    2048                 :            : 
    2049                 :            : /* Compile a playback::context:
    2050                 :            : 
    2051                 :            :    - Use the context's options to cconstruct command-line options, and
    2052                 :            :      call into the rest of GCC (toplev::main).
    2053                 :            :    - Assuming it succeeds, we have a .s file.
    2054                 :            :    - We then run the "postprocess" vfunc:
    2055                 :            : 
    2056                 :            :      (A) In-memory compile ("gcc_jit_context_compile")
    2057                 :            : 
    2058                 :            :        For an in-memory compile we have the playback::compile_to_memory
    2059                 :            :        subclass; "postprocess" will convert the .s file to a .so DSO,
    2060                 :            :        and load it in memory (via dlopen), wrapping the result up as
    2061                 :            :        a jit::result and returning it.
    2062                 :            : 
    2063                 :            :      (B) Compile to file ("gcc_jit_context_compile_to_file")
    2064                 :            : 
    2065                 :            :        When compiling to a file, we have the playback::compile_to_file
    2066                 :            :        subclass; "postprocess" will either copy the .s file to the
    2067                 :            :        destination (for GCC_JIT_OUTPUT_KIND_ASSEMBLER), or invoke
    2068                 :            :        the driver to convert it as necessary, copying the result.  */
    2069                 :            : 
    2070                 :            : void
    2071                 :        983 : playback::context::
    2072                 :            : compile ()
    2073                 :            : {
    2074                 :        983 :   JIT_LOG_SCOPE (get_logger ());
    2075                 :            : 
    2076                 :        983 :   const char *ctxt_progname;
    2077                 :            : 
    2078                 :        983 :   int keep_intermediates =
    2079                 :        983 :     get_bool_option (GCC_JIT_BOOL_OPTION_KEEP_INTERMEDIATES);
    2080                 :            : 
    2081                 :        983 :   m_tempdir = new tempdir (get_logger (), keep_intermediates);
    2082                 :        983 :   if (!m_tempdir->create ())
    2083                 :            :     return;
    2084                 :            : 
    2085                 :            :   /* Call into the rest of gcc.
    2086                 :            :      For now, we have to assemble command-line options to pass into
    2087                 :            :      toplev::main, so that they can be parsed. */
    2088                 :            : 
    2089                 :            :   /* Pass in user-provided program name as argv0, if any, so that it
    2090                 :            :      makes it into GCC's "progname" global, used in various diagnostics. */
    2091                 :        983 :   ctxt_progname = get_str_option (GCC_JIT_STR_OPTION_PROGNAME);
    2092                 :            : 
    2093                 :        983 :   if (!ctxt_progname)
    2094                 :         21 :     ctxt_progname = "libgccjit.so";
    2095                 :            : 
    2096                 :        983 :   auto_vec <recording::requested_dump> requested_dumps;
    2097                 :        983 :   m_recording_ctxt->get_all_requested_dumps (&requested_dumps);
    2098                 :            : 
    2099                 :            :   /* Acquire the JIT mutex and set "this" as the active playback ctxt.  */
    2100                 :        983 :   acquire_mutex ();
    2101                 :            : 
    2102                 :        983 :   auto_string_vec fake_args;
    2103                 :        983 :   make_fake_args (&fake_args, ctxt_progname, &requested_dumps);
    2104                 :        983 :   if (errors_occurred ())
    2105                 :            :     {
    2106                 :          0 :       release_mutex ();
    2107                 :          0 :       return;
    2108                 :            :     }
    2109                 :            : 
    2110                 :            :   /* This runs the compiler.  */
    2111                 :        983 :   toplev toplev (get_timer (), /* external_timer */
    2112                 :        983 :                  false); /* init_signals */
    2113                 :        983 :   enter_scope ("toplev::main");
    2114                 :        983 :   if (get_logger ())
    2115                 :       8074 :     for (unsigned i = 0; i < fake_args.length (); i++)
    2116                 :       3675 :       get_logger ()->log ("argv[%i]: %s", i, fake_args[i]);
    2117                 :       2949 :   toplev.main (fake_args.length (),
    2118                 :            :                const_cast <char **> (fake_args.address ()));
    2119                 :        983 :   exit_scope ("toplev::main");
    2120                 :            : 
    2121                 :            :   /* Extracting dumps makes use of the gcc::dump_manager, hence we
    2122                 :            :      need to do it between toplev::main (which creates the dump manager)
    2123                 :            :      and toplev::finalize (which deletes it).  */
    2124                 :        983 :   extract_any_requested_dumps (&requested_dumps);
    2125                 :            : 
    2126                 :            :   /* Clean up the compiler.  */
    2127                 :        983 :   enter_scope ("toplev::finalize");
    2128                 :        983 :   toplev.finalize ();
    2129                 :        983 :   exit_scope ("toplev::finalize");
    2130                 :            : 
    2131                 :            :   /* Ideally we would release the jit mutex here, but we can't yet since
    2132                 :            :      followup activities use timevars, which are global state.  */
    2133                 :            : 
    2134                 :        983 :   if (errors_occurred ())
    2135                 :            :     {
    2136                 :         25 :       release_mutex ();
    2137                 :         25 :       return;
    2138                 :            :     }
    2139                 :            : 
    2140                 :        958 :   if (get_bool_option (GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE))
    2141                 :          0 :     dump_generated_code ();
    2142                 :            : 
    2143                 :            :   /* We now have a .s file.
    2144                 :            : 
    2145                 :            :      Run any postprocessing steps.  This will either convert the .s file to
    2146                 :            :      a .so DSO, and load it in memory (playback::compile_to_memory), or
    2147                 :            :      convert the .s file to the requested output format, and copy it to a
    2148                 :            :      given file (playback::compile_to_file).  */
    2149                 :        958 :   postprocess (ctxt_progname);
    2150                 :            : 
    2151                 :        958 :   release_mutex ();
    2152                 :       1008 : }
    2153                 :            : 
    2154                 :            : /* Implementation of class gcc::jit::playback::compile_to_memory,
    2155                 :            :    a subclass of gcc::jit::playback::context.  */
    2156                 :            : 
    2157                 :            : /*  playback::compile_to_memory's trivial constructor. */
    2158                 :            : 
    2159                 :        957 : playback::compile_to_memory::compile_to_memory (recording::context *ctxt) :
    2160                 :            :   playback::context (ctxt),
    2161                 :        957 :   m_result (NULL)
    2162                 :            : {
    2163                 :        957 :   JIT_LOG_SCOPE (get_logger ());
    2164                 :        957 : }
    2165                 :            : 
    2166                 :            : /*  Implementation of the playback::context::process vfunc for compiling
    2167                 :            :     to memory.
    2168                 :            : 
    2169                 :            :     Convert the .s file to a .so DSO, and load it in memory (via dlopen),
    2170                 :            :     wrapping the result up as a jit::result and returning it.  */
    2171                 :            : 
    2172                 :            : void
    2173                 :        932 : playback::compile_to_memory::postprocess (const char *ctxt_progname)
    2174                 :            : {
    2175                 :        932 :   JIT_LOG_SCOPE (get_logger ());
    2176                 :        932 :   convert_to_dso (ctxt_progname);
    2177                 :        932 :   if (errors_occurred ())
    2178                 :          5 :     return;
    2179                 :        927 :   m_result = dlopen_built_dso ();
    2180                 :        932 : }
    2181                 :            : 
    2182                 :            : /* Implementation of class gcc::jit::playback::compile_to_file,
    2183                 :            :    a subclass of gcc::jit::playback::context.  */
    2184                 :            : 
    2185                 :            : /*  playback::compile_to_file's trivial constructor. */
    2186                 :            : 
    2187                 :         26 : playback::compile_to_file::compile_to_file (recording::context *ctxt,
    2188                 :            :                                             enum gcc_jit_output_kind output_kind,
    2189                 :         26 :                                             const char *output_path) :
    2190                 :            :   playback::context (ctxt),
    2191                 :         26 :   m_output_kind (output_kind),
    2192                 :         26 :   m_output_path (output_path)
    2193                 :            : {
    2194                 :         26 :   JIT_LOG_SCOPE (get_logger ());
    2195                 :         26 : }
    2196                 :            : 
    2197                 :            : /*  Implementation of the playback::context::process vfunc for compiling
    2198                 :            :     to a file.
    2199                 :            : 
    2200                 :            :     Either copy the .s file to the given destination (for
    2201                 :            :     GCC_JIT_OUTPUT_KIND_ASSEMBLER), or invoke the driver to convert it
    2202                 :            :     as necessary, copying the result.  */
    2203                 :            : 
    2204                 :            : void
    2205                 :         26 : playback::compile_to_file::postprocess (const char *ctxt_progname)
    2206                 :            : {
    2207                 :         26 :   JIT_LOG_SCOPE (get_logger ());
    2208                 :            : 
    2209                 :            :   /* The driver takes different actions based on the filename, so
    2210                 :            :      we provide a filename with an appropriate suffix for the
    2211                 :            :      output kind, and then copy it up to the user-provided path,
    2212                 :            :      rather than directly compiling it to the requested output path.  */
    2213                 :            : 
    2214                 :         26 :   switch (m_output_kind)
    2215                 :            :     {
    2216                 :          0 :     default:
    2217                 :          0 :       gcc_unreachable ();
    2218                 :            : 
    2219                 :          5 :     case GCC_JIT_OUTPUT_KIND_ASSEMBLER:
    2220                 :          5 :       copy_file (get_tempdir ()->get_path_s_file (),
    2221                 :            :                  m_output_path);
    2222                 :            :       /* The .s file is automatically unlinked by tempdir::~tempdir.  */
    2223                 :          5 :       break;
    2224                 :            : 
    2225                 :          5 :     case GCC_JIT_OUTPUT_KIND_OBJECT_FILE:
    2226                 :          5 :       {
    2227                 :          5 :         char *tmp_o_path = ::concat (get_tempdir ()->get_path (),
    2228                 :            :                                      "/fake.o",
    2229                 :            :                                      NULL);
    2230                 :          5 :         invoke_driver (ctxt_progname,
    2231                 :            :                        get_tempdir ()->get_path_s_file (),
    2232                 :            :                        tmp_o_path,
    2233                 :            :                        TV_ASSEMBLE,
    2234                 :            :                        false, /* bool shared, */
    2235                 :            :                        false);/* bool run_linker */
    2236                 :          5 :         if (!errors_occurred ())
    2237                 :            :           {
    2238                 :          5 :             copy_file (tmp_o_path,
    2239                 :            :                        m_output_path);
    2240                 :          5 :             get_tempdir ()->add_temp_file (tmp_o_path);
    2241                 :            :           }
    2242                 :            :         else
    2243                 :          0 :           free (tmp_o_path);
    2244                 :            :       }
    2245                 :            :       break;
    2246                 :            : 
    2247                 :          5 :     case GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY:
    2248                 :          5 :       invoke_driver (ctxt_progname,
    2249                 :            :                      get_tempdir ()->get_path_s_file (),
    2250                 :            :                      get_tempdir ()->get_path_so_file (),
    2251                 :            :                      TV_ASSEMBLE,
    2252                 :            :                      true, /* bool shared, */
    2253                 :            :                      true);/* bool run_linker */
    2254                 :          5 :       if (!errors_occurred ())
    2255                 :          5 :         copy_file (get_tempdir ()->get_path_so_file (),
    2256                 :            :                    m_output_path);
    2257                 :            :       /* The .so file is automatically unlinked by tempdir::~tempdir.  */
    2258                 :            :       break;
    2259                 :            : 
    2260                 :         11 :     case GCC_JIT_OUTPUT_KIND_EXECUTABLE:
    2261                 :         11 :       {
    2262                 :         11 :         char *tmp_exe_path = ::concat (get_tempdir ()->get_path (),
    2263                 :            :                                      "/fake.exe",
    2264                 :            :                                      NULL);
    2265                 :         11 :         invoke_driver (ctxt_progname,
    2266                 :            :                        get_tempdir ()->get_path_s_file (),
    2267                 :            :                        tmp_exe_path,
    2268                 :            :                        TV_ASSEMBLE,
    2269                 :            :                        false, /* bool shared, */
    2270                 :            :                        true);/* bool run_linker */
    2271                 :         11 :         if (!errors_occurred ())
    2272                 :            :           {
    2273                 :         11 :             copy_file (tmp_exe_path,
    2274                 :            :                        m_output_path);
    2275                 :         11 :             get_tempdir ()->add_temp_file (tmp_exe_path);
    2276                 :            :           }
    2277                 :            :         else
    2278                 :          0 :           free (tmp_exe_path);
    2279                 :            :       }
    2280                 :            :       break;
    2281                 :            : 
    2282                 :            :     }
    2283                 :            : 
    2284                 :         26 : }
    2285                 :            : 
    2286                 :            : /* Copy SRC_PATH to DST_PATH, preserving permission bits (in particular,
    2287                 :            :    the "executable" bits).
    2288                 :            : 
    2289                 :            :    Any errors that occur are reported on the context and hence count as
    2290                 :            :    a failure of the compile.
    2291                 :            : 
    2292                 :            :    We can't in general hardlink or use "rename" from the tempdir since
    2293                 :            :    it might be on a different filesystem to the destination.  For example,
    2294                 :            :    I get EXDEV: "Invalid cross-device link".  */
    2295                 :            : 
    2296                 :            : void
    2297                 :         26 : playback::compile_to_file::copy_file (const char *src_path,
    2298                 :            :                                       const char *dst_path)
    2299                 :            : {
    2300                 :         26 :   JIT_LOG_SCOPE (get_logger ());
    2301                 :         26 :   if (get_logger ())
    2302                 :            :     {
    2303                 :         25 :       get_logger ()->log ("src_path: %s", src_path);
    2304                 :         25 :       get_logger ()->log ("dst_path: %s", dst_path);
    2305                 :            :     }
    2306                 :            : 
    2307                 :         26 :   FILE *f_in = NULL;
    2308                 :         26 :   FILE *f_out = NULL;
    2309                 :         26 :   size_t total_sz_in = 0;
    2310                 :         26 :   size_t total_sz_out = 0;
    2311                 :         26 :   char buf[4096];
    2312                 :         26 :   size_t sz_in;
    2313                 :         26 :   struct stat stat_buf;
    2314                 :            : 
    2315                 :         26 :   f_in = fopen (src_path, "rb");
    2316                 :         26 :   if (!f_in)
    2317                 :            :     {
    2318                 :          0 :       add_error (NULL,
    2319                 :            :                  "unable to open %s for reading: %s",
    2320                 :            :                  src_path,
    2321                 :          0 :                  xstrerror (errno));
    2322                 :          0 :       return;
    2323                 :            :     }
    2324                 :            : 
    2325                 :            :   /* Use stat on the filedescriptor to get the mode,
    2326                 :            :      so that we can copy it over (in particular, the
    2327                 :            :      "executable" bits).  */
    2328                 :         26 :   if (fstat (fileno (f_in), &stat_buf) == -1)
    2329                 :            :     {
    2330                 :          0 :       add_error (NULL,
    2331                 :            :                  "unable to fstat %s: %s",
    2332                 :            :                  src_path,
    2333                 :          0 :                  xstrerror (errno));
    2334                 :          0 :       fclose (f_in);
    2335                 :          0 :       return;
    2336                 :            :     }
    2337                 :            : 
    2338                 :         26 :   f_out = fopen (dst_path, "wb");
    2339                 :         26 :   if (!f_out)
    2340                 :            :     {
    2341                 :          0 :       add_error (NULL,
    2342                 :            :                  "unable to open %s for writing: %s",
    2343                 :            :                  dst_path,
    2344                 :          0 :                  xstrerror (errno));
    2345                 :          0 :       fclose (f_in);
    2346                 :          0 :       return;
    2347                 :            :     }
    2348                 :            : 
    2349                 :        132 :   while ( (sz_in = fread (buf, 1, sizeof (buf), f_in)) )
    2350                 :            :     {
    2351                 :        106 :       total_sz_in += sz_in;
    2352                 :        106 :       size_t sz_out_remaining = sz_in;
    2353                 :        106 :       size_t sz_out_so_far = 0;
    2354                 :        212 :       while (sz_out_remaining)
    2355                 :            :         {
    2356                 :        106 :           size_t sz_out = fwrite (buf + sz_out_so_far,
    2357                 :            :                                   1,
    2358                 :            :                                   sz_out_remaining,
    2359                 :            :                                   f_out);
    2360                 :        106 :           gcc_assert (sz_out <= sz_out_remaining);
    2361                 :        106 :           if (!sz_out)
    2362                 :            :             {
    2363                 :          0 :               add_error (NULL,
    2364                 :            :                          "error writing to %s: %s",
    2365                 :            :                          dst_path,
    2366                 :          0 :                          xstrerror (errno));
    2367                 :          0 :               fclose (f_in);
    2368                 :          0 :               fclose (f_out);
    2369                 :          0 :               return;
    2370                 :            :             }
    2371                 :        106 :           total_sz_out += sz_out;
    2372                 :        106 :           sz_out_so_far += sz_out;
    2373                 :        106 :           sz_out_remaining -= sz_out;
    2374                 :            :         }
    2375                 :        106 :       gcc_assert (sz_out_so_far == sz_in);
    2376                 :            :     }
    2377                 :            : 
    2378                 :         26 :   if (!feof (f_in))
    2379                 :          0 :     add_error (NULL,
    2380                 :            :                "error reading from %s: %s",
    2381                 :            :                src_path,
    2382                 :          0 :                xstrerror (errno));
    2383                 :            : 
    2384                 :         26 :   fclose (f_in);
    2385                 :            : 
    2386                 :         26 :   gcc_assert (total_sz_in == total_sz_out);
    2387                 :         26 :   if (get_logger ())
    2388                 :         25 :     get_logger ()->log ("total bytes copied: %zu", total_sz_out);
    2389                 :            : 
    2390                 :            :   /* fchmod does not exist in Windows. */
    2391                 :            : #ifndef _WIN32
    2392                 :            :   /* Set the permissions of the copy to those of the original file,
    2393                 :            :      in particular the "executable" bits.  */
    2394                 :         26 :   if (fchmod (fileno (f_out), stat_buf.st_mode) == -1)
    2395                 :          0 :     add_error (NULL,
    2396                 :            :                "error setting mode of %s: %s",
    2397                 :            :                dst_path,
    2398                 :          0 :                xstrerror (errno));
    2399                 :            : #endif
    2400                 :            : 
    2401                 :         26 :   fclose (f_out);
    2402                 :         26 : }
    2403                 :            : 
    2404                 :            : /* Helper functions for gcc::jit::playback::context::compile.  */
    2405                 :            : 
    2406                 :            : /* This mutex guards gcc::jit::recording::context::compile, so that only
    2407                 :            :    one thread can be accessing the bulk of GCC's state at once.  */
    2408                 :            : 
    2409                 :            : static pthread_mutex_t jit_mutex = PTHREAD_MUTEX_INITIALIZER;
    2410                 :            : 
    2411                 :            : /* Acquire jit_mutex and set "this" as the active playback ctxt.  */
    2412                 :            : 
    2413                 :            : void
    2414                 :        983 : playback::context::acquire_mutex ()
    2415                 :            : {
    2416                 :        983 :   auto_timevar tv (get_timer (), TV_JIT_ACQUIRING_MUTEX);
    2417                 :            : 
    2418                 :            :   /* Acquire the big GCC mutex. */
    2419                 :        983 :   JIT_LOG_SCOPE (get_logger ());
    2420                 :        983 :   pthread_mutex_lock (&jit_mutex);
    2421                 :        983 :   gcc_assert (active_playback_ctxt == NULL);
    2422                 :        983 :   active_playback_ctxt = this;
    2423                 :        983 : }
    2424                 :            : 
    2425                 :            : /* Release jit_mutex and clear the active playback ctxt.  */
    2426                 :            : 
    2427                 :            : void
    2428                 :        983 : playback::context::release_mutex ()
    2429                 :            : {
    2430                 :            :   /* Release the big GCC mutex. */
    2431                 :        983 :   JIT_LOG_SCOPE (get_logger ());
    2432                 :        983 :   gcc_assert (active_playback_ctxt == this);
    2433                 :        983 :   active_playback_ctxt = NULL;
    2434                 :        983 :   pthread_mutex_unlock (&jit_mutex);
    2435                 :        983 : }
    2436                 :            : 
    2437                 :            : /* Callback used by gcc::jit::playback::context::make_fake_args when
    2438                 :            :    invoking driver_get_configure_time_options.
    2439                 :            :    Populate a vec <char * > with the configure-time options.  */
    2440                 :            : 
    2441                 :            : static void
    2442                 :        164 : append_arg_from_driver (const char *option, void *user_data)
    2443                 :            : {
    2444                 :        164 :   gcc_assert (option);
    2445                 :        164 :   gcc_assert (user_data);
    2446                 :        164 :   vec <char *> *argvec = static_cast <vec <char *> *> (user_data);
    2447                 :        164 :   argvec->safe_push (concat ("-", option, NULL));
    2448                 :        164 : }
    2449                 :            : 
    2450                 :            : /* Build a fake argv for toplev::main from the options set
    2451                 :            :    by the user on the context .  */
    2452                 :            : 
    2453                 :            : void
    2454                 :        983 : playback::context::
    2455                 :            : make_fake_args (vec <char *> *argvec,
    2456                 :            :                 const char *ctxt_progname,
    2457                 :            :                 vec <recording::requested_dump> *requested_dumps)
    2458                 :            : {
    2459                 :        983 :   JIT_LOG_SCOPE (get_logger ());
    2460                 :            : 
    2461                 :            : #define ADD_ARG(arg) argvec->safe_push (xstrdup (arg))
    2462                 :            : #define ADD_ARG_TAKE_OWNERSHIP(arg) argvec->safe_push (arg)
    2463                 :            : 
    2464                 :        983 :   ADD_ARG (ctxt_progname);
    2465                 :        983 :   ADD_ARG (get_path_c_file ());
    2466                 :        983 :   ADD_ARG ("-fPIC");
    2467                 :            : 
    2468                 :            :   /* Handle int options: */
    2469                 :        983 :   switch (get_int_option (GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL))
    2470                 :            :     {
    2471                 :          0 :     default:
    2472                 :          0 :       add_error (NULL,
    2473                 :            :                  "unrecognized optimization level: %i",
    2474                 :            :                  get_int_option (GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL));
    2475                 :          0 :       return;
    2476                 :            : 
    2477                 :        116 :     case 0:
    2478                 :        116 :       ADD_ARG ("-O0");
    2479                 :        116 :       break;
    2480                 :            : 
    2481                 :        100 :     case 1:
    2482                 :        100 :       ADD_ARG ("-O1");
    2483                 :        100 :       break;
    2484                 :            : 
    2485                 :        100 :     case 2:
    2486                 :        100 :       ADD_ARG ("-O2");
    2487                 :        100 :       break;
    2488                 :            : 
    2489                 :        667 :     case 3:
    2490                 :        667 :       ADD_ARG ("-O3");
    2491                 :        667 :       break;
    2492                 :            :     }
    2493                 :            :   /* What about -Os? */
    2494                 :            : 
    2495                 :            :   /* Handle bool options: */
    2496                 :        983 :   if (get_bool_option (GCC_JIT_BOOL_OPTION_DEBUGINFO))
    2497                 :        577 :     ADD_ARG ("-g");
    2498                 :            : 
    2499                 :            :   /* Suppress timing (and other) info.  */
    2500                 :        983 :   if (!get_bool_option (GCC_JIT_BOOL_OPTION_DUMP_SUMMARY))
    2501                 :            :     {
    2502                 :        983 :       ADD_ARG ("-quiet");
    2503                 :        983 :       quiet_flag = 1;
    2504                 :            :     }
    2505                 :            : 
    2506                 :            :   /* Aggressively garbage-collect, to shake out bugs: */
    2507                 :        983 :   if (get_bool_option (GCC_JIT_BOOL_OPTION_SELFCHECK_GC))
    2508                 :            :     {
    2509                 :        567 :       ADD_ARG ("--param=ggc-min-expand=0");
    2510                 :        567 :       ADD_ARG ("--param=ggc-min-heapsize=0");
    2511                 :            :     }
    2512                 :            : 
    2513                 :        983 :   if (get_bool_option (GCC_JIT_BOOL_OPTION_DUMP_EVERYTHING))
    2514                 :            :     {
    2515                 :          0 :       ADD_ARG ("-fdump-tree-all");
    2516                 :          0 :       ADD_ARG ("-fdump-rtl-all");
    2517                 :          0 :       ADD_ARG ("-fdump-ipa-all");
    2518                 :            :     }
    2519                 :            : 
    2520                 :            :   /* Add "-fdump-" options for any calls to
    2521                 :            :      gcc_jit_context_enable_dump.  */
    2522                 :            :   {
    2523                 :            :     int i;
    2524                 :            :     recording::requested_dump *d;
    2525                 :       1033 :     FOR_EACH_VEC_ELT (*requested_dumps, i, d)
    2526                 :            :       {
    2527                 :         50 :         char *arg = concat ("-fdump-", d->m_dumpname, NULL);
    2528                 :         50 :         ADD_ARG_TAKE_OWNERSHIP (arg);
    2529                 :            :       }
    2530                 :            :   }
    2531                 :            : 
    2532                 :            :   /* PR jit/64810: Add any target-specific default options
    2533                 :            :      from OPTION_DEFAULT_SPECS, normally provided by the driver
    2534                 :            :      in the non-jit case.
    2535                 :            : 
    2536                 :            :      The target-specific code can define OPTION_DEFAULT_SPECS:
    2537                 :            :      default command options in the form of spec macros for the
    2538                 :            :      driver to expand ().
    2539                 :            : 
    2540                 :            :      For cc1 etc, the driver processes OPTION_DEFAULT_SPECS and,
    2541                 :            :      if not overriden, injects the defaults as extra arguments to
    2542                 :            :      cc1 etc.
    2543                 :            :      For the jit case, we need to add these arguments here.  The
    2544                 :            :      input format (using the specs language) means that we have to run
    2545                 :            :      part of the driver code here (driver_get_configure_time_options).
    2546                 :            : 
    2547                 :            :      To avoid running the spec-expansion code every time, we just do
    2548                 :            :      it the first time (via a function-static flag), saving the result
    2549                 :            :      into a function-static vec.
    2550                 :            :      This flag and vec are global state (i.e. per-process).
    2551                 :            :      They are guarded by the jit mutex.  */
    2552                 :        983 :   {
    2553                 :        983 :     static bool have_configure_time_options = false;
    2554                 :        983 :     static vec <char *> configure_time_options;
    2555                 :            : 
    2556                 :        983 :     if (have_configure_time_options)
    2557                 :        901 :       log ("reusing cached configure-time options");
    2558                 :            :     else
    2559                 :            :       {
    2560                 :         82 :         have_configure_time_options = true;
    2561                 :         82 :         log ("getting configure-time options from driver");
    2562                 :         82 :         driver_get_configure_time_options (append_arg_from_driver,
    2563                 :            :                                            &configure_time_options);
    2564                 :            :       }
    2565                 :            : 
    2566                 :        983 :     int i;
    2567                 :        983 :     char *opt;
    2568                 :            : 
    2569                 :        983 :     if (get_logger ())
    2570                 :       1086 :       FOR_EACH_VEC_ELT (configure_time_options, i, opt)
    2571                 :        724 :         log ("configure_time_options[%i]: %s", i, opt);
    2572                 :            : 
    2573                 :            :     /* configure_time_options should now contain the expanded options
    2574                 :            :        from OPTION_DEFAULT_SPECS (if any).  */
    2575                 :       2949 :     FOR_EACH_VEC_ELT (configure_time_options, i, opt)
    2576                 :            :       {
    2577                 :       1966 :         gcc_assert (opt);
    2578                 :       1966 :         gcc_assert (opt[0] == '-');
    2579                 :       1966 :         ADD_ARG (opt);
    2580                 :            :       }
    2581                 :            :   }
    2582                 :            : 
    2583                 :        983 :   if (get_timer ())
    2584                 :        400 :     ADD_ARG ("-ftime-report");
    2585                 :            : 
    2586                 :            :   /* Add any user-provided extra options, starting with any from
    2587                 :            :      parent contexts.  */
    2588                 :        983 :   m_recording_ctxt->append_command_line_options (argvec);
    2589                 :            : 
    2590                 :            : #undef ADD_ARG
    2591                 :            : #undef ADD_ARG_TAKE_OWNERSHIP
    2592                 :        983 : }
    2593                 :            : 
    2594                 :            : /* The second half of the implementation of gcc_jit_context_enable_dump.
    2595                 :            :    Iterate through the requested dumps, reading the underlying files
    2596                 :            :    into heap-allocated buffers, writing pointers to the buffers into
    2597                 :            :    the char ** pointers provided by client code.
    2598                 :            :    Client code is responsible for calling free on the results.  */
    2599                 :            : 
    2600                 :            : void
    2601                 :        983 : playback::context::
    2602                 :            : extract_any_requested_dumps (vec <recording::requested_dump> *requested_dumps)
    2603                 :            : {
    2604                 :        983 :   JIT_LOG_SCOPE (get_logger ());
    2605                 :            : 
    2606                 :        983 :   int i;
    2607                 :        983 :   recording::requested_dump *d;
    2608                 :       1033 :   FOR_EACH_VEC_ELT (*requested_dumps, i, d)
    2609                 :            :     {
    2610                 :         50 :       dump_file_info *dfi;
    2611                 :         50 :       char *filename;
    2612                 :         50 :       char *content;
    2613                 :            : 
    2614                 :         50 :       dfi = g->get_dumps ()->get_dump_file_info_by_switch (d->m_dumpname);
    2615                 :         50 :       if (!dfi)
    2616                 :            :         {
    2617                 :          5 :           add_error (NULL, "unrecognized dump: %s", d->m_dumpname);
    2618                 :          5 :           continue;
    2619                 :            :         }
    2620                 :            : 
    2621                 :         45 :       filename = g->get_dumps ()->get_dump_file_name (dfi);
    2622                 :         45 :       content = read_dump_file (filename);
    2623                 :         45 :       *(d->m_out_ptr) = content;
    2624                 :         45 :       m_tempdir->add_temp_file (filename);
    2625                 :            :     }
    2626                 :        983 : }
    2627                 :            : 
    2628                 :            : /* Helper function for playback::context::extract_any_requested_dumps
    2629                 :            :    (itself for use in implementation of gcc_jit_context_enable_dump).
    2630                 :            : 
    2631                 :            :    Attempt to read the complete file at the given path, returning the
    2632                 :            :    bytes found there as a buffer.
    2633                 :            :    The caller is responsible for calling free on the result.
    2634                 :            :    Errors will be reported on the context, and lead to NULL being
    2635                 :            :    returned; an out-of-memory error will terminate the process.  */
    2636                 :            : 
    2637                 :            : char *
    2638                 :         45 : playback::context::read_dump_file (const char *path)
    2639                 :            : {
    2640                 :         45 :   char *result = NULL;
    2641                 :         45 :   size_t total_sz = 0;
    2642                 :         45 :   char buf[4096];
    2643                 :         45 :   size_t sz;
    2644                 :         45 :   FILE *f_in;
    2645                 :            : 
    2646                 :         45 :   f_in = fopen (path, "r");
    2647                 :         45 :   if (!f_in)
    2648                 :            :     {
    2649                 :          0 :       add_error (NULL, "unable to open %s for reading", path);
    2650                 :          0 :       return NULL;
    2651                 :            :     }
    2652                 :            : 
    2653                 :       4795 :   while ( (sz = fread (buf, 1, sizeof (buf), f_in)) )
    2654                 :            :     {
    2655                 :       4750 :       size_t old_total_sz = total_sz;
    2656                 :       4750 :       total_sz += sz;
    2657                 :       4750 :       result = reinterpret_cast <char *> (xrealloc (result, total_sz + 1));
    2658                 :       4750 :       memcpy (result + old_total_sz, buf, sz);
    2659                 :            :     }
    2660                 :            : 
    2661                 :         45 :   if (!feof (f_in))
    2662                 :            :     {
    2663                 :          0 :       add_error (NULL, "error reading from %s", path);
    2664                 :          0 :       free (result);
    2665                 :          0 :       fclose (f_in);
    2666                 :          0 :       return NULL;
    2667                 :            :     }
    2668                 :            : 
    2669                 :         45 :   fclose (f_in);
    2670                 :            : 
    2671                 :         45 :   if (result)
    2672                 :            :     {
    2673                 :         45 :       result[total_sz] = '\0';
    2674                 :         45 :       return result;
    2675                 :            :     }
    2676                 :            :   else
    2677                 :          0 :     return xstrdup ("");
    2678                 :            : }
    2679                 :            : 
    2680                 :            : /* Part of playback::context::compile ().
    2681                 :            : 
    2682                 :            :    We have a .s file; we want a .so file.
    2683                 :            :    We could reuse parts of gcc/gcc.c to do this.
    2684                 :            :    For now, just use the driver binary from the install, as
    2685                 :            :    named in gcc-driver-name.h
    2686                 :            :    e.g. "x86_64-unknown-linux-gnu-gcc-5.0.0".  */
    2687                 :            : 
    2688                 :            : void
    2689                 :        932 : playback::context::
    2690                 :            : convert_to_dso (const char *ctxt_progname)
    2691                 :            : {
    2692                 :        932 :   JIT_LOG_SCOPE (get_logger ());
    2693                 :            : 
    2694                 :        932 :   invoke_driver (ctxt_progname,
    2695                 :        932 :                  m_tempdir->get_path_s_file (),
    2696                 :        932 :                  m_tempdir->get_path_so_file (),
    2697                 :            :                  TV_ASSEMBLE,
    2698                 :            :                  true, /* bool shared, */
    2699                 :            :                  true);/* bool run_linker */
    2700                 :        932 : }
    2701                 :            : 
    2702                 :            : static const char * const gcc_driver_name = GCC_DRIVER_NAME;
    2703                 :            : 
    2704                 :            : void
    2705                 :        953 : playback::context::
    2706                 :            : invoke_driver (const char *ctxt_progname,
    2707                 :            :                const char *input_file,
    2708                 :            :                const char *output_file,
    2709                 :            :                timevar_id_t tv_id,
    2710                 :            :                bool shared,
    2711                 :            :                bool run_linker)
    2712                 :            : {
    2713                 :        953 :   JIT_LOG_SCOPE (get_logger ());
    2714                 :            : 
    2715                 :        953 :   bool embedded_driver
    2716                 :        953 :     = !get_inner_bool_option (INNER_BOOL_OPTION_USE_EXTERNAL_DRIVER);
    2717                 :            : 
    2718                 :            :   /* Currently this lumps together both assembling and linking into
    2719                 :            :      TV_ASSEMBLE.  */
    2720                 :        953 :   auto_timevar assemble_timevar (get_timer (), tv_id);
    2721                 :        953 :   auto_string_vec argvec;
    2722                 :            : #define ADD_ARG(arg) argvec.safe_push (xstrdup (arg))
    2723                 :            : 
    2724                 :        953 :   ADD_ARG (gcc_driver_name);
    2725                 :            : 
    2726                 :        953 :   add_multilib_driver_arguments (&argvec);
    2727                 :            : 
    2728                 :        953 :   if (shared)
    2729                 :        937 :     ADD_ARG ("-shared");
    2730                 :            : 
    2731                 :        953 :   if (!run_linker)
    2732                 :          5 :     ADD_ARG ("-c");
    2733                 :            : 
    2734                 :        953 :   ADD_ARG (input_file);
    2735                 :        953 :   ADD_ARG ("-o");
    2736                 :        953 :   ADD_ARG (output_file);
    2737                 :            : 
    2738                 :            :   /* Don't use the linker plugin.
    2739                 :            :      If running with just a "make" and not a "make install", then we'd
    2740                 :            :      run into
    2741                 :            :        "fatal error: -fuse-linker-plugin, but liblto_plugin.so not found"
    2742                 :            :      libto_plugin is a .la at build time, with it becoming installed with
    2743                 :            :      ".so" suffix: i.e. it doesn't exist with a .so suffix until install
    2744                 :            :      time.  */
    2745                 :        953 :   ADD_ARG ("-fno-use-linker-plugin");
    2746                 :            : 
    2747                 :            : #if defined (DARWIN_X86) || defined (DARWIN_PPC)
    2748                 :            :   /* OS X's linker defaults to treating undefined symbols as errors.
    2749                 :            :      If the context has any imported functions or globals they will be
    2750                 :            :      undefined until the .so is dynamically-linked into the process.
    2751                 :            :      Ensure that the driver passes in "-undefined dynamic_lookup" to the
    2752                 :            :      linker.  */
    2753                 :            :   ADD_ARG ("-Wl,-undefined,dynamic_lookup");
    2754                 :            : #endif
    2755                 :            : 
    2756                 :        953 :   if (0)
    2757                 :            :     ADD_ARG ("-v");
    2758                 :            : 
    2759                 :            :   /* Add any user-provided driver extra options.  */
    2760                 :            : 
    2761                 :        953 :   m_recording_ctxt->append_driver_options (&argvec);
    2762                 :            : 
    2763                 :            : #undef ADD_ARG
    2764                 :            : 
    2765                 :            :   /* pex_one's error-handling requires pname to be non-NULL.  */
    2766                 :        953 :   gcc_assert (ctxt_progname);
    2767                 :            : 
    2768                 :        953 :   if (get_logger ())
    2769                 :       5312 :     for (unsigned i = 0; i < argvec.length (); i++)
    2770                 :       2324 :       get_logger ()->log ("argv[%i]: %s", i, argvec[i]);
    2771                 :            : 
    2772                 :        953 :   if (embedded_driver)
    2773                 :        948 :     invoke_embedded_driver (&argvec);
    2774                 :            :   else
    2775                 :          5 :     invoke_external_driver (ctxt_progname, &argvec);
    2776                 :        953 : }
    2777                 :            : 
    2778                 :            : void
    2779                 :        948 : playback::context::
    2780                 :            : invoke_embedded_driver (const vec <char *> *argvec)
    2781                 :            : {
    2782                 :        948 :   JIT_LOG_SCOPE (get_logger ());
    2783                 :        948 :   driver d (true, /* can_finalize */
    2784                 :        948 :             false); /* debug */
    2785                 :       1896 :   int result = d.main (argvec->length (),
    2786                 :        948 :                        const_cast <char **> (argvec->address ()));
    2787                 :        948 :   d.finalize ();
    2788                 :        948 :   if (result)
    2789                 :          0 :     add_error (NULL, "error invoking gcc driver");
    2790                 :        948 : }
    2791                 :            : 
    2792                 :            : void
    2793                 :          5 : playback::context::
    2794                 :            : invoke_external_driver (const char *ctxt_progname,
    2795                 :            :                         vec <char *> *argvec)
    2796                 :            : {
    2797                 :          5 :   JIT_LOG_SCOPE (get_logger ());
    2798                 :          5 :   const char *errmsg;
    2799                 :          5 :   int exit_status = 0;
    2800                 :          5 :   int err = 0;
    2801                 :            : 
    2802                 :            :   /* pex argv arrays are NULL-terminated.  */
    2803                 :          5 :   argvec->safe_push (NULL);
    2804                 :            : 
    2805                 :          5 :   errmsg = pex_one (PEX_SEARCH, /* int flags, */
    2806                 :            :                     gcc_driver_name,
    2807                 :          5 :                     const_cast <char *const *> (argvec->address ()),
    2808                 :            :                     ctxt_progname, /* const char *pname */
    2809                 :            :                     NULL, /* const char *outname */
    2810                 :            :                     NULL, /* const char *errname */
    2811                 :            :                     &exit_status, /* int *status */
    2812                 :            :                     &err); /* int *err*/
    2813                 :          5 :   if (errmsg)
    2814                 :            :     {
    2815                 :          5 :       add_error (NULL, "error invoking gcc driver: %s", errmsg);
    2816                 :          5 :       return;
    2817                 :            :     }
    2818                 :            : 
    2819                 :            :   /* pex_one can return a NULL errmsg when the executable wasn't
    2820                 :            :      found (or doesn't exist), so trap these cases also.  */
    2821                 :          0 :   if (exit_status || err)
    2822                 :            :     {
    2823                 :          0 :       add_error (NULL,
    2824                 :            :                  "error invoking gcc driver: exit_status: %i err: %i",
    2825                 :            :                  exit_status, err);
    2826                 :          0 :       add_error (NULL,
    2827                 :            :                  "whilst attempting to run a driver named: %s",
    2828                 :            :                  gcc_driver_name);
    2829                 :          0 :       add_error (NULL,
    2830                 :            :                  "PATH was: %s",
    2831                 :            :                  getenv ("PATH"));
    2832                 :          0 :       return;
    2833                 :            :     }
    2834                 :          5 : }
    2835                 :            : 
    2836                 :            : /* Extract the target-specific MULTILIB_DEFAULTS to
    2837                 :            :    multilib_defaults_raw for use by
    2838                 :            :    playback::context::add_multilib_driver_arguments ().  */
    2839                 :            : 
    2840                 :            : #ifndef MULTILIB_DEFAULTS
    2841                 :            : #define MULTILIB_DEFAULTS { "" }
    2842                 :            : #endif
    2843                 :            : 
    2844                 :            : static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
    2845                 :            : 
    2846                 :            : /* Helper function for playback::context::invoke_driver ().
    2847                 :            : 
    2848                 :            :    32-bit and 64-bit multilib peer builds of libgccjit.so may share
    2849                 :            :    a driver binary.  We need to pass in options to the shared driver
    2850                 :            :    to get the appropriate assembler/linker options for this multilib
    2851                 :            :    peer.  */
    2852                 :            : 
    2853                 :            : void
    2854                 :        953 : playback::context::
    2855                 :            : add_multilib_driver_arguments (vec <char *> *argvec)
    2856                 :            : {
    2857                 :        953 :   JIT_LOG_SCOPE (get_logger ());
    2858                 :            : 
    2859                 :            :   /* Add copies of the arguments in multilib_defaults_raw to argvec,
    2860                 :            :      prepending each with a "-".  */
    2861                 :       1906 :   for (size_t i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
    2862                 :        953 :     if (multilib_defaults_raw[i][0])
    2863                 :        953 :       argvec->safe_push (concat ("-", multilib_defaults_raw[i], NULL));
    2864                 :        953 : }
    2865                 :            : 
    2866                 :            : /* Dynamically-link the built DSO file into this process, using dlopen.
    2867                 :            :    Wrap it up within a jit::result *, and return that.
    2868                 :            :    Return NULL if any errors occur, reporting them on this context.  */
    2869                 :            : 
    2870                 :            : result *
    2871                 :        927 : playback::context::
    2872                 :            : dlopen_built_dso ()
    2873                 :            : {
    2874                 :        927 :   JIT_LOG_SCOPE (get_logger ());
    2875                 :        927 :   auto_timevar load_timevar (get_timer (), TV_LOAD);
    2876                 :        927 :   result::handle handle = NULL;
    2877                 :        927 :   result *result_obj = NULL;
    2878                 :            : 
    2879                 :            : #ifdef _WIN32
    2880                 :            :   /* Clear any existing error.  */
    2881                 :            :   SetLastError(0);
    2882                 :            : 
    2883                 :            :   handle = LoadLibrary(m_tempdir->get_path_so_file ());
    2884                 :            :   if (GetLastError() != 0)  {
    2885                 :            :     print_last_error();
    2886                 :            :   }
    2887                 :            : #else
    2888                 :        927 :   const char *error = NULL;
    2889                 :            :   /* Clear any existing error.  */
    2890                 :        927 :   dlerror ();
    2891                 :            : 
    2892                 :        927 :   handle = dlopen (m_tempdir->get_path_so_file (),
    2893                 :            :                    RTLD_NOW | RTLD_LOCAL);
    2894                 :        927 :   if ((error = dlerror()) != NULL)  {
    2895                 :          0 :     add_error (NULL, "%s", error);
    2896                 :            :   }
    2897                 :            : #endif
    2898                 :            : 
    2899                 :        927 :   if (handle)
    2900                 :            :     {
    2901                 :            :       /* We've successfully dlopened the result; create a
    2902                 :            :          jit::result object to wrap it.
    2903                 :            : 
    2904                 :            :          We're done with the tempdir for now, but if the user
    2905                 :            :          has requested debugging, the user's debugger might not
    2906                 :            :          be capable of dealing with the .so file being unlinked
    2907                 :            :          immediately, so keep it around until after the result
    2908                 :            :          is released.  We do this by handing over ownership of
    2909                 :            :          the jit::tempdir to the result.  See PR jit/64206.  */
    2910                 :        927 :       tempdir *handover_tempdir;
    2911                 :        927 :       if (get_bool_option (GCC_JIT_BOOL_OPTION_DEBUGINFO))
    2912                 :            :         {
    2913                 :        521 :           handover_tempdir = m_tempdir;
    2914                 :        521 :           m_tempdir = NULL;
    2915                 :            :           /* The tempdir will eventually be cleaned up in the
    2916                 :            :              jit::result's dtor. */
    2917                 :        521 :           log ("GCC_JIT_BOOL_OPTION_DEBUGINFO was set:"
    2918                 :            :                " handing over tempdir to jit::result");
    2919                 :            :         }
    2920                 :            :       else
    2921                 :            :         {
    2922                 :        406 :           handover_tempdir = NULL;
    2923                 :            :           /* ... and retain ownership of m_tempdir so we clean it
    2924                 :            :              up it the playback::context's dtor. */
    2925                 :        406 :           log ("GCC_JIT_BOOL_OPTION_DEBUGINFO was not set:"
    2926                 :            :                " retaining ownership of tempdir");
    2927                 :            :         }
    2928                 :            : 
    2929                 :        927 :       result_obj = new result (get_logger (), handle, handover_tempdir);
    2930                 :            :     }
    2931                 :            :   else
    2932                 :            :     result_obj = NULL;
    2933                 :            : 
    2934                 :       1854 :   return result_obj;
    2935                 :        927 : }
    2936                 :            : 
    2937                 :            : /* Top-level hook for playing back a recording context.
    2938                 :            : 
    2939                 :            :    This plays back m_recording_ctxt, and, if no errors
    2940                 :            :    occurred builds statement lists for and then postprocesses
    2941                 :            :    every function in the result.  */
    2942                 :            : 
    2943                 :            : void
    2944                 :        978 : playback::context::
    2945                 :            : replay ()
    2946                 :            : {
    2947                 :        978 :   JIT_LOG_SCOPE (get_logger ());
    2948                 :            : 
    2949                 :        978 :   init_types ();
    2950                 :            : 
    2951                 :            :   /* Replay the recorded events:  */
    2952                 :        978 :   timevar_push (TV_JIT_REPLAY);
    2953                 :            : 
    2954                 :            :   /* Ensure that builtins that could be needed during optimization
    2955                 :            :      get created ahead of time.  */
    2956                 :        978 :   builtins_manager *bm = m_recording_ctxt->get_builtins_manager ();
    2957                 :        978 :   bm->ensure_optimization_builtins_exist ();
    2958                 :            : 
    2959                 :        978 :   m_recording_ctxt->replay_into (this);
    2960                 :            : 
    2961                 :            :   /* Clean away the temporary references from recording objects
    2962                 :            :      to playback objects.  We have to do this now since the
    2963                 :            :      latter are GC-allocated, but the former don't mark these
    2964                 :            :      refs.  Hence we must stop using them before the GC can run.  */
    2965                 :        978 :   m_recording_ctxt->disassociate_from_playback ();
    2966                 :            : 
    2967                 :            :   /* The builtins_manager is associated with the recording::context
    2968                 :            :      and might be reused for future compiles on other playback::contexts,
    2969                 :            :      but its m_attributes array is not GTY-labeled and hence will become
    2970                 :            :      nonsense if the GC runs.  Purge this state.  */
    2971                 :        978 :   bm->finish_playback ();
    2972                 :            : 
    2973                 :        978 :   timevar_pop (TV_JIT_REPLAY);
    2974                 :            : 
    2975                 :        978 :   if (!errors_occurred ())
    2976                 :            :     {
    2977                 :        968 :       int i;
    2978                 :        968 :       function *func;
    2979                 :        968 :       tree global;
    2980                 :            :       /* No GC can happen yet; process the cached source locations.  */
    2981                 :        968 :       handle_locations ();
    2982                 :            : 
    2983                 :            :       /* Finalize globals. See how FORTRAN 95 does it in gfc_be_parse_file()
    2984                 :            :          for a simple reference. */
    2985                 :       2067 :       FOR_EACH_VEC_ELT (m_globals, i, global)
    2986                 :        131 :         rest_of_decl_compilation (global, true, true);
    2987                 :            : 
    2988                 :       1034 :       wrapup_global_declarations (m_globals.address(), m_globals.length());
    2989                 :            : 
    2990                 :            :       /* We've now created tree nodes for the stmts in the various blocks
    2991                 :            :          in each function, but we haven't built each function's single stmt
    2992                 :            :          list yet.  Do so now.  */
    2993                 :       5846 :       FOR_EACH_VEC_ELT (m_functions, i, func)
    2994                 :       3910 :         func->build_stmt_list ();
    2995                 :            : 
    2996                 :            :       /* No GC can have happened yet.  */
    2997                 :            : 
    2998                 :            :       /* Postprocess the functions.  This could trigger GC.  */
    2999                 :       4878 :       FOR_EACH_VEC_ELT (m_functions, i, func)
    3000                 :            :         {
    3001                 :       3910 :           gcc_assert (func);
    3002                 :       3910 :           func->postprocess ();
    3003                 :            :         }
    3004                 :            :     }
    3005                 :        978 : }
    3006                 :            : 
    3007                 :            : /* Dump the generated .s file to stderr.  */
    3008                 :            : 
    3009                 :            : void
    3010                 :          0 : playback::context::
    3011                 :            : dump_generated_code ()
    3012                 :            : {
    3013                 :          0 :   JIT_LOG_SCOPE (get_logger ());
    3014                 :          0 :   char buf[4096];
    3015                 :          0 :   size_t sz;
    3016                 :          0 :   FILE *f_in = fopen (get_path_s_file (), "r");
    3017                 :          0 :   if (!f_in)
    3018                 :          0 :     return;
    3019                 :            : 
    3020                 :          0 :   while ( (sz = fread (buf, 1, sizeof (buf), f_in)) )
    3021                 :          0 :     fwrite (buf, 1, sz, stderr);
    3022                 :            : 
    3023                 :          0 :   fclose (f_in);
    3024                 :          0 : }
    3025                 :            : 
    3026                 :            : /* Get the supposed path of the notional "fake.c" file within the
    3027                 :            :    tempdir.  This file doesn't exist, but the rest of the compiler
    3028                 :            :    needs a name.  */
    3029                 :            : 
    3030                 :            : const char *
    3031                 :        983 : playback::context::
    3032                 :            : get_path_c_file () const
    3033                 :            : {
    3034                 :        983 :   return m_tempdir->get_path_c_file ();
    3035                 :            : }
    3036                 :            : 
    3037                 :            : /* Get the path of the assembler output file "fake.s" file within the
    3038                 :            :    tempdir. */
    3039                 :            : 
    3040                 :            : const char *
    3041                 :          0 : playback::context::
    3042                 :            : get_path_s_file () const
    3043                 :            : {
    3044                 :          0 :   return m_tempdir->get_path_s_file ();
    3045                 :            : }
    3046                 :            : 
    3047                 :            : /* Get the path of the DSO object file "fake.so" file within the
    3048                 :            :    tempdir. */
    3049                 :            : 
    3050                 :            : const char *
    3051                 :          0 : playback::context::
    3052                 :            : get_path_so_file () const
    3053                 :            : {
    3054                 :          0 :   return m_tempdir->get_path_so_file ();
    3055                 :            : }
    3056                 :            : 
    3057                 :            : /* qsort comparator for comparing pairs of playback::source_line *,
    3058                 :            :    ordering them by line number.  */
    3059                 :            : 
    3060                 :            : static int
    3061                 :       5518 : line_comparator (const void *lhs, const void *rhs)
    3062                 :            : {
    3063                 :       5518 :   const playback::source_line *line_lhs = \
    3064                 :            :     *static_cast<const playback::source_line * const*> (lhs);
    3065                 :       5518 :   const playback::source_line *line_rhs = \
    3066                 :            :     *static_cast<const playback::source_line * const*> (rhs);
    3067                 :       5518 :   return line_lhs->get_line_num () - line_rhs->get_line_num ();
    3068                 :            : }
    3069                 :            : 
    3070                 :            : /* qsort comparator for comparing pairs of playback::location *,
    3071                 :            :    ordering them by column number.  */
    3072                 :            : 
    3073                 :            : static int
    3074                 :       6713 : location_comparator (const void *lhs, const void *rhs)
    3075                 :            : {
    3076                 :       6713 :   const playback::location *loc_lhs = \
    3077                 :            :     *static_cast<const playback::location * const *> (lhs);
    3078                 :       6713 :   const playback::location *loc_rhs = \
    3079                 :            :     *static_cast<const playback::location * const *> (rhs);
    3080                 :       6713 :   return loc_lhs->get_column_num () - loc_rhs->get_column_num ();
    3081                 :            : }
    3082                 :            : 
    3083                 :            : /* Initialize the NAME_TYPE of the primitive types as well as some
    3084                 :            :    others. */
    3085                 :            : void
    3086                 :        978 : playback::context::
    3087                 :            : init_types ()
    3088                 :            : {
    3089                 :            :   /* See lto_init() in lto-lang.c or void visit (TypeBasic *t) in D's types.cc 
    3090                 :            :      for reference. If TYPE_NAME is not set, debug info will not contain types */
    3091                 :            : #define NAME_TYPE(t,n) \
    3092                 :            : if (t) \
    3093                 :            :   TYPE_NAME (t) = build_decl (UNKNOWN_LOCATION, TYPE_DECL, \
    3094                 :            :                               get_identifier (n), t)
    3095                 :            : 
    3096                 :        978 :   NAME_TYPE (integer_type_node, "int");
    3097                 :        978 :   NAME_TYPE (char_type_node, "char");
    3098                 :        978 :   NAME_TYPE (long_integer_type_node, "long int");
    3099                 :        978 :   NAME_TYPE (unsigned_type_node, "unsigned int");
    3100                 :        978 :   NAME_TYPE (long_unsigned_type_node, "long unsigned int");
    3101                 :        978 :   NAME_TYPE (long_long_integer_type_node, "long long int");
    3102                 :        978 :   NAME_TYPE (long_long_unsigned_type_node, "long long unsigned int");
    3103                 :        978 :   NAME_TYPE (short_integer_type_node, "short int");
    3104                 :        978 :   NAME_TYPE (short_unsigned_type_node, "short unsigned int");
    3105                 :        978 :   if (signed_char_type_node != char_type_node)
    3106                 :        978 :     NAME_TYPE (signed_char_type_node, "signed char");
    3107                 :        978 :   if (unsigned_char_type_node != char_type_node)
    3108                 :        978 :     NAME_TYPE (unsigned_char_type_node, "unsigned char");
    3109                 :        978 :   NAME_TYPE (float_type_node, "float");
    3110                 :        978 :   NAME_TYPE (double_type_node, "double");
    3111                 :        978 :   NAME_TYPE (long_double_type_node, "long double");
    3112                 :        978 :   NAME_TYPE (void_type_node, "void");
    3113                 :        978 :   NAME_TYPE (boolean_type_node, "bool");
    3114                 :        978 :   NAME_TYPE (complex_float_type_node, "complex float");
    3115                 :        978 :   NAME_TYPE (complex_double_type_node, "complex double");
    3116                 :        978 :   NAME_TYPE (complex_long_double_type_node, "complex long double");
    3117                 :            :   
    3118                 :        978 :   m_const_char_ptr = build_pointer_type(
    3119                 :            :     build_qualified_type (char_type_node, TYPE_QUAL_CONST));
    3120                 :            : 
    3121                 :        978 :   NAME_TYPE (m_const_char_ptr, "char");
    3122                 :        978 :   NAME_TYPE (size_type_node, "size_t");
    3123                 :        978 :   NAME_TYPE (fileptr_type_node, "FILE");
    3124                 :            : #undef NAME_TYPE
    3125                 :        978 : }
    3126                 :            : 
    3127                 :            : /* Our API allows locations to be created in arbitrary orders, but the
    3128                 :            :    linemap API requires locations to be created in ascending order
    3129                 :            :    as if we were tokenizing files.
    3130                 :            : 
    3131                 :            :    This hook sorts all of the locations that have been created, and
    3132                 :            :    calls into the linemap API, creating linemap entries in sorted order
    3133                 :            :    for our locations.  */
    3134                 :            : 
    3135                 :            : void
    3136                 :        968 : playback::context::
    3137                 :            : handle_locations ()
    3138                 :            : {
    3139                 :            :   /* Create the source code locations, following the ordering rules
    3140                 :            :      imposed by the linemap API.
    3141                 :            : 
    3142                 :            :      line_table is a global.  */
    3143                 :        968 :   JIT_LOG_SCOPE (get_logger ());
    3144                 :        968 :   int i;
    3145                 :        968 :   source_file *file;
    3146                 :            : 
    3147                 :       1030 :   FOR_EACH_VEC_ELT (m_source_files, i, file)
    3148                 :            :     {
    3149                 :         62 :       linemap_add (line_table, LC_ENTER, false, file->get_filename (), 0);
    3150                 :            : 
    3151                 :            :       /* Sort lines by ascending line numbers.  */
    3152                 :         62 :       file->m_source_lines.qsort (&line_comparator);
    3153                 :            : 
    3154                 :            :       int j;
    3155                 :            :       source_line *line;
    3156                 :        455 :       FOR_EACH_VEC_ELT (file->m_source_lines, j, line)
    3157                 :            :         {
    3158                 :        393 :           int k;
    3159                 :        393 :           location *loc;
    3160                 :            : 
    3161                 :            :           /* Sort locations in line by ascending column numbers.  */
    3162                 :        393 :           line->m_locations.qsort (&location_comparator);
    3163                 :            : 
    3164                 :            :           /* Determine maximum column within this line.  */
    3165                 :        393 :           gcc_assert (line->m_locations.length () > 0);
    3166                 :        393 :           location *final_column =
    3167                 :        393 :             line->m_locations[line->m_locations.length () - 1];
    3168                 :        393 :           int max_col = final_column->get_column_num ();
    3169                 :            : 
    3170                 :        393 :           linemap_line_start (line_table, line->get_line_num (), max_col);
    3171                 :       1916 :           FOR_EACH_VEC_ELT (line->m_locations, k, loc)
    3172                 :            :             {
    3173                 :        737 :               loc->m_srcloc =                                           \
    3174                 :        737 :                 linemap_position_for_column (line_table, loc->get_column_num ());
    3175                 :            :             }
    3176                 :            :         }
    3177                 :            : 
    3178                 :         62 :       linemap_add (line_table, LC_LEAVE, false, NULL, 0);
    3179                 :            :     }
    3180                 :            : 
    3181                 :            :   /* line_table should now be populated; every playback::location should
    3182                 :            :      now have an m_srcloc.  */
    3183                 :            : 
    3184                 :            :   /* Now assign them to tree nodes as appropriate.  */
    3185                 :            :   std::pair<tree, location *> *cached_location;
    3186                 :            : 
    3187                 :       2528 :   FOR_EACH_VEC_ELT (m_cached_locations, i, cached_location)
    3188                 :            :     {
    3189                 :       1560 :       tree t = cached_location->first;
    3190                 :       1560 :       location_t srcloc = cached_location->second->m_srcloc;
    3191                 :            : 
    3192                 :            :       /* This covers expressions: */
    3193                 :       1560 :       if (CAN_HAVE_LOCATION_P (t))
    3194                 :       1449 :         SET_EXPR_LOCATION (t, srcloc);
    3195                 :        111 :       else if (CODE_CONTAINS_STRUCT(TREE_CODE(t), TS_DECL_MINIMAL))
    3196                 :        111 :         DECL_SOURCE_LOCATION (t) = srcloc;
    3197                 :            :       else
    3198                 :            :         {
    3199                 :            :           /* Don't know how to set location on this node.  */
    3200                 :            :         }
    3201                 :            :     }
    3202                 :        968 : }
    3203                 :            : 
    3204                 :            : /* We handle errors on a playback::context by adding them to the
    3205                 :            :    corresponding recording::context.  */
    3206                 :            : 
    3207                 :            : void
    3208                 :         20 : playback::context::
    3209                 :            : add_error (location *loc, const char *fmt, ...)
    3210                 :            : {
    3211                 :         20 :   va_list ap;
    3212                 :         20 :   va_start (ap, fmt);
    3213                 :         20 :   m_recording_ctxt->add_error_va (loc ? loc->get_recording_loc () : NULL,
    3214                 :            :                                   fmt, ap);
    3215                 :         20 :   va_end (ap);
    3216                 :         20 : }
    3217                 :            : 
    3218                 :            : /* We handle errors on a playback::context by adding them to the
    3219                 :            :    corresponding recording::context.  */
    3220                 :            : 
    3221                 :            : void
    3222                 :          0 : playback::context::
    3223                 :            : add_error_va (location *loc, const char *fmt, va_list ap)
    3224                 :            : {
    3225                 :          0 :   m_recording_ctxt->add_error_va (loc ? loc->get_recording_loc () : NULL,
    3226                 :            :                                   fmt, ap);
    3227                 :          0 : }
    3228                 :            : 
    3229                 :            : /* Report a diagnostic up to the jit context as an error,
    3230                 :            :    so that the compilation is treated as a failure.
    3231                 :            :    For now, any kind of diagnostic is treated as an error by the jit
    3232                 :            :    API.  */
    3233                 :            : 
    3234                 :            : void
    3235                 :         15 : playback::context::
    3236                 :            : add_diagnostic (struct diagnostic_context *diag_context,
    3237                 :            :                 struct diagnostic_info *diagnostic)
    3238                 :            : {
    3239                 :            :   /* At this point the text has been formatted into the pretty-printer's
    3240                 :            :      output buffer.  */
    3241                 :         15 :   pretty_printer *pp = diag_context->printer;
    3242                 :         15 :   const char *text = pp_formatted_text (pp);
    3243                 :            : 
    3244                 :            :   /* Get location information (if any) from the diagnostic.
    3245                 :            :      The recording::context::add_error[_va] methods require a
    3246                 :            :      recording::location.  We can't lookup the playback::location
    3247                 :            :      from the file/line/column since any playback location instances
    3248                 :            :      may have been garbage-collected away by now, so instead we create
    3249                 :            :      another recording::location directly.  */
    3250                 :         15 :   location_t gcc_loc = diagnostic_location (diagnostic);
    3251                 :         15 :   recording::location *rec_loc = NULL;
    3252                 :         15 :   if (gcc_loc)
    3253                 :            :     {
    3254                 :         10 :       expanded_location exploc = expand_location (gcc_loc);
    3255                 :         10 :       if (exploc.file)
    3256                 :          5 :         rec_loc = m_recording_ctxt->new_location (exploc.file,
    3257                 :            :                                                   exploc.line,
    3258                 :            :                                                   exploc.column,
    3259                 :            :                                                   false);
    3260                 :            :     }
    3261                 :            : 
    3262                 :         15 :   m_recording_ctxt->add_error (rec_loc, "%s", text);
    3263                 :         15 :   pp_clear_output_area (pp);
    3264                 :         15 : }
    3265                 :            : 
    3266                 :            : /* Dealing with the linemap API.  */
    3267                 :            : 
    3268                 :            : /* Construct a playback::location for a recording::location, if it
    3269                 :            :    doesn't exist already.  */
    3270                 :            : 
    3271                 :            : playback::location *
    3272                 :        965 : playback::context::
    3273                 :            : new_location (recording::location *rloc,
    3274                 :            :               const char *filename,
    3275                 :            :               int line,
    3276                 :            :               int column)
    3277                 :            : {
    3278                 :            :   /* Get the source_file for filename, creating if necessary.  */
    3279                 :        965 :   source_file *src_file = get_source_file (filename);
    3280                 :            :   /* Likewise for the line within the file.  */
    3281                 :        965 :   source_line *src_line = src_file->get_source_line (line);
    3282                 :            :   /* Likewise for the column within the line.  */
    3283                 :        965 :   location *loc = src_line->get_location (rloc, column);
    3284                 :        965 :   return loc;
    3285                 :            : }
    3286                 :            : 
    3287                 :            : /* Deferred setting of the location for a given tree, by adding the
    3288                 :            :    (tree, playback::location) pair to a list of deferred associations.
    3289                 :            :    We will actually set the location on the tree later on once
    3290                 :            :    the location_t for the playback::location exists.  */
    3291                 :            : 
    3292                 :            : void
    3293                 :       1560 : playback::context::
    3294                 :            : set_tree_location (tree t, location *loc)
    3295                 :            : {
    3296                 :       1560 :   gcc_assert (loc);
    3297                 :       1560 :   m_cached_locations.safe_push (std::make_pair (t, loc));
    3298                 :       1560 : }
    3299                 :            : 
    3300                 :            : 
    3301                 :            : /* Construct a playback::source_file for the given source
    3302                 :            :    filename, if it doesn't exist already.  */
    3303                 :            : 
    3304                 :            : playback::source_file *
    3305                 :        965 : playback::context::
    3306                 :            : get_source_file (const char *filename)
    3307                 :            : {
    3308                 :            :   /* Locate the file.
    3309                 :            :      For simplicitly, this is currently a linear search.
    3310                 :            :      Replace with a hash if this shows up in the profile.  */
    3311                 :        965 :   int i;
    3312                 :        965 :   source_file *file;
    3313                 :        965 :   tree ident_filename = get_identifier (filename);
    3314                 :            : 
    3315                 :       2698 :   FOR_EACH_VEC_ELT (m_source_files, i, file)
    3316                 :       1671 :     if (file->filename_as_tree () == ident_filename)
    3317                 :        903 :       return file;
    3318                 :            : 
    3319                 :            :   /* Not found.  */
    3320                 :         62 :   file = new source_file (ident_filename);
    3321                 :         62 :   m_source_files.safe_push (file);
    3322                 :         62 :   return file;
    3323                 :            : }
    3324                 :            : 
    3325                 :            : /* Constructor for gcc::jit::playback::source_file.  */
    3326                 :            : 
    3327                 :         62 : playback::source_file::source_file (tree filename) :
    3328                 :         62 :   m_source_lines (),
    3329                 :         62 :   m_filename (filename)
    3330                 :            : {
    3331                 :         62 : }
    3332                 :            : 
    3333                 :            : /* Don't leak vec's internal buffer (in non-GC heap) when we are
    3334                 :            :    GC-ed.  */
    3335                 :            : 
    3336                 :            : void
    3337                 :         52 : playback::source_file::finalizer ()
    3338                 :            : {
    3339                 :         52 :   m_source_lines.release ();
    3340                 :         52 : }
    3341                 :            : 
    3342                 :            : /* Construct a playback::source_line for the given line
    3343                 :            :    within this source file, if one doesn't exist already.  */
    3344                 :            : 
    3345                 :            : playback::source_line *
    3346                 :        965 : playback::source_file::
    3347                 :            : get_source_line (int line_num)
    3348                 :            : {
    3349                 :            :   /* Locate the line.
    3350                 :            :      For simplicitly, this is currently a linear search.
    3351                 :            :      Replace with a hash if this shows up in the profile.  */
    3352                 :        965 :   int i;
    3353                 :        965 :   source_line *line;
    3354                 :            : 
    3355                 :       7404 :   FOR_EACH_VEC_ELT (m_source_lines, i, line)
    3356                 :       7011 :     if (line->get_line_num () == line_num)
    3357                 :        572 :       return line;
    3358                 :            : 
    3359                 :            :   /* Not found.  */
    3360                 :        393 :   line = new source_line (this, line_num);
    3361                 :        393 :   m_source_lines.safe_push (line);
    3362                 :        393 :   return line;
    3363                 :            : }
    3364                 :            : 
    3365                 :            : /* Constructor for gcc::jit::playback::source_line.  */
    3366                 :            : 
    3367                 :        393 : playback::source_line::source_line (source_file *file, int line_num) :
    3368                 :        393 :   m_locations (),
    3369                 :        393 :   m_source_file (file),
    3370                 :        393 :   m_line_num (line_num)
    3371                 :            : {
    3372                 :        393 : }
    3373                 :            : 
    3374                 :            : /* Don't leak vec's internal buffer (in non-GC heap) when we are
    3375                 :            :    GC-ed.  */
    3376                 :            : 
    3377                 :            : void
    3378                 :        308 : playback::source_line::finalizer ()
    3379                 :            : {
    3380                 :        308 :   m_locations.release ();
    3381                 :        308 : }
    3382                 :            : 
    3383                 :            : /* Construct a playback::location for the given column
    3384                 :            :    within this line of a specific source file, if one doesn't exist
    3385                 :            :    already.  */
    3386                 :            : 
    3387                 :            : playback::location *
    3388                 :        965 : playback::source_line::
    3389                 :            : get_location (recording::location *rloc, int column_num)
    3390                 :            : {
    3391                 :        965 :   int i;
    3392                 :        965 :   location *loc;
    3393                 :            : 
    3394                 :            :   /* Another linear search that probably should be a hash table.  */
    3395                 :       5376 :   FOR_EACH_VEC_ELT (m_locations, i, loc)
    3396                 :       4639 :     if (loc->get_column_num () == column_num)
    3397                 :        228 :       return loc;
    3398                 :            : 
    3399                 :            :   /* Not found.  */
    3400                 :        737 :   loc = new location (rloc, this, column_num);
    3401                 :        737 :   m_locations.safe_push (loc);
    3402                 :        737 :   return loc;
    3403                 :            : }
    3404                 :            : 
    3405                 :            : /* Constructor for gcc::jit::playback::location.  */
    3406                 :            : 
    3407                 :        737 : playback::location::location (recording::location *loc,
    3408                 :            :                               source_line *line,
    3409                 :        737 :                               int column_num) :
    3410                 :        737 :   m_srcloc (UNKNOWN_LOCATION),
    3411                 :        737 :   m_recording_loc (loc),
    3412                 :        737 :   m_line (line),
    3413                 :        737 :   m_column_num(column_num)
    3414                 :            : {
    3415                 :        737 : }
    3416                 :            : 
    3417                 :            : /* The active gcc::jit::playback::context instance.  This is a singleton,
    3418                 :            :    guarded by jit_mutex.  */
    3419                 :            : 
    3420                 :            : playback::context *active_playback_ctxt;
    3421                 :            : 
    3422                 :            : } // namespace gcc::jit
    3423                 :            : 
    3424                 :            : } // namespace gcc

Generated by: LCOV version 1.15+git.20200812.d100e6c

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.