LCOV - code coverage report
Current view: top level - gcc/jit - libgccjit.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 748 785 95.3 %
Date: 2020-03-28 11:57:23 Functions: 105 113 92.9 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Implementation of the C API; all wrappers into the internal C++ API
       2                 :            :    Copyright (C) 2013-2020 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 "timevar.h"
      25                 :            : #include "typed-splay-tree.h"
      26                 :            : 
      27                 :            : #include "libgccjit.h"
      28                 :            : #include "jit-recording.h"
      29                 :            : #include "jit-result.h"
      30                 :            : 
      31                 :            : /* The opaque types used by the public API are actually subclasses
      32                 :            :    of the gcc::jit::recording classes.  */
      33                 :            : 
      34                 :       2716 : struct gcc_jit_context : public gcc::jit::recording::context
      35                 :            : {
      36                 :       1360 :   gcc_jit_context (gcc_jit_context *parent_ctxt) :
      37                 :       1360 :     context (parent_ctxt)
      38                 :            :   {}
      39                 :            : };
      40                 :            : 
      41                 :            : struct gcc_jit_result : public gcc::jit::result
      42                 :            : {
      43                 :            : };
      44                 :            : 
      45                 :            : struct gcc_jit_object : public gcc::jit::recording::memento
      46                 :            : {
      47                 :            : };
      48                 :            : 
      49                 :            : struct gcc_jit_location : public gcc::jit::recording::location
      50                 :            : {
      51                 :            : };
      52                 :            : 
      53                 :            : struct gcc_jit_type : public gcc::jit::recording::type
      54                 :            : {
      55                 :            : };
      56                 :            : 
      57                 :            : struct gcc_jit_struct : public gcc::jit::recording::struct_
      58                 :            : {
      59                 :            : };
      60                 :            : 
      61                 :            : struct gcc_jit_field : public gcc::jit::recording::field
      62                 :            : {
      63                 :            : };
      64                 :            : 
      65                 :            : struct gcc_jit_bitfield : public gcc::jit::recording::bitfield
      66                 :            : {
      67                 :            : };
      68                 :            : 
      69                 :            : struct gcc_jit_function : public gcc::jit::recording::function
      70                 :            : {
      71                 :            : };
      72                 :            : 
      73                 :            : struct gcc_jit_block : public gcc::jit::recording::block
      74                 :            : {
      75                 :            : };
      76                 :            : 
      77                 :            : struct gcc_jit_rvalue : public gcc::jit::recording::rvalue
      78                 :            : {
      79                 :            : };
      80                 :            : 
      81                 :            : struct gcc_jit_lvalue : public gcc::jit::recording::lvalue
      82                 :            : {
      83                 :            : };
      84                 :            : 
      85                 :            : struct gcc_jit_param : public gcc::jit::recording::param
      86                 :            : {
      87                 :            : };
      88                 :            : 
      89                 :            : struct gcc_jit_case : public gcc::jit::recording::case_
      90                 :            : {
      91                 :            : };
      92                 :            : 
      93                 :         42 : struct gcc_jit_timer : public timer
      94                 :            : {
      95                 :            : };
      96                 :            : 
      97                 :            : /**********************************************************************
      98                 :            :  Error-handling.
      99                 :            : 
     100                 :            :  We try to gracefully handle API usage errors by being defensive
     101                 :            :  at the API boundary.
     102                 :            :  **********************************************************************/
     103                 :            : 
     104                 :            : #define JIT_BEGIN_STMT do {
     105                 :            : #define JIT_END_STMT   } while(0)
     106                 :            : 
     107                 :            : /* Each of these error-handling macros determines if TEST_EXPR holds.
     108                 :            : 
     109                 :            :    If TEXT_EXPR fails to hold we return from the enclosing function and
     110                 :            :    print an error, either via adding an error on the given context CTXT
     111                 :            :    if CTXT is non-NULL, falling back to simply printing to stderr if CTXT
     112                 :            :    is NULL.
     113                 :            : 
     114                 :            :    They have to be macros since they inject their "return" into the
     115                 :            :    function they are placed in.
     116                 :            : 
     117                 :            :    The variant macros express:
     118                 :            : 
     119                 :            :      (A) whether or not we need to return a value:
     120                 :            :             RETURN_VAL_IF_FAIL* vs
     121                 :            :             RETURN_IF_FAIL*,
     122                 :            :          with the former returning RETURN_EXPR, and
     123                 :            :             RETURN_NULL_IF_FAIL*
     124                 :            :          for the common case where a NULL value is to be returned on
     125                 :            :          error, and
     126                 :            : 
     127                 :            :      (B) whether the error message is to be directly printed:
     128                 :            :            RETURN_*IF_FAIL
     129                 :            :          or is a format string with some number of arguments:
     130                 :            :            RETURN_*IF_FAIL_PRINTF*
     131                 :            : 
     132                 :            :    They all use JIT_BEGIN_STMT/JIT_END_STMT so they can be written with
     133                 :            :    trailing semicolons.
     134                 :            : */
     135                 :            : 
     136                 :            : #define RETURN_VAL_IF_FAIL(TEST_EXPR, RETURN_EXPR, CTXT, LOC, ERR_MSG)  \
     137                 :            :   JIT_BEGIN_STMT                                                        \
     138                 :            :     if (!(TEST_EXPR))                                                   \
     139                 :            :       {                                                         \
     140                 :            :         jit_error ((CTXT), (LOC), "%s: %s", __func__, (ERR_MSG));     \
     141                 :            :         return (RETURN_EXPR);                                           \
     142                 :            :       }                                                         \
     143                 :            :   JIT_END_STMT
     144                 :            : 
     145                 :            : #define RETURN_VAL_IF_FAIL_PRINTF1(TEST_EXPR, RETURN_EXPR, CTXT, LOC, ERR_FMT, A0) \
     146                 :            :   JIT_BEGIN_STMT                                                        \
     147                 :            :     if (!(TEST_EXPR))                                                   \
     148                 :            :       {                                                         \
     149                 :            :         jit_error ((CTXT), (LOC), "%s: " ERR_FMT,                     \
     150                 :            :                    __func__, (A0));                             \
     151                 :            :         return (RETURN_EXPR);                                           \
     152                 :            :       }                                                         \
     153                 :            :   JIT_END_STMT
     154                 :            : 
     155                 :            : #define RETURN_VAL_IF_FAIL_PRINTF2(TEST_EXPR, RETURN_EXPR, CTXT, LOC, ERR_FMT, A0, A1) \
     156                 :            :   JIT_BEGIN_STMT                                                        \
     157                 :            :     if (!(TEST_EXPR))                                                   \
     158                 :            :       {                                                         \
     159                 :            :         jit_error ((CTXT), (LOC), "%s: " ERR_FMT,                             \
     160                 :            :                    __func__, (A0), (A1));                               \
     161                 :            :         return (RETURN_EXPR);                                           \
     162                 :            :       }                                                         \
     163                 :            :   JIT_END_STMT
     164                 :            : 
     165                 :            : #define RETURN_VAL_IF_FAIL_PRINTF3(TEST_EXPR, RETURN_EXPR, CTXT, LOC, ERR_FMT, A0, A1, A2) \
     166                 :            :   JIT_BEGIN_STMT                                                        \
     167                 :            :     if (!(TEST_EXPR))                                                   \
     168                 :            :       {                                                         \
     169                 :            :         jit_error ((CTXT), (LOC), "%s: " ERR_FMT,                             \
     170                 :            :                    __func__, (A0), (A1), (A2));                 \
     171                 :            :         return (RETURN_EXPR);                                           \
     172                 :            :       }                                                         \
     173                 :            :   JIT_END_STMT
     174                 :            : 
     175                 :            : #define RETURN_VAL_IF_FAIL_PRINTF4(TEST_EXPR, RETURN_EXPR, CTXT, LOC, ERR_FMT, A0, A1, A2, A3) \
     176                 :            :   JIT_BEGIN_STMT                                                        \
     177                 :            :     if (!(TEST_EXPR))                                                   \
     178                 :            :       {                                                         \
     179                 :            :         jit_error ((CTXT), (LOC), "%s: " ERR_FMT,                             \
     180                 :            :                    __func__, (A0), (A1), (A2), (A3));                   \
     181                 :            :         return (RETURN_EXPR);                                           \
     182                 :            :       }                                                         \
     183                 :            :   JIT_END_STMT
     184                 :            : 
     185                 :            : #define RETURN_VAL_IF_FAIL_PRINTF5(TEST_EXPR, RETURN_EXPR, CTXT, LOC, ERR_FMT, A0, A1, A2, A3, A4) \
     186                 :            :   JIT_BEGIN_STMT                                                        \
     187                 :            :     if (!(TEST_EXPR))                                                   \
     188                 :            :       {                                                         \
     189                 :            :         jit_error ((CTXT), (LOC), "%s: " ERR_FMT,                             \
     190                 :            :                    __func__, (A0), (A1), (A2), (A3), (A4));     \
     191                 :            :         return (RETURN_EXPR);                                           \
     192                 :            :       }                                                         \
     193                 :            :   JIT_END_STMT
     194                 :            : 
     195                 :            : #define RETURN_VAL_IF_FAIL_PRINTF6(TEST_EXPR, RETURN_EXPR, CTXT, LOC, ERR_FMT, A0, A1, A2, A3, A4, A5) \
     196                 :            :   JIT_BEGIN_STMT                                                        \
     197                 :            :     if (!(TEST_EXPR))                                                   \
     198                 :            :       {                                                         \
     199                 :            :         jit_error ((CTXT), (LOC), "%s: " ERR_FMT,                             \
     200                 :            :                    __func__, (A0), (A1), (A2), (A3), (A4), (A5));       \
     201                 :            :         return (RETURN_EXPR);                                           \
     202                 :            :       }                                                         \
     203                 :            :   JIT_END_STMT
     204                 :            : 
     205                 :            : #define RETURN_NULL_IF_FAIL(TEST_EXPR, CTXT, LOC, ERR_MSG) \
     206                 :            :   RETURN_VAL_IF_FAIL ((TEST_EXPR), NULL, (CTXT), (LOC), (ERR_MSG))
     207                 :            : 
     208                 :            : #define RETURN_NULL_IF_FAIL_PRINTF1(TEST_EXPR, CTXT, LOC, ERR_FMT, A0) \
     209                 :            :   RETURN_VAL_IF_FAIL_PRINTF1 (TEST_EXPR, NULL, CTXT, LOC, ERR_FMT, A0)
     210                 :            : 
     211                 :            : #define RETURN_NULL_IF_FAIL_PRINTF2(TEST_EXPR, CTXT, LOC, ERR_FMT, A0, A1) \
     212                 :            :   RETURN_VAL_IF_FAIL_PRINTF2 (TEST_EXPR, NULL, CTXT, LOC, ERR_FMT, A0, A1)
     213                 :            : 
     214                 :            : #define RETURN_NULL_IF_FAIL_PRINTF3(TEST_EXPR, CTXT, LOC, ERR_FMT, A0, A1, A2) \
     215                 :            :   RETURN_VAL_IF_FAIL_PRINTF3 (TEST_EXPR, NULL, CTXT, LOC, ERR_FMT, A0, A1, A2)
     216                 :            : 
     217                 :            : #define RETURN_NULL_IF_FAIL_PRINTF4(TEST_EXPR, CTXT, LOC, ERR_FMT, A0, A1, A2, A3) \
     218                 :            :   RETURN_VAL_IF_FAIL_PRINTF4 (TEST_EXPR, NULL, CTXT, LOC, ERR_FMT, A0, A1, A2, A3)
     219                 :            : 
     220                 :            : #define RETURN_NULL_IF_FAIL_PRINTF5(TEST_EXPR, CTXT, LOC, ERR_FMT, A0, A1, A2, A3, A4) \
     221                 :            :   RETURN_VAL_IF_FAIL_PRINTF5 (TEST_EXPR, NULL, CTXT, LOC, ERR_FMT, A0, A1, A2, A3, A4)
     222                 :            : 
     223                 :            : #define RETURN_NULL_IF_FAIL_PRINTF6(TEST_EXPR, CTXT, LOC, ERR_FMT, A0, A1, A2, A3, A4, A5) \
     224                 :            :   RETURN_VAL_IF_FAIL_PRINTF6 (TEST_EXPR, NULL, CTXT, LOC, ERR_FMT, A0, A1, A2, A3, A4, A5)
     225                 :            : 
     226                 :            : #define RETURN_IF_FAIL(TEST_EXPR, CTXT, LOC, ERR_MSG)                   \
     227                 :            :   JIT_BEGIN_STMT                                                        \
     228                 :            :     if (!(TEST_EXPR))                                                   \
     229                 :            :       {                                                         \
     230                 :            :         jit_error ((CTXT), (LOC), "%s: %s", __func__, (ERR_MSG));             \
     231                 :            :         return;                                                 \
     232                 :            :       }                                                         \
     233                 :            :   JIT_END_STMT
     234                 :            : 
     235                 :            : #define RETURN_IF_FAIL_PRINTF1(TEST_EXPR, CTXT, LOC, ERR_FMT, A0) \
     236                 :            :   JIT_BEGIN_STMT                                                        \
     237                 :            :     if (!(TEST_EXPR))                                                   \
     238                 :            :       {                                                         \
     239                 :            :         jit_error ((CTXT), (LOC), "%s: " ERR_FMT,                             \
     240                 :            :                    __func__, (A0));                                     \
     241                 :            :         return;                                                 \
     242                 :            :       }                                                         \
     243                 :            :   JIT_END_STMT
     244                 :            : 
     245                 :            : #define RETURN_IF_FAIL_PRINTF2(TEST_EXPR, CTXT, LOC, ERR_FMT, A0, A1) \
     246                 :            :   JIT_BEGIN_STMT                                                        \
     247                 :            :     if (!(TEST_EXPR))                                                   \
     248                 :            :       {                                                         \
     249                 :            :         jit_error ((CTXT), (LOC), "%s: " ERR_FMT,                             \
     250                 :            :                    __func__, (A0), (A1));                               \
     251                 :            :         return;                                                 \
     252                 :            :       }                                                         \
     253                 :            :   JIT_END_STMT
     254                 :            : 
     255                 :            : #define RETURN_IF_FAIL_PRINTF4(TEST_EXPR, CTXT, LOC, ERR_FMT, A0, A1, A2, A3) \
     256                 :            :   JIT_BEGIN_STMT                                                        \
     257                 :            :     if (!(TEST_EXPR))                                                   \
     258                 :            :       {                                                         \
     259                 :            :         jit_error ((CTXT), (LOC), "%s: " ERR_FMT,                             \
     260                 :            :                    __func__, (A0), (A1), (A2), (A3));                   \
     261                 :            :         return;                                                 \
     262                 :            :       }                                                         \
     263                 :            :   JIT_END_STMT
     264                 :            : 
     265                 :            : /* Check that BLOCK is non-NULL, and that it's OK to add statements to
     266                 :            :    it.  This will fail if BLOCK has already been terminated by some
     267                 :            :    kind of jump or a return.  */
     268                 :            : #define RETURN_IF_NOT_VALID_BLOCK(BLOCK, LOC)                           \
     269                 :            :   JIT_BEGIN_STMT                                                        \
     270                 :            :     RETURN_IF_FAIL ((BLOCK), NULL, (LOC), "NULL block");              \
     271                 :            :     RETURN_IF_FAIL_PRINTF2 (                                            \
     272                 :            :       !(BLOCK)->has_been_terminated (),                              \
     273                 :            :       (BLOCK)->get_context (),                                               \
     274                 :            :       (LOC),                                                            \
     275                 :            :       "adding to terminated block: %s (already terminated by: %s)",   \
     276                 :            :       (BLOCK)->get_debug_string (),                                  \
     277                 :            :       (BLOCK)->get_last_statement ()->get_debug_string ());               \
     278                 :            :   JIT_END_STMT
     279                 :            : 
     280                 :            : /* As RETURN_IF_NOT_VALID_BLOCK, but injecting a "return NULL;" if it
     281                 :            :    fails.  */
     282                 :            : #define RETURN_NULL_IF_NOT_VALID_BLOCK(BLOCK, LOC)                      \
     283                 :            :   JIT_BEGIN_STMT                                                        \
     284                 :            :     RETURN_NULL_IF_FAIL ((BLOCK), NULL, (LOC), "NULL block");         \
     285                 :            :     RETURN_NULL_IF_FAIL_PRINTF2 (                                       \
     286                 :            :       !(BLOCK)->has_been_terminated (),                              \
     287                 :            :       (BLOCK)->get_context (),                                               \
     288                 :            :       (LOC),                                                            \
     289                 :            :       "adding to terminated block: %s (already terminated by: %s)",   \
     290                 :            :       (BLOCK)->get_debug_string (),                                  \
     291                 :            :       (BLOCK)->get_last_statement ()->get_debug_string ());               \
     292                 :            :   JIT_END_STMT
     293                 :            : 
     294                 :            : /* Format the given string, and report it as an error, either on CTXT
     295                 :            :    if non-NULL, or by printing to stderr if we have a NULL context.
     296                 :            :    LOC gives the source location where the error occcurred, and can be
     297                 :            :    NULL.  */
     298                 :            : 
     299                 :            : static void
     300                 :            : jit_error (gcc::jit::recording::context *ctxt,
     301                 :            :            gcc_jit_location *loc,
     302                 :            :            const char *fmt, ...)
     303                 :            :   GNU_PRINTF(3, 4);
     304                 :            : 
     305                 :            : static void
     306                 :       5686 : jit_error (gcc::jit::recording::context *ctxt,
     307                 :            :            gcc_jit_location *loc,
     308                 :            :            const char *fmt, ...)
     309                 :            : {
     310                 :       5686 :   va_list ap;
     311                 :       5686 :   va_start (ap, fmt);
     312                 :            : 
     313                 :       5686 :   if (ctxt)
     314                 :       4877 :     ctxt->add_error_va (loc, fmt, ap);
     315                 :            :   else
     316                 :            :     {
     317                 :            :       /* No context?  Send to stderr.  */
     318                 :        809 :       vfprintf (stderr, fmt, ap);
     319                 :        809 :       fprintf (stderr, "\n");
     320                 :            :     }
     321                 :            : 
     322                 :       5686 :   va_end (ap);
     323                 :       5686 : }
     324                 :            : 
     325                 :            : /* Determine whether or not we can write to lvalues of type LTYPE from
     326                 :            :    rvalues of type RTYPE, detecting type errors such as attempting to
     327                 :            :    write to an int with a string literal (without an explicit cast).
     328                 :            : 
     329                 :            :    This is implemented by calling the
     330                 :            :    gcc::jit::recording::type::accepts_writes_from virtual function on
     331                 :            :    LTYPE.  */
     332                 :            : 
     333                 :            : static bool
     334                 :      10868 : compatible_types (gcc::jit::recording::type *ltype,
     335                 :            :                   gcc::jit::recording::type *rtype)
     336                 :            : {
     337                 :      10868 :   return ltype->accepts_writes_from (rtype);
     338                 :            : }
     339                 :            : 
     340                 :            : /* Public entrypoint for acquiring a gcc_jit_context.
     341                 :            :    Note that this creates a new top-level context; contrast with
     342                 :            :    gcc_jit_context_new_child_context below.
     343                 :            : 
     344                 :            :    The real work is done in the constructor for
     345                 :            :    gcc::jit::recording::context in jit-recording.c. */
     346                 :            : 
     347                 :            : gcc_jit_context *
     348                 :       1348 : gcc_jit_context_acquire (void)
     349                 :            : {
     350                 :       1348 :   gcc_jit_context *ctxt = new gcc_jit_context (NULL);
     351                 :       1348 :   ctxt->log ("new top-level ctxt: %p", (void *)ctxt);
     352                 :       1348 :   return ctxt;
     353                 :            : }
     354                 :            : 
     355                 :            : /* Public entrypoint for releasing a gcc_jit_context.
     356                 :            :    The real work is done in the destructor for
     357                 :            :    gcc::jit::recording::context in jit-recording.c.  */
     358                 :            : 
     359                 :            : void
     360                 :       1358 : gcc_jit_context_release (gcc_jit_context *ctxt)
     361                 :            : {
     362                 :       1358 :   RETURN_IF_FAIL (ctxt, NULL, NULL, "NULL ctxt");
     363                 :       2716 :   JIT_LOG_FUNC (ctxt->get_logger ());
     364                 :       1358 :   ctxt->log ("deleting ctxt: %p", (void *)ctxt);
     365                 :       1358 :   delete ctxt;
     366                 :            : }
     367                 :            : 
     368                 :            : /* Public entrypoint for creating a child context within
     369                 :            :    PARENT_CTXT.  See description in libgccjit.h.
     370                 :            : 
     371                 :            :    The real work is done in the constructor for
     372                 :            :    gcc::jit::recording::context in jit-recording.c. */
     373                 :            : 
     374                 :            : gcc_jit_context *
     375                 :         12 : gcc_jit_context_new_child_context (gcc_jit_context *parent_ctxt)
     376                 :            : {
     377                 :         12 :   RETURN_NULL_IF_FAIL (parent_ctxt, NULL, NULL, "NULL parent ctxt");
     378                 :         12 :   JIT_LOG_FUNC (parent_ctxt->get_logger ());
     379                 :         12 :   parent_ctxt->log ("parent_ctxt: %p", (void *)parent_ctxt);
     380                 :         12 :   gcc_jit_context *child_ctxt = new gcc_jit_context (parent_ctxt);
     381                 :         12 :   child_ctxt->log ("new child_ctxt: %p", (void *)child_ctxt);
     382                 :         12 :   return child_ctxt;
     383                 :            : }
     384                 :            : 
     385                 :            : /* Public entrypoint.  See description in libgccjit.h.
     386                 :            : 
     387                 :            :    After error-checking, the real work is done by the
     388                 :            :      gcc::jit::recording::context::new_location
     389                 :            :    method in jit-recording.c.  */
     390                 :            : 
     391                 :            : gcc_jit_location *
     392                 :      11307 : gcc_jit_context_new_location (gcc_jit_context *ctxt,
     393                 :            :                               const char *filename,
     394                 :            :                               int line,
     395                 :            :                               int column)
     396                 :            : {
     397                 :      11307 :   RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context");
     398                 :      22614 :   JIT_LOG_FUNC (ctxt->get_logger ());
     399                 :      11307 :   return (gcc_jit_location *)ctxt->new_location (filename, line, column, true);
     400                 :            : }
     401                 :            : 
     402                 :            : /* Public entrypoint.  See description in libgccjit.h.
     403                 :            : 
     404                 :            :    After error-checking, this calls the trivial
     405                 :            :    gcc::jit::recording::memento::as_object method (a location is a
     406                 :            :    memento), in jit-recording.h.  */
     407                 :            : 
     408                 :            : gcc_jit_object *
     409                 :         24 : gcc_jit_location_as_object (gcc_jit_location *loc)
     410                 :            : {
     411                 :         24 :   RETURN_NULL_IF_FAIL (loc, NULL, NULL, "NULL location");
     412                 :            : 
     413                 :         24 :   return static_cast <gcc_jit_object *> (loc->as_object ());
     414                 :            : }
     415                 :            : 
     416                 :            : /* Public entrypoint.  See description in libgccjit.h.
     417                 :            : 
     418                 :            :    After error-checking, this calls the trivial
     419                 :            :    gcc::jit::recording::memento::as_object method (a type is a
     420                 :            :    memento), in jit-recording.h.  */
     421                 :            : 
     422                 :            : gcc_jit_object *
     423                 :        392 : gcc_jit_type_as_object (gcc_jit_type *type)
     424                 :            : {
     425                 :        392 :   RETURN_NULL_IF_FAIL (type, NULL, NULL, "NULL type");
     426                 :            : 
     427                 :        392 :   return static_cast <gcc_jit_object *> (type->as_object ());
     428                 :            : }
     429                 :            : 
     430                 :            : /* Public entrypoint for getting a specific type from a context.
     431                 :            : 
     432                 :            :    After error-checking, the real work is done by the
     433                 :            :    gcc::jit::recording::context::get_type method, in
     434                 :            :    jit-recording.c  */
     435                 :            : 
     436                 :            : gcc_jit_type *
     437                 :      16388 : gcc_jit_context_get_type (gcc_jit_context *ctxt,
     438                 :            :                           enum gcc_jit_types type)
     439                 :            : {
     440                 :      16388 :   RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context");
     441                 :      32776 :   JIT_LOG_FUNC (ctxt->get_logger ());
     442                 :      16388 :   RETURN_NULL_IF_FAIL_PRINTF1 (
     443                 :            :     (type >= GCC_JIT_TYPE_VOID
     444                 :            :      && type <= GCC_JIT_TYPE_FILE_PTR),
     445                 :            :     ctxt, NULL,
     446                 :            :     "unrecognized value for enum gcc_jit_types: %i", type);
     447                 :            : 
     448                 :      16383 :   return (gcc_jit_type *)ctxt->get_type (type);
     449                 :            : }
     450                 :            : 
     451                 :            : /* Public entrypoint for getting the integer type of the given size and
     452                 :            :    signedness.
     453                 :            : 
     454                 :            :    After error-checking, the real work is done by the
     455                 :            :    gcc::jit::recording::context::get_int_type method,
     456                 :            :    in jit-recording.c.  */
     457                 :            : 
     458                 :            : gcc_jit_type *
     459                 :         26 : gcc_jit_context_get_int_type (gcc_jit_context *ctxt,
     460                 :            :                               int num_bytes, int is_signed)
     461                 :            : {
     462                 :         26 :   RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context");
     463                 :         52 :   JIT_LOG_FUNC (ctxt->get_logger ());
     464                 :         26 :   RETURN_NULL_IF_FAIL (num_bytes >= 0, ctxt, NULL, "negative size");
     465                 :            : 
     466                 :         26 :   return (gcc_jit_type *)ctxt->get_int_type (num_bytes, is_signed);
     467                 :            : }
     468                 :            : 
     469                 :            : /* Public entrypoint.  See description in libgccjit.h.
     470                 :            : 
     471                 :            :    After error-checking, the real work is done by the
     472                 :            :    gcc::jit::recording::type::get_pointer method, in
     473                 :            :    jit-recording.c  */
     474                 :            : 
     475                 :            : gcc_jit_type *
     476                 :       1261 : gcc_jit_type_get_pointer (gcc_jit_type *type)
     477                 :            : {
     478                 :       1261 :   RETURN_NULL_IF_FAIL (type, NULL, NULL, "NULL type");
     479                 :            : 
     480                 :       1261 :   return (gcc_jit_type *)type->get_pointer ();
     481                 :            : }
     482                 :            : 
     483                 :            : /* Public entrypoint.  See description in libgccjit.h.
     484                 :            : 
     485                 :            :    After error-checking, the real work is done by the
     486                 :            :    gcc::jit::recording::type::get_const method, in
     487                 :            :    jit-recording.c.  */
     488                 :            : 
     489                 :            : gcc_jit_type *
     490                 :        527 : gcc_jit_type_get_const (gcc_jit_type *type)
     491                 :            : {
     492                 :        527 :   RETURN_NULL_IF_FAIL (type, NULL, NULL, "NULL type");
     493                 :            : 
     494                 :        527 :   return (gcc_jit_type *)type->get_const ();
     495                 :            : }
     496                 :            : 
     497                 :            : /* Public entrypoint.  See description in libgccjit.h.
     498                 :            : 
     499                 :            :    After error-checking, the real work is done by the
     500                 :            :    gcc::jit::recording::type::get_volatile method, in
     501                 :            :    jit-recording.c.  */
     502                 :            : 
     503                 :            : gcc_jit_type *
     504                 :         15 : gcc_jit_type_get_volatile (gcc_jit_type *type)
     505                 :            : {
     506                 :         15 :   RETURN_NULL_IF_FAIL (type, NULL, NULL, "NULL type");
     507                 :            : 
     508                 :         15 :   return (gcc_jit_type *)type->get_volatile ();
     509                 :            : }
     510                 :            : 
     511                 :            : /* Public entrypoint.  See description in libgccjit.h.
     512                 :            : 
     513                 :            :    After error-checking, the real work is done by the
     514                 :            :    gcc::jit::recording::context::new_array_type method, in
     515                 :            :    jit-recording.c.  */
     516                 :            : 
     517                 :            : gcc_jit_type *
     518                 :         65 : gcc_jit_context_new_array_type (gcc_jit_context *ctxt,
     519                 :            :                                 gcc_jit_location *loc,
     520                 :            :                                 gcc_jit_type *element_type,
     521                 :            :                                 int num_elements)
     522                 :            : {
     523                 :         65 :   RETURN_NULL_IF_FAIL (ctxt, NULL, loc, "NULL context");
     524                 :        130 :   JIT_LOG_FUNC (ctxt->get_logger ());
     525                 :            :   /* LOC can be NULL.  */
     526                 :         65 :   RETURN_NULL_IF_FAIL (element_type, ctxt, loc, "NULL type");
     527                 :         65 :   RETURN_NULL_IF_FAIL (num_elements >= 0, ctxt, NULL, "negative size");
     528                 :            : 
     529                 :         65 :   return (gcc_jit_type *)ctxt->new_array_type (loc,
     530                 :            :                                                element_type,
     531                 :         65 :                                                num_elements);
     532                 :            : }
     533                 :            : 
     534                 :            : /* Public entrypoint.  See description in libgccjit.h.
     535                 :            : 
     536                 :            :    After error-checking, the real work is done by the
     537                 :            :    gcc::jit::recording::context::new_field method, in
     538                 :            :    jit-recording.c.  */
     539                 :            : 
     540                 :            : gcc_jit_field *
     541                 :       5794 : gcc_jit_context_new_field (gcc_jit_context *ctxt,
     542                 :            :                            gcc_jit_location *loc,
     543                 :            :                            gcc_jit_type *type,
     544                 :            :                            const char *name)
     545                 :            : {
     546                 :       5794 :   RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context");
     547                 :      11588 :   JIT_LOG_FUNC (ctxt->get_logger ());
     548                 :            :   /* LOC can be NULL.  */
     549                 :       5794 :   RETURN_NULL_IF_FAIL (type, ctxt, loc, "NULL type");
     550                 :       5794 :   RETURN_NULL_IF_FAIL (name, ctxt, loc, "NULL name");
     551                 :       5794 :   RETURN_NULL_IF_FAIL_PRINTF2 (
     552                 :            :     type->has_known_size (),
     553                 :            :     ctxt, loc,
     554                 :            :     "unknown size for field \"%s\" (type: %s)",
     555                 :            :     name,
     556                 :            :     type->get_debug_string ());
     557                 :            : 
     558                 :       5789 :   return (gcc_jit_field *)ctxt->new_field (loc, type, name);
     559                 :            : }
     560                 :            : 
     561                 :            : /* Public entrypoint.  See description in libgccjit.h.
     562                 :            : 
     563                 :            :    After error-checking, the real work is done by the
     564                 :            :    gcc::jit::recording::context::new_bitfield method, in
     565                 :            :    jit-recording.c.  */
     566                 :            : 
     567                 :            : gcc_jit_field *
     568                 :        115 : gcc_jit_context_new_bitfield (gcc_jit_context *ctxt,
     569                 :            :                               gcc_jit_location *loc,
     570                 :            :                               gcc_jit_type *type,
     571                 :            :                               int width,
     572                 :            :                               const char *name)
     573                 :            : {
     574                 :        115 :   RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context");
     575                 :        230 :   JIT_LOG_FUNC (ctxt->get_logger ());
     576                 :            :   /* LOC can be NULL.  */
     577                 :        115 :   RETURN_NULL_IF_FAIL (name, ctxt, loc, "NULL name");
     578                 :        115 :   RETURN_NULL_IF_FAIL (type, ctxt, loc, "NULL type");
     579                 :        115 :   RETURN_NULL_IF_FAIL_PRINTF2 (type->is_int () || type->is_bool (),
     580                 :            :                                ctxt, loc,
     581                 :            :                                "bit-field %s has non integral type %s",
     582                 :            :                                name, type->get_debug_string ());
     583                 :        110 :   RETURN_NULL_IF_FAIL_PRINTF2 (
     584                 :            :     width > 0, ctxt, loc,
     585                 :            :     "invalid width %d for bitfield \"%s\" (must be > 0)",
     586                 :            :     width, name);
     587                 :        110 :   RETURN_NULL_IF_FAIL_PRINTF2 (
     588                 :            :     type->has_known_size (),
     589                 :            :     ctxt, loc,
     590                 :            :     "unknown size for field \"%s\" (type: %s)",
     591                 :            :     name,
     592                 :            :     type->get_debug_string ());
     593                 :            : 
     594                 :        110 :   return (gcc_jit_field *)ctxt->new_bitfield (loc, type, width, name);
     595                 :            : }
     596                 :            : 
     597                 :            : /* Public entrypoint.  See description in libgccjit.h.
     598                 :            : 
     599                 :            :    After error-checking, this calls the trivial
     600                 :            :    gcc::jit::recording::memento::as_object method (a field is a
     601                 :            :    memento), in jit-recording.h.  */
     602                 :            : 
     603                 :            : gcc_jit_object *
     604                 :        110 : gcc_jit_field_as_object (gcc_jit_field *field)
     605                 :            : {
     606                 :        110 :   RETURN_NULL_IF_FAIL (field, NULL, NULL, "NULL field");
     607                 :            : 
     608                 :        110 :   return static_cast <gcc_jit_object *> (field->as_object ());
     609                 :            : }
     610                 :            : 
     611                 :            : /* Public entrypoint.  See description in libgccjit.h.
     612                 :            : 
     613                 :            :    After error-checking, the real work is done by the
     614                 :            :    gcc::jit::recording::context::new_struct_type method,
     615                 :            :    immediately followed by a "set_fields" call on the resulting
     616                 :            :    gcc::jit::recording::compound_type *, both in jit-recording.c  */
     617                 :            : 
     618                 :            : gcc_jit_struct *
     619                 :       1305 : gcc_jit_context_new_struct_type (gcc_jit_context *ctxt,
     620                 :            :                                  gcc_jit_location *loc,
     621                 :            :                                  const char *name,
     622                 :            :                                  int num_fields,
     623                 :            :                                  gcc_jit_field **fields)
     624                 :            : {
     625                 :       1305 :   RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context");
     626                 :       2610 :   JIT_LOG_FUNC (ctxt->get_logger ());
     627                 :            :   /* LOC can be NULL.  */
     628                 :       1305 :   RETURN_NULL_IF_FAIL (name, ctxt, loc, "NULL name");
     629                 :       1305 :   if (num_fields)
     630                 :       1185 :     RETURN_NULL_IF_FAIL (fields, ctxt, loc, "NULL fields ptr");
     631                 :       6969 :   for (int i = 0; i < num_fields; i++)
     632                 :            :     {
     633                 :       5664 :       RETURN_NULL_IF_FAIL (fields[i], ctxt, loc, "NULL field ptr");
     634                 :       5664 :       RETURN_NULL_IF_FAIL_PRINTF2 (
     635                 :            :         fields[i]->get_container () == NULL,
     636                 :            :         ctxt, loc,
     637                 :            :         "%s is already a field of %s",
     638                 :            :         fields[i]->get_debug_string (),
     639                 :            :         fields[i]->get_container ()->get_debug_string ());
     640                 :            :     }
     641                 :            : 
     642                 :       1305 :   gcc::jit::recording::struct_ *result =
     643                 :       1305 :     ctxt->new_struct_type (loc, name);
     644                 :       1305 :   result->set_fields (loc,
     645                 :            :                       num_fields,
     646                 :            :                       (gcc::jit::recording::field **)fields);
     647                 :       1305 :   return static_cast<gcc_jit_struct *> (result);
     648                 :            : }
     649                 :            : 
     650                 :            : /* Public entrypoint.  See description in libgccjit.h.
     651                 :            : 
     652                 :            :    After error-checking, the real work is done by the
     653                 :            :    gcc::jit::recording::context::new_struct_type method in
     654                 :            :    jit-recording.c.  */
     655                 :            : 
     656                 :            : gcc_jit_struct *
     657                 :         90 : gcc_jit_context_new_opaque_struct (gcc_jit_context *ctxt,
     658                 :            :                                    gcc_jit_location *loc,
     659                 :            :                                    const char *name)
     660                 :            : {
     661                 :         90 :   RETURN_NULL_IF_FAIL (ctxt, NULL, loc, "NULL context");
     662                 :        180 :   JIT_LOG_FUNC (ctxt->get_logger ());
     663                 :            :   /* LOC can be NULL.  */
     664                 :         90 :   RETURN_NULL_IF_FAIL (name, ctxt, loc, "NULL name");
     665                 :            : 
     666                 :         90 :   return (gcc_jit_struct *)ctxt->new_struct_type (loc, name);
     667                 :            : }
     668                 :            : 
     669                 :            : /* Public entrypoint.  See description in libgccjit.h.
     670                 :            : 
     671                 :            :    After error-checking, this calls the trivial
     672                 :            :    gcc::jit::recording::struct_::as_object method in
     673                 :            :    jit-recording.h.  */
     674                 :            : 
     675                 :            : gcc_jit_type *
     676                 :       1365 : gcc_jit_struct_as_type (gcc_jit_struct *struct_type)
     677                 :            : {
     678                 :       1365 :   RETURN_NULL_IF_FAIL (struct_type, NULL, NULL, "NULL struct_type");
     679                 :            : 
     680                 :       1365 :   return static_cast <gcc_jit_type *> (struct_type->as_type ());
     681                 :            : }
     682                 :            : 
     683                 :            : /* Public entrypoint.  See description in libgccjit.h.
     684                 :            : 
     685                 :            :    After error-checking, the real work is done by the
     686                 :            :    gcc::jit::recording::compound_type::set_fields method in
     687                 :            :    jit-recording.c.  */
     688                 :            : 
     689                 :            : void
     690                 :         60 : gcc_jit_struct_set_fields (gcc_jit_struct *struct_type,
     691                 :            :                            gcc_jit_location *loc,
     692                 :            :                            int num_fields,
     693                 :            :                            gcc_jit_field **fields)
     694                 :            : {
     695                 :         60 :   RETURN_IF_FAIL (struct_type, NULL, loc, "NULL struct_type");
     696                 :         60 :   gcc::jit::recording::context *ctxt = struct_type->m_ctxt;
     697                 :        120 :   JIT_LOG_FUNC (ctxt->get_logger ());
     698                 :            :   /* LOC can be NULL.  */
     699                 :         60 :   RETURN_IF_FAIL_PRINTF1 (
     700                 :            :     struct_type->get_fields () == NULL, ctxt, loc,
     701                 :            :     "%s already has had fields set",
     702                 :            :     struct_type->get_debug_string ());
     703                 :         60 :   if (num_fields)
     704                 :         60 :     RETURN_IF_FAIL (fields, ctxt, loc, "NULL fields ptr");
     705                 :        195 :   for (int i = 0; i < num_fields; i++)
     706                 :            :     {
     707                 :        135 :       RETURN_IF_FAIL_PRINTF2 (
     708                 :            :         fields[i],
     709                 :            :         ctxt, loc,
     710                 :            :         "%s: NULL field ptr at index %i",
     711                 :            :         struct_type->get_debug_string (),
     712                 :            :         i);
     713                 :        135 :       RETURN_IF_FAIL_PRINTF2 (
     714                 :            :         fields[i]->get_container () == NULL,
     715                 :            :         ctxt, loc,
     716                 :            :         "%s is already a field of %s",
     717                 :            :         fields[i]->get_debug_string (),
     718                 :            :         fields[i]->get_container ()->get_debug_string ());
     719                 :            :     }
     720                 :            : 
     721                 :         60 :   struct_type->set_fields (loc, num_fields,
     722                 :            :                            (gcc::jit::recording::field **)fields);
     723                 :            : }
     724                 :            : 
     725                 :            : /* Public entrypoint.  See description in libgccjit.h.
     726                 :            : 
     727                 :            :    After error-checking, the real work is done by the
     728                 :            :    gcc::jit::recording::context::new_union_type method,
     729                 :            :    immediately followed by a "set_fields" call on the resulting
     730                 :            :    gcc::jit::recording::compound_type *, both in jit-recording.c  */
     731                 :            : 
     732                 :            : gcc_jit_type *
     733                 :         35 : gcc_jit_context_new_union_type (gcc_jit_context *ctxt,
     734                 :            :                                 gcc_jit_location *loc,
     735                 :            :                                 const char *name,
     736                 :            :                                 int num_fields,
     737                 :            :                                 gcc_jit_field **fields)
     738                 :            : {
     739                 :         35 :   RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context");
     740                 :         70 :   JIT_LOG_FUNC (ctxt->get_logger ());
     741                 :            :   /* LOC can be NULL.  */
     742                 :         35 :   RETURN_NULL_IF_FAIL (name, ctxt, loc, "NULL name");
     743                 :         35 :   if (num_fields)
     744                 :         35 :     RETURN_NULL_IF_FAIL (fields, ctxt, loc, "NULL fields ptr");
     745                 :        120 :   for (int i = 0; i < num_fields; i++)
     746                 :            :     {
     747                 :         85 :       RETURN_NULL_IF_FAIL (fields[i], ctxt, loc, "NULL field ptr");
     748                 :         85 :       RETURN_NULL_IF_FAIL_PRINTF2 (
     749                 :            :         fields[i]->get_container () == NULL,
     750                 :            :         ctxt, loc,
     751                 :            :         "%s is already a field of %s",
     752                 :            :         fields[i]->get_debug_string (),
     753                 :            :         fields[i]->get_container ()->get_debug_string ());
     754                 :            :     }
     755                 :            : 
     756                 :         35 :   gcc::jit::recording::union_ *result =
     757                 :         35 :     ctxt->new_union_type (loc, name);
     758                 :         35 :   result->set_fields (loc,
     759                 :            :                       num_fields,
     760                 :            :                       (gcc::jit::recording::field **)fields);
     761                 :         35 :   return (gcc_jit_type *) (result);
     762                 :            : }
     763                 :            : 
     764                 :            : /* Public entrypoint.  See description in libgccjit.h.
     765                 :            : 
     766                 :            :    After error-checking, the real work is done by the
     767                 :            :    gcc::jit::recording::context::new_function_ptr_type method,
     768                 :            :    in jit-recording.c  */
     769                 :            : 
     770                 :            : gcc_jit_type *
     771                 :         55 : gcc_jit_context_new_function_ptr_type (gcc_jit_context *ctxt,
     772                 :            :                                        gcc_jit_location *loc,
     773                 :            :                                        gcc_jit_type *return_type,
     774                 :            :                                        int num_params,
     775                 :            :                                        gcc_jit_type **param_types,
     776                 :            :                                        int is_variadic)
     777                 :            : {
     778                 :         55 :   RETURN_NULL_IF_FAIL (ctxt, NULL, loc, "NULL context");
     779                 :        110 :   JIT_LOG_FUNC (ctxt->get_logger ());
     780                 :            :   /* LOC can be NULL.  */
     781                 :         55 :   RETURN_NULL_IF_FAIL (return_type, ctxt, loc, "NULL return_type");
     782                 :         55 :   RETURN_NULL_IF_FAIL (
     783                 :            :     (num_params == 0) || param_types,
     784                 :            :     ctxt, loc,
     785                 :            :     "NULL param_types creating function pointer type");
     786                 :        155 :   for (int i = 0; i < num_params; i++)
     787                 :        100 :     RETURN_NULL_IF_FAIL_PRINTF1 (
     788                 :            :       param_types[i],
     789                 :            :       ctxt, loc,
     790                 :            :       "NULL parameter type %i creating function pointer type", i);
     791                 :            : 
     792                 :         55 :   return (gcc_jit_type*)
     793                 :         55 :     ctxt->new_function_ptr_type (loc, return_type,
     794                 :            :                                  num_params,
     795                 :            :                                  (gcc::jit::recording::type **)param_types,
     796                 :         55 :                                  is_variadic);
     797                 :            : }
     798                 :            : 
     799                 :            : /* Constructing functions.  */
     800                 :            : 
     801                 :            : /* Public entrypoint.  See description in libgccjit.h.
     802                 :            : 
     803                 :            :    After error-checking, the real work is done by the
     804                 :            :    gcc::jit::recording::context::new_param method, in jit-recording.c  */
     805                 :            : 
     806                 :            : gcc_jit_param *
     807                 :       8581 : gcc_jit_context_new_param (gcc_jit_context *ctxt,
     808                 :            :                            gcc_jit_location *loc,
     809                 :            :                            gcc_jit_type *type,
     810                 :            :                            const char *name)
     811                 :            : {
     812                 :       8581 :   RETURN_NULL_IF_FAIL (ctxt, NULL, loc, "NULL context");
     813                 :      17162 :   JIT_LOG_FUNC (ctxt->get_logger ());
     814                 :            :   /* LOC can be NULL.  */
     815                 :       8581 :   RETURN_NULL_IF_FAIL (type, ctxt, loc, "NULL type");
     816                 :       8581 :   RETURN_NULL_IF_FAIL (name, ctxt, loc, "NULL name");
     817                 :            : 
     818                 :       8581 :   return (gcc_jit_param *)ctxt->new_param (loc, type, name);
     819                 :            : }
     820                 :            : 
     821                 :            : /* Public entrypoint.  See description in libgccjit.h.
     822                 :            : 
     823                 :            :    After error-checking, this calls the trivial
     824                 :            :    gcc::jit::recording::memento::as_object method (a param is a memento),
     825                 :            :    in jit-recording.h.  */
     826                 :            : 
     827                 :            : gcc_jit_object *
     828                 :          0 : gcc_jit_param_as_object (gcc_jit_param *param)
     829                 :            : {
     830                 :          0 :   RETURN_NULL_IF_FAIL (param, NULL, NULL, "NULL param");
     831                 :            : 
     832                 :          0 :   return static_cast <gcc_jit_object *> (param->as_object ());
     833                 :            : }
     834                 :            : 
     835                 :            : /* Public entrypoint.  See description in libgccjit.h.
     836                 :            : 
     837                 :            :    After error-checking, this calls the trivial
     838                 :            :    gcc::jit::recording::param::as_lvalue method in jit-recording.h.  */
     839                 :            : 
     840                 :            : gcc_jit_lvalue *
     841                 :       2051 : gcc_jit_param_as_lvalue (gcc_jit_param *param)
     842                 :            : {
     843                 :       2051 :   RETURN_NULL_IF_FAIL (param, NULL, NULL, "NULL param");
     844                 :            : 
     845                 :       2051 :   return (gcc_jit_lvalue *)param->as_lvalue ();
     846                 :            : }
     847                 :            : 
     848                 :            : /* Public entrypoint.  See description in libgccjit.h.
     849                 :            : 
     850                 :            :    After error-checking, this calls the trivial
     851                 :            :    gcc::jit::recording::lvalue::as_rvalue method (a param is an rvalue),
     852                 :            :    in jit-recording.h.  */
     853                 :            : 
     854                 :            : gcc_jit_rvalue *
     855                 :       4666 : gcc_jit_param_as_rvalue (gcc_jit_param *param)
     856                 :            : {
     857                 :       4666 :   RETURN_NULL_IF_FAIL (param, NULL, NULL, "NULL param");
     858                 :            : 
     859                 :       4666 :   return (gcc_jit_rvalue *)param->as_rvalue ();
     860                 :            : }
     861                 :            : 
     862                 :            : /* Public entrypoint.  See description in libgccjit.h.
     863                 :            : 
     864                 :            :    After error-checking, the real work is done by the
     865                 :            :    gcc::jit::recording::context::new_function method, in
     866                 :            :    jit-recording.c.  */
     867                 :            : 
     868                 :            : gcc_jit_function *
     869                 :       3695 : gcc_jit_context_new_function (gcc_jit_context *ctxt,
     870                 :            :                               gcc_jit_location *loc,
     871                 :            :                               enum gcc_jit_function_kind kind,
     872                 :            :                               gcc_jit_type *return_type,
     873                 :            :                               const char *name,
     874                 :            :                               int num_params,
     875                 :            :                               gcc_jit_param **params,
     876                 :            :                               int is_variadic)
     877                 :            : {
     878                 :       3695 :   RETURN_NULL_IF_FAIL (ctxt, NULL, loc, "NULL context");
     879                 :       7390 :   JIT_LOG_FUNC (ctxt->get_logger ());
     880                 :            :   /* LOC can be NULL.  */
     881                 :       3695 :   RETURN_NULL_IF_FAIL_PRINTF1 (
     882                 :            :     ((kind >= GCC_JIT_FUNCTION_EXPORTED)
     883                 :            :      && (kind <= GCC_JIT_FUNCTION_ALWAYS_INLINE)),
     884                 :            :     ctxt, loc,
     885                 :            :     "unrecognized value for enum gcc_jit_function_kind: %i",
     886                 :            :     kind);
     887                 :       3690 :   RETURN_NULL_IF_FAIL (return_type, ctxt, loc, "NULL return_type");
     888                 :       3685 :   RETURN_NULL_IF_FAIL (name, ctxt, loc, "NULL name");
     889                 :            :   /* The assembler can only handle certain names, so for now, enforce
     890                 :            :      C's rules for identiers upon the name, using ISALPHA and ISALNUM
     891                 :            :      from safe-ctype.h to ignore the current locale.
     892                 :            :      Eventually we'll need some way to interact with e.g. C++ name
     893                 :            :      mangling.  */
     894                 :       3685 :   {
     895                 :            :     /* Leading char: */
     896                 :       3685 :     char ch = *name;
     897                 :       3685 :     RETURN_NULL_IF_FAIL_PRINTF2 (
     898                 :            :         ISALPHA (ch) || ch == '_',
     899                 :            :         ctxt, loc,
     900                 :            :         "name \"%s\" contains invalid character: '%c'",
     901                 :            :         name, ch);
     902                 :            :     /* Subsequent chars: */
     903                 :    1051240 :     for (const char *ptr = name + 1; (ch = *ptr); ptr++)
     904                 :            :       {
     905                 :    1047550 :         RETURN_NULL_IF_FAIL_PRINTF2 (
     906                 :            :           ISALNUM (ch) || ch == '_',
     907                 :            :           ctxt, loc,
     908                 :            :           "name \"%s\" contains invalid character: '%c'",
     909                 :            :           name, ch);
     910                 :            :       }
     911                 :            :   }
     912                 :       3685 :   RETURN_NULL_IF_FAIL_PRINTF1 (
     913                 :            :     (num_params == 0) || params,
     914                 :            :     ctxt, loc,
     915                 :            :     "NULL params creating function %s", name);
     916                 :      12266 :   for (int i = 0; i < num_params; i++)
     917                 :            :     {
     918                 :       8586 :       RETURN_NULL_IF_FAIL_PRINTF2 (
     919                 :            :         params[i],
     920                 :            :         ctxt, loc,
     921                 :            :         "NULL parameter %i creating function %s", i, name);
     922                 :       8586 :       RETURN_NULL_IF_FAIL_PRINTF5 (
     923                 :            :         params[i]->get_scope () == NULL,
     924                 :            :         ctxt, loc,
     925                 :            :         "parameter %i \"%s\""
     926                 :            :         " (type: %s)"
     927                 :            :         " for function %s"
     928                 :            :         " was already used for function %s",
     929                 :            :         i, params[i]->get_debug_string (),
     930                 :            :         params[i]->get_type ()->get_debug_string (),
     931                 :            :         name,
     932                 :            :         params[i]->get_scope ()->get_debug_string ());
     933                 :            :     }
     934                 :            : 
     935                 :       3680 :   return (gcc_jit_function*)
     936                 :       3680 :     ctxt->new_function (loc, kind, return_type, name,
     937                 :            :                         num_params,
     938                 :            :                         (gcc::jit::recording::param **)params,
     939                 :            :                         is_variadic,
     940                 :       3680 :                         BUILT_IN_NONE);
     941                 :            : }
     942                 :            : 
     943                 :            : /* Public entrypoint.  See description in libgccjit.h.
     944                 :            : 
     945                 :            :    After error-checking, the real work is done by the
     946                 :            :    gcc::jit::recording::context::get_builtin_function method, in
     947                 :            :    jit-recording.c.  */
     948                 :            : 
     949                 :            : gcc_jit_function *
     950                 :        140 : gcc_jit_context_get_builtin_function (gcc_jit_context *ctxt,
     951                 :            :                                       const char *name)
     952                 :            : {
     953                 :        140 :   RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context");
     954                 :        280 :   JIT_LOG_FUNC (ctxt->get_logger ());
     955                 :        140 :   RETURN_NULL_IF_FAIL (name, ctxt, NULL, "NULL name");
     956                 :            : 
     957                 :        140 :   return static_cast <gcc_jit_function *> (ctxt->get_builtin_function (name));
     958                 :            : }
     959                 :            : 
     960                 :            : /* Public entrypoint.  See description in libgccjit.h.
     961                 :            : 
     962                 :            :    After error-checking, this calls the trivial
     963                 :            :    gcc::jit::recording::memento::as_object method (a function is a
     964                 :            :    memento), in jit-recording.h.  */
     965                 :            : 
     966                 :            : gcc_jit_object *
     967                 :        126 : gcc_jit_function_as_object (gcc_jit_function *func)
     968                 :            : {
     969                 :        126 :   RETURN_NULL_IF_FAIL (func, NULL, NULL, "NULL function");
     970                 :            : 
     971                 :        126 :   return static_cast <gcc_jit_object *> (func->as_object ());
     972                 :            : }
     973                 :            : 
     974                 :            : /* Public entrypoint.  See description in libgccjit.h.
     975                 :            : 
     976                 :            :    After error-checking, the real work is done by the
     977                 :            :    gcc::jit::recording::function::get_param method, in
     978                 :            :    jit-recording.h.  */
     979                 :            : 
     980                 :            : gcc_jit_param *
     981                 :          0 : gcc_jit_function_get_param (gcc_jit_function *func, int index)
     982                 :            : {
     983                 :          0 :   RETURN_NULL_IF_FAIL (func, NULL, NULL, "NULL function");
     984                 :          0 :   gcc::jit::recording::context *ctxt = func->m_ctxt;
     985                 :          0 :   JIT_LOG_FUNC (ctxt->get_logger ());
     986                 :          0 :   RETURN_NULL_IF_FAIL (index >= 0, ctxt, NULL, "negative index");
     987                 :          0 :   int num_params = func->get_params ().length ();
     988                 :          0 :   RETURN_NULL_IF_FAIL_PRINTF3 (index < num_params,
     989                 :            :                                ctxt, NULL,
     990                 :            :                                "index of %d is too large (%s has %d params)",
     991                 :            :                                index,
     992                 :            :                                func->get_debug_string (),
     993                 :            :                                num_params);
     994                 :            : 
     995                 :          0 :   return static_cast <gcc_jit_param *> (func->get_param (index));
     996                 :            : }
     997                 :            : 
     998                 :            : /* Public entrypoint.  See description in libgccjit.h.
     999                 :            : 
    1000                 :            :    After error-checking, the real work is done by the
    1001                 :            :    gcc::jit::recording::function::dump_to_dot method, in
    1002                 :            :    jit-recording.c.  */
    1003                 :            : 
    1004                 :            : void
    1005                 :          0 : gcc_jit_function_dump_to_dot (gcc_jit_function *func,
    1006                 :            :                               const char *path)
    1007                 :            : {
    1008                 :          0 :   RETURN_IF_FAIL (func, NULL, NULL, "NULL function");
    1009                 :          0 :   gcc::jit::recording::context *ctxt = func->m_ctxt;
    1010                 :          0 :   JIT_LOG_FUNC (ctxt->get_logger ());
    1011                 :          0 :   RETURN_IF_FAIL (path, ctxt, NULL, "NULL path");
    1012                 :            : 
    1013                 :          0 :   func->dump_to_dot (path);
    1014                 :            : }
    1015                 :            : 
    1016                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1017                 :            : 
    1018                 :            :    After error-checking, the real work is done by the
    1019                 :            :    gcc::jit::recording::function::new_block method, in
    1020                 :            :    jit-recording.c.  */
    1021                 :            : 
    1022                 :            : gcc_jit_block*
    1023                 :       5846 : gcc_jit_function_new_block (gcc_jit_function *func,
    1024                 :            :                             const char *name)
    1025                 :            : {
    1026                 :       5846 :   RETURN_NULL_IF_FAIL (func, NULL, NULL, "NULL function");
    1027                 :      11692 :   JIT_LOG_FUNC (func->get_context ()->get_logger ());
    1028                 :       5846 :   RETURN_NULL_IF_FAIL (func->get_kind () != GCC_JIT_FUNCTION_IMPORTED,
    1029                 :            :                        func->get_context (), NULL,
    1030                 :            :                        "cannot add block to an imported function");
    1031                 :            :   /* name can be NULL.  */
    1032                 :            : 
    1033                 :       5562 :   return (gcc_jit_block *)func->new_block (name);
    1034                 :            : }
    1035                 :            : 
    1036                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1037                 :            : 
    1038                 :            :    After error-checking, this calls the trivial
    1039                 :            :    gcc::jit::recording::memento::as_object method (a block is a
    1040                 :            :    memento), in jit-recording.h.  */
    1041                 :            : 
    1042                 :            : gcc_jit_object *
    1043                 :        192 : gcc_jit_block_as_object (gcc_jit_block *block)
    1044                 :            : {
    1045                 :        192 :   RETURN_NULL_IF_FAIL (block, NULL, NULL, "NULL block");
    1046                 :            : 
    1047                 :        192 :   return static_cast <gcc_jit_object *> (block->as_object ());
    1048                 :            : }
    1049                 :            : 
    1050                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1051                 :            : 
    1052                 :            :    After error-checking, the real work is done by the
    1053                 :            :    gcc::jit::recording::block::get_function method, in
    1054                 :            :    jit-recording.h.  */
    1055                 :            : 
    1056                 :            : gcc_jit_function *
    1057                 :          0 : gcc_jit_block_get_function (gcc_jit_block *block)
    1058                 :            : {
    1059                 :          0 :   RETURN_NULL_IF_FAIL (block, NULL, NULL, "NULL block");
    1060                 :            : 
    1061                 :          0 :   return static_cast <gcc_jit_function *> (block->get_function ());
    1062                 :            : }
    1063                 :            : 
    1064                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1065                 :            : 
    1066                 :            :    After error-checking, the real work is done by the
    1067                 :            :    gcc::jit::recording::context::new_global method, in
    1068                 :            :    jit-recording.c.  */
    1069                 :            : 
    1070                 :            : gcc_jit_lvalue *
    1071                 :       1590 : gcc_jit_context_new_global (gcc_jit_context *ctxt,
    1072                 :            :                             gcc_jit_location *loc,
    1073                 :            :                             enum gcc_jit_global_kind kind,
    1074                 :            :                             gcc_jit_type *type,
    1075                 :            :                             const char *name)
    1076                 :            : {
    1077                 :       1590 :   RETURN_NULL_IF_FAIL (ctxt, NULL, loc, "NULL context");
    1078                 :       3180 :   JIT_LOG_FUNC (ctxt->get_logger ());
    1079                 :            :   /* LOC can be NULL.  */
    1080                 :       1590 :   RETURN_NULL_IF_FAIL_PRINTF1 (
    1081                 :            :     ((kind >= GCC_JIT_GLOBAL_EXPORTED)
    1082                 :            :      && (kind <= GCC_JIT_GLOBAL_IMPORTED)),
    1083                 :            :     ctxt, loc,
    1084                 :            :     "unrecognized value for enum gcc_jit_global_kind: %i",
    1085                 :            :     kind);
    1086                 :       1590 :   RETURN_NULL_IF_FAIL (type, ctxt, loc, "NULL type");
    1087                 :       1590 :   RETURN_NULL_IF_FAIL (name, ctxt, loc, "NULL name");
    1088                 :       1590 :   RETURN_NULL_IF_FAIL_PRINTF2 (
    1089                 :            :     type->has_known_size (),
    1090                 :            :     ctxt, loc,
    1091                 :            :     "unknown size for global \"%s\" (type: %s)",
    1092                 :            :     name,
    1093                 :            :     type->get_debug_string ());
    1094                 :            : 
    1095                 :       1585 :   return (gcc_jit_lvalue *)ctxt->new_global (loc, kind, type, name);
    1096                 :            : }
    1097                 :            : 
    1098                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1099                 :            : 
    1100                 :            :    After error-checking, this calls the trivial
    1101                 :            :    gcc::jit::recording::memento::as_object method (an lvalue is a
    1102                 :            :    memento), in jit-recording.h.  */
    1103                 :            : 
    1104                 :            : gcc_jit_object *
    1105                 :         30 : gcc_jit_lvalue_as_object (gcc_jit_lvalue *lvalue)
    1106                 :            : {
    1107                 :         30 :   RETURN_NULL_IF_FAIL (lvalue, NULL, NULL, "NULL lvalue");
    1108                 :            : 
    1109                 :         30 :   return static_cast <gcc_jit_object *> (lvalue->as_object ());
    1110                 :            : }
    1111                 :            : 
    1112                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1113                 :            : 
    1114                 :            :    After error-checking, this calls the trivial
    1115                 :            :    gcc::jit::recording::lvalue::as_rvalue method in jit-recording.h.  */
    1116                 :            : 
    1117                 :            : gcc_jit_rvalue *
    1118                 :       8985 : gcc_jit_lvalue_as_rvalue (gcc_jit_lvalue *lvalue)
    1119                 :            : {
    1120                 :       8985 :   RETURN_NULL_IF_FAIL (lvalue, NULL, NULL, "NULL lvalue");
    1121                 :            : 
    1122                 :       8970 :   return (gcc_jit_rvalue *)lvalue->as_rvalue ();
    1123                 :            : }
    1124                 :            : 
    1125                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1126                 :            : 
    1127                 :            :    After error-checking, this calls the trivial
    1128                 :            :    gcc::jit::recording::memento::as_object method (an rvalue is a
    1129                 :            :    memento), in jit-recording.h.  */
    1130                 :            : 
    1131                 :            : gcc_jit_object *
    1132                 :       1786 : gcc_jit_rvalue_as_object (gcc_jit_rvalue *rvalue)
    1133                 :            : {
    1134                 :       1786 :   RETURN_NULL_IF_FAIL (rvalue, NULL, NULL, "NULL rvalue");
    1135                 :            : 
    1136                 :       1786 :   return static_cast <gcc_jit_object *> (rvalue->as_object ());
    1137                 :            : }
    1138                 :            : 
    1139                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1140                 :            : 
    1141                 :            :    After error-checking, the real work is done by the
    1142                 :            :    gcc::jit::recording::rvalue::get_type method, in
    1143                 :            :    jit-recording.h.  */
    1144                 :            : 
    1145                 :            : gcc_jit_type *
    1146                 :         91 : gcc_jit_rvalue_get_type (gcc_jit_rvalue *rvalue)
    1147                 :            : {
    1148                 :         91 :   RETURN_NULL_IF_FAIL (rvalue, NULL, NULL, "NULL rvalue");
    1149                 :            : 
    1150                 :         91 :   return static_cast <gcc_jit_type *> (rvalue->get_type ());
    1151                 :            : }
    1152                 :            : 
    1153                 :            : /* Verify that NUMERIC_TYPE is non-NULL, and that it is a "numeric"
    1154                 :            :    type i.e. it satisfies gcc::jit::type::is_numeric (), such as the
    1155                 :            :    result of gcc_jit_context_get_type (GCC_JIT_TYPE_INT).  */
    1156                 :            : 
    1157                 :            : #define RETURN_NULL_IF_FAIL_NONNULL_NUMERIC_TYPE(CTXT, NUMERIC_TYPE) \
    1158                 :            :   JIT_BEGIN_STMT                                                     \
    1159                 :            :   RETURN_NULL_IF_FAIL (NUMERIC_TYPE, CTXT, NULL, "NULL type"); \
    1160                 :            :   RETURN_NULL_IF_FAIL_PRINTF1 (                                \
    1161                 :            :     NUMERIC_TYPE->is_numeric (), ctxt, NULL,                   \
    1162                 :            :     "not a numeric type: %s",                                  \
    1163                 :            :     NUMERIC_TYPE->get_debug_string ()); \
    1164                 :            :   JIT_END_STMT
    1165                 :            : 
    1166                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1167                 :            : 
    1168                 :            :    After error-checking, the real work is done by the
    1169                 :            :    gcc::jit::recording::context::new_rvalue_from_int method in
    1170                 :            :    jit-recording.c.  */
    1171                 :            : 
    1172                 :            : gcc_jit_rvalue *
    1173                 :       5646 : gcc_jit_context_new_rvalue_from_int (gcc_jit_context *ctxt,
    1174                 :            :                                      gcc_jit_type *numeric_type,
    1175                 :            :                                      int value)
    1176                 :            : {
    1177                 :       5646 :   RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context");
    1178                 :      11292 :   JIT_LOG_FUNC (ctxt->get_logger ());
    1179                 :       5646 :   RETURN_NULL_IF_FAIL_NONNULL_NUMERIC_TYPE (ctxt, numeric_type);
    1180                 :            : 
    1181                 :       4956 :   return ((gcc_jit_rvalue *)ctxt
    1182                 :       4956 :           ->new_rvalue_from_const <int> (numeric_type, value));
    1183                 :            : }
    1184                 :            : 
    1185                 :            : /* FIXME. */
    1186                 :            : 
    1187                 :            : gcc_jit_rvalue *
    1188                 :         50 : gcc_jit_context_new_rvalue_from_long (gcc_jit_context *ctxt,
    1189                 :            :                                       gcc_jit_type *numeric_type,
    1190                 :            :                                       long value)
    1191                 :            : {
    1192                 :         50 :   RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context");
    1193                 :        100 :   JIT_LOG_FUNC (ctxt->get_logger ());
    1194                 :         50 :   RETURN_NULL_IF_FAIL_NONNULL_NUMERIC_TYPE (ctxt, numeric_type);
    1195                 :            : 
    1196                 :         50 :   return ((gcc_jit_rvalue *)ctxt
    1197                 :         50 :           ->new_rvalue_from_const <long> (numeric_type, value));
    1198                 :            : }
    1199                 :            : 
    1200                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1201                 :            : 
    1202                 :            :    This is essentially equivalent to:
    1203                 :            :       gcc_jit_context_new_rvalue_from_int (ctxt, numeric_type, 0);
    1204                 :            :    albeit with slightly different error messages if an error occurs.  */
    1205                 :            : 
    1206                 :            : gcc_jit_rvalue *
    1207                 :        360 : gcc_jit_context_zero (gcc_jit_context *ctxt,
    1208                 :            :                       gcc_jit_type *numeric_type)
    1209                 :            : {
    1210                 :        360 :   RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context");
    1211                 :        720 :   JIT_LOG_FUNC (ctxt->get_logger ());
    1212                 :        360 :   RETURN_NULL_IF_FAIL_NONNULL_NUMERIC_TYPE (ctxt, numeric_type);
    1213                 :            : 
    1214                 :        360 :   return gcc_jit_context_new_rvalue_from_int (ctxt, numeric_type, 0);
    1215                 :            : }
    1216                 :            : 
    1217                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1218                 :            : 
    1219                 :            :    This is essentially equivalent to:
    1220                 :            :       gcc_jit_context_new_rvalue_from_int (ctxt, numeric_type, 1);
    1221                 :            :    albeit with slightly different error messages if an error occurs.  */
    1222                 :            : 
    1223                 :            : gcc_jit_rvalue *
    1224                 :        161 : gcc_jit_context_one (gcc_jit_context *ctxt,
    1225                 :            :                      gcc_jit_type *numeric_type)
    1226                 :            : {
    1227                 :        161 :   RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context");
    1228                 :        322 :   JIT_LOG_FUNC (ctxt->get_logger ());
    1229                 :        161 :   RETURN_NULL_IF_FAIL_NONNULL_NUMERIC_TYPE (ctxt, numeric_type);
    1230                 :            : 
    1231                 :        161 :   return gcc_jit_context_new_rvalue_from_int (ctxt, numeric_type, 1);
    1232                 :            : }
    1233                 :            : 
    1234                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1235                 :            : 
    1236                 :            :    After error-checking, the real work is done by the
    1237                 :            :    gcc::jit::recording::context::new_rvalue_from_double method in
    1238                 :            :    jit-recording.c.  */
    1239                 :            : 
    1240                 :            : gcc_jit_rvalue *
    1241                 :        110 : gcc_jit_context_new_rvalue_from_double (gcc_jit_context *ctxt,
    1242                 :            :                                         gcc_jit_type *numeric_type,
    1243                 :            :                                         double value)
    1244                 :            : {
    1245                 :        110 :   RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context");
    1246                 :        220 :   JIT_LOG_FUNC (ctxt->get_logger ());
    1247                 :        110 :   RETURN_NULL_IF_FAIL_NONNULL_NUMERIC_TYPE (ctxt, numeric_type);
    1248                 :            : 
    1249                 :        105 :   return ((gcc_jit_rvalue *)ctxt
    1250                 :        105 :           ->new_rvalue_from_const <double> (numeric_type, value));
    1251                 :            : }
    1252                 :            : 
    1253                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1254                 :            : 
    1255                 :            :    After error-checking, the real work is done by the
    1256                 :            :    gcc::jit::recording::context::new_rvalue_from_ptr method in
    1257                 :            :    jit-recording.c.  */
    1258                 :            : 
    1259                 :            : gcc_jit_rvalue *
    1260                 :        110 : gcc_jit_context_new_rvalue_from_ptr (gcc_jit_context *ctxt,
    1261                 :            :                                      gcc_jit_type *pointer_type,
    1262                 :            :                                      void *value)
    1263                 :            : {
    1264                 :        110 :   RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context");
    1265                 :        220 :   JIT_LOG_FUNC (ctxt->get_logger ());
    1266                 :        110 :   RETURN_NULL_IF_FAIL (pointer_type, ctxt, NULL, "NULL type");
    1267                 :        110 :   RETURN_NULL_IF_FAIL_PRINTF1 (
    1268                 :            :     pointer_type->is_pointer (),
    1269                 :            :     ctxt, NULL,
    1270                 :            :     "not a pointer type (type: %s)",
    1271                 :            :     pointer_type->get_debug_string ());
    1272                 :            : 
    1273                 :        110 :   return ((gcc_jit_rvalue *)ctxt
    1274                 :        110 :           ->new_rvalue_from_const <void *> (pointer_type, value));
    1275                 :            : }
    1276                 :            : 
    1277                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1278                 :            : 
    1279                 :            :    This is essentially equivalent to:
    1280                 :            :       gcc_jit_context_new_rvalue_from_ptr (ctxt, pointer_type, NULL);
    1281                 :            :    albeit with slightly different error messages if an error occurs.  */
    1282                 :            : 
    1283                 :            : gcc_jit_rvalue *
    1284                 :         20 : gcc_jit_context_null (gcc_jit_context *ctxt,
    1285                 :            :                       gcc_jit_type *pointer_type)
    1286                 :            : {
    1287                 :         20 :   RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context");
    1288                 :         40 :   JIT_LOG_FUNC (ctxt->get_logger ());
    1289                 :         20 :   RETURN_NULL_IF_FAIL (pointer_type, ctxt, NULL, "NULL type");
    1290                 :         20 :   RETURN_NULL_IF_FAIL_PRINTF1 (
    1291                 :            :     pointer_type->is_pointer (),
    1292                 :            :     ctxt, NULL,
    1293                 :            :     "not a pointer type (type: %s)",
    1294                 :            :     pointer_type->get_debug_string ());
    1295                 :            : 
    1296                 :         20 :   return gcc_jit_context_new_rvalue_from_ptr (ctxt, pointer_type, NULL);
    1297                 :            : }
    1298                 :            : 
    1299                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1300                 :            : 
    1301                 :            :    After error-checking, the real work is done by the
    1302                 :            :    gcc::jit::recording::context::new_string_literal method in
    1303                 :            :    jit-recording.c.  */
    1304                 :            : 
    1305                 :            : gcc_jit_rvalue *
    1306                 :       1783 : gcc_jit_context_new_string_literal (gcc_jit_context *ctxt,
    1307                 :            :                                     const char *value)
    1308                 :            : {
    1309                 :       1783 :   RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context");
    1310                 :       3566 :   JIT_LOG_FUNC (ctxt->get_logger ());
    1311                 :       1783 :   RETURN_NULL_IF_FAIL (value, ctxt, NULL, "NULL value");
    1312                 :            : 
    1313                 :       1783 :   return (gcc_jit_rvalue *)ctxt->new_string_literal (value);
    1314                 :            : }
    1315                 :            : 
    1316                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1317                 :            : 
    1318                 :            :    After error-checking, the real work is done by the
    1319                 :            :    gcc::jit::recording::context::new_unary_op method in
    1320                 :            :    jit-recording.c.  */
    1321                 :            : 
    1322                 :            : gcc_jit_rvalue *
    1323                 :        103 : gcc_jit_context_new_unary_op (gcc_jit_context *ctxt,
    1324                 :            :                               gcc_jit_location *loc,
    1325                 :            :                               enum gcc_jit_unary_op op,
    1326                 :            :                               gcc_jit_type *result_type,
    1327                 :            :                               gcc_jit_rvalue *rvalue)
    1328                 :            : {
    1329                 :        103 :   RETURN_NULL_IF_FAIL (ctxt, NULL, loc, "NULL context");
    1330                 :        206 :   JIT_LOG_FUNC (ctxt->get_logger ());
    1331                 :            :   /* LOC can be NULL.  */
    1332                 :        103 :   RETURN_NULL_IF_FAIL_PRINTF1 (
    1333                 :            :     (op >= GCC_JIT_UNARY_OP_MINUS
    1334                 :            :      && op <= GCC_JIT_UNARY_OP_ABS),
    1335                 :            :     ctxt, loc,
    1336                 :            :     "unrecognized value for enum gcc_jit_unary_op: %i",
    1337                 :            :     op);
    1338                 :         98 :   RETURN_NULL_IF_FAIL (result_type, ctxt, loc, "NULL result_type");
    1339                 :         98 :   RETURN_NULL_IF_FAIL_PRINTF3 (
    1340                 :            :     result_type->is_numeric (), ctxt, loc,
    1341                 :            :     "gcc_jit_unary_op %s with operand %s "
    1342                 :            :     "has non-numeric result_type: %s",
    1343                 :            :     gcc::jit::unary_op_reproducer_strings[op],
    1344                 :            :     rvalue->get_debug_string (),
    1345                 :            :     result_type->get_debug_string ());
    1346                 :         93 :   RETURN_NULL_IF_FAIL (rvalue, ctxt, loc, "NULL rvalue");
    1347                 :            : 
    1348                 :         93 :   return (gcc_jit_rvalue *)ctxt->new_unary_op (loc, op, result_type, rvalue);
    1349                 :            : }
    1350                 :            : 
    1351                 :            : /* Determine if OP is a valid value for enum gcc_jit_binary_op.
    1352                 :            :    For use by both gcc_jit_context_new_binary_op and
    1353                 :            :    gcc_jit_block_add_assignment_op.  */
    1354                 :            : 
    1355                 :            : static bool
    1356                 :       3442 : valid_binary_op_p (enum gcc_jit_binary_op op)
    1357                 :            : {
    1358                 :       3442 :   return (op >= GCC_JIT_BINARY_OP_PLUS
    1359                 :          0 :           && op <= GCC_JIT_BINARY_OP_RSHIFT);
    1360                 :            : }
    1361                 :            : 
    1362                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1363                 :            : 
    1364                 :            :    After error-checking, the real work is done by the
    1365                 :            :    gcc::jit::recording::context::new_binary_op method in
    1366                 :            :    jit-recording.c.  */
    1367                 :            : 
    1368                 :            : gcc_jit_rvalue *
    1369                 :       3068 : gcc_jit_context_new_binary_op (gcc_jit_context *ctxt,
    1370                 :            :                                gcc_jit_location *loc,
    1371                 :            :                                enum gcc_jit_binary_op op,
    1372                 :            :                                gcc_jit_type *result_type,
    1373                 :            :                                gcc_jit_rvalue *a, gcc_jit_rvalue *b)
    1374                 :            : {
    1375                 :       3068 :   RETURN_NULL_IF_FAIL (ctxt, NULL, loc, "NULL context");
    1376                 :       6136 :   JIT_LOG_FUNC (ctxt->get_logger ());
    1377                 :            :   /* LOC can be NULL.  */
    1378                 :       3068 :   RETURN_NULL_IF_FAIL_PRINTF1 (
    1379                 :            :     valid_binary_op_p (op),
    1380                 :            :     ctxt, loc,
    1381                 :            :     "unrecognized value for enum gcc_jit_binary_op: %i",
    1382                 :            :     op);
    1383                 :       3063 :   RETURN_NULL_IF_FAIL (result_type, ctxt, loc, "NULL result_type");
    1384                 :       3063 :   RETURN_NULL_IF_FAIL (a, ctxt, loc, "NULL a");
    1385                 :       3063 :   RETURN_NULL_IF_FAIL (b, ctxt, loc, "NULL b");
    1386                 :       3063 :   RETURN_NULL_IF_FAIL_PRINTF4 (
    1387                 :            :     a->get_type ()->unqualified () == b->get_type ()->unqualified (),
    1388                 :            :     ctxt, loc,
    1389                 :            :     "mismatching types for binary op:"
    1390                 :            :     " a: %s (type: %s) b: %s (type: %s)",
    1391                 :            :     a->get_debug_string (),
    1392                 :            :     a->get_type ()->get_debug_string (),
    1393                 :            :     b->get_debug_string (),
    1394                 :            :     b->get_type ()->get_debug_string ());
    1395                 :       3063 :   RETURN_NULL_IF_FAIL_PRINTF4 (
    1396                 :            :     result_type->is_numeric (), ctxt, loc,
    1397                 :            :     "gcc_jit_binary_op %s with operands a: %s b: %s "
    1398                 :            :     "has non-numeric result_type: %s",
    1399                 :            :     gcc::jit::binary_op_reproducer_strings[op],
    1400                 :            :     a->get_debug_string (), b->get_debug_string (),
    1401                 :            :     result_type->get_debug_string ());
    1402                 :            : 
    1403                 :       3058 :   return (gcc_jit_rvalue *)ctxt->new_binary_op (loc, op, result_type, a, b);
    1404                 :            : }
    1405                 :            : 
    1406                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1407                 :            : 
    1408                 :            :    After error-checking, the real work is done by the
    1409                 :            :    gcc::jit::recording::context::new_comparison method in
    1410                 :            :    jit-recording.c.  */
    1411                 :            : 
    1412                 :            : gcc_jit_rvalue *
    1413                 :       1244 : gcc_jit_context_new_comparison (gcc_jit_context *ctxt,
    1414                 :            :                                 gcc_jit_location *loc,
    1415                 :            :                                 enum gcc_jit_comparison op,
    1416                 :            :                                 gcc_jit_rvalue *a, gcc_jit_rvalue *b)
    1417                 :            : {
    1418                 :       1244 :   RETURN_NULL_IF_FAIL (ctxt, NULL, loc, "NULL context");
    1419                 :       2488 :   JIT_LOG_FUNC (ctxt->get_logger ());
    1420                 :            :   /* LOC can be NULL.  */
    1421                 :       1244 :   RETURN_NULL_IF_FAIL_PRINTF1 (
    1422                 :            :     (op >= GCC_JIT_COMPARISON_EQ
    1423                 :            :      && op <= GCC_JIT_COMPARISON_GE),
    1424                 :            :     ctxt, loc,
    1425                 :            :     "unrecognized value for enum gcc_jit_comparison: %i",
    1426                 :            :     op);
    1427                 :       1244 :   RETURN_NULL_IF_FAIL (a, ctxt, loc, "NULL a");
    1428                 :       1244 :   RETURN_NULL_IF_FAIL (b, ctxt, loc, "NULL b");
    1429                 :       1244 :   RETURN_NULL_IF_FAIL_PRINTF4 (
    1430                 :            :     a->get_type ()->unqualified () == b->get_type ()->unqualified (),
    1431                 :            :     ctxt, loc,
    1432                 :            :     "mismatching types for comparison:"
    1433                 :            :     " a: %s (type: %s) b: %s (type: %s)",
    1434                 :            :     a->get_debug_string (),
    1435                 :            :     a->get_type ()->get_debug_string (),
    1436                 :            :     b->get_debug_string (),
    1437                 :            :     b->get_type ()->get_debug_string ());
    1438                 :            : 
    1439                 :       1244 :   return (gcc_jit_rvalue *)ctxt->new_comparison (loc, op, a, b);
    1440                 :            : }
    1441                 :            : 
    1442                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1443                 :            : 
    1444                 :            :    After error-checking, the real work is done by the
    1445                 :            :    gcc::jit::recording::context::new_call method in
    1446                 :            :    jit-recording.c.  */
    1447                 :            : 
    1448                 :            : gcc_jit_rvalue *
    1449                 :        615 : gcc_jit_context_new_call (gcc_jit_context *ctxt,
    1450                 :            :                           gcc_jit_location *loc,
    1451                 :            :                           gcc_jit_function *func,
    1452                 :            :                           int numargs , gcc_jit_rvalue **args)
    1453                 :            : {
    1454                 :        615 :   RETURN_NULL_IF_FAIL (ctxt, NULL, loc, "NULL context");
    1455                 :       1230 :   JIT_LOG_FUNC (ctxt->get_logger ());
    1456                 :            :   /* LOC can be NULL.  */
    1457                 :        615 :   RETURN_NULL_IF_FAIL (func, ctxt, loc, "NULL function");
    1458                 :        615 :   if (numargs)
    1459                 :        605 :     RETURN_NULL_IF_FAIL (args, ctxt, loc, "NULL args");
    1460                 :            : 
    1461                 :        615 :   int min_num_params = func->get_params ().length ();
    1462                 :        615 :   bool is_variadic = func->is_variadic ();
    1463                 :            : 
    1464                 :        615 :   RETURN_NULL_IF_FAIL_PRINTF3 (
    1465                 :            :     numargs >= min_num_params,
    1466                 :            :     ctxt, loc,
    1467                 :            :     "not enough arguments to function \"%s\""
    1468                 :            :     " (got %i args, expected %i)",
    1469                 :            :     func->get_name ()->c_str (),
    1470                 :            :     numargs, min_num_params);
    1471                 :            : 
    1472                 :        610 :   RETURN_NULL_IF_FAIL_PRINTF3 (
    1473                 :            :     (numargs == min_num_params || is_variadic),
    1474                 :            :     ctxt, loc,
    1475                 :            :     "too many arguments to function \"%s\""
    1476                 :            :     " (got %i args, expected %i)",
    1477                 :            :     func->get_name ()->c_str (),
    1478                 :            :     numargs, min_num_params);
    1479                 :            : 
    1480                 :       1235 :   for (int i = 0; i < min_num_params; i++)
    1481                 :            :     {
    1482                 :        645 :       gcc::jit::recording::param *param = func->get_param (i);
    1483                 :        645 :       gcc_jit_rvalue *arg = args[i];
    1484                 :            : 
    1485                 :        645 :       RETURN_NULL_IF_FAIL_PRINTF4 (
    1486                 :            :         arg,
    1487                 :            :         ctxt, loc,
    1488                 :            :         "NULL argument %i to function \"%s\":"
    1489                 :            :         " param %s (type: %s)",
    1490                 :            :         i + 1,
    1491                 :            :         func->get_name ()->c_str (),
    1492                 :            :         param->get_debug_string (),
    1493                 :            :         param->get_type ()->get_debug_string ());
    1494                 :            : 
    1495                 :        640 :       RETURN_NULL_IF_FAIL_PRINTF6 (
    1496                 :            :         compatible_types (param->get_type (),
    1497                 :            :                           arg->get_type ()),
    1498                 :            :         ctxt, loc,
    1499                 :            :         "mismatching types for argument %d of function \"%s\":"
    1500                 :            :         " assignment to param %s (type: %s) from %s (type: %s)",
    1501                 :            :         i + 1,
    1502                 :            :         func->get_name ()->c_str (),
    1503                 :            :         param->get_debug_string (),
    1504                 :            :         param->get_type ()->get_debug_string (),
    1505                 :            :         arg->get_debug_string (),
    1506                 :            :         arg->get_type ()->get_debug_string ());
    1507                 :            :     }
    1508                 :            : 
    1509                 :        590 :   return (gcc_jit_rvalue *)ctxt->new_call (loc,
    1510                 :            :                                            func,
    1511                 :            :                                            numargs,
    1512                 :        590 :                                            (gcc::jit::recording::rvalue **)args);
    1513                 :            : }
    1514                 :            : 
    1515                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1516                 :            : 
    1517                 :            :    After error-checking, the real work is done by the
    1518                 :            :    gcc::jit::recording::context::new_call_through_ptr method in
    1519                 :            :    jit-recording.c.  */
    1520                 :            : 
    1521                 :            : gcc_jit_rvalue *
    1522                 :         40 : gcc_jit_context_new_call_through_ptr (gcc_jit_context *ctxt,
    1523                 :            :                                       gcc_jit_location *loc,
    1524                 :            :                                       gcc_jit_rvalue *fn_ptr,
    1525                 :            :                                       int numargs, gcc_jit_rvalue **args)
    1526                 :            : {
    1527                 :         40 :   RETURN_NULL_IF_FAIL (ctxt, NULL, loc, "NULL context");
    1528                 :         80 :   JIT_LOG_FUNC (ctxt->get_logger ());
    1529                 :            :   /* LOC can be NULL.  */
    1530                 :         40 :   RETURN_NULL_IF_FAIL (fn_ptr, ctxt, loc, "NULL fn_ptr");
    1531                 :         40 :   if (numargs)
    1532                 :         35 :     RETURN_NULL_IF_FAIL (args, ctxt, loc, "NULL args");
    1533                 :            : 
    1534                 :         40 :   gcc::jit::recording::type *ptr_type = fn_ptr->get_type ()->dereference ();
    1535                 :         40 :   RETURN_NULL_IF_FAIL_PRINTF2 (
    1536                 :            :     ptr_type, ctxt, loc,
    1537                 :            :     "fn_ptr is not a ptr: %s"
    1538                 :            :     " type: %s",
    1539                 :            :     fn_ptr->get_debug_string (),
    1540                 :            :     fn_ptr->get_type ()->get_debug_string ());
    1541                 :            : 
    1542                 :         35 :   gcc::jit::recording::function_type *fn_type =
    1543                 :         35 :     ptr_type->dyn_cast_function_type();
    1544                 :         35 :   RETURN_NULL_IF_FAIL_PRINTF2 (
    1545                 :            :     fn_type, ctxt, loc,
    1546                 :            :     "fn_ptr is not a function ptr: %s"
    1547                 :            :     " type: %s",
    1548                 :            :     fn_ptr->get_debug_string (),
    1549                 :            :     fn_ptr->get_type ()->get_debug_string ());
    1550                 :            : 
    1551                 :         30 :   int min_num_params = fn_type->get_param_types ().length ();
    1552                 :         30 :   bool is_variadic = fn_type->is_variadic ();
    1553                 :            : 
    1554                 :         30 :   RETURN_NULL_IF_FAIL_PRINTF3 (
    1555                 :            :     numargs >= min_num_params,
    1556                 :            :     ctxt, loc,
    1557                 :            :     "not enough arguments to fn_ptr: %s"
    1558                 :            :     " (got %i args, expected %i)",
    1559                 :            :     fn_ptr->get_debug_string (),
    1560                 :            :     numargs, min_num_params);
    1561                 :            : 
    1562                 :         25 :   RETURN_NULL_IF_FAIL_PRINTF3 (
    1563                 :            :     (numargs == min_num_params || is_variadic),
    1564                 :            :     ctxt, loc,
    1565                 :            :     "too many arguments to fn_ptr: %s"
    1566                 :            :     " (got %i args, expected %i)",
    1567                 :            :     fn_ptr->get_debug_string (),
    1568                 :            :     numargs, min_num_params);
    1569                 :            : 
    1570                 :         65 :   for (int i = 0; i < min_num_params; i++)
    1571                 :            :     {
    1572                 :         50 :       gcc::jit::recording::type *param_type = fn_type->get_param_types ()[i];
    1573                 :         50 :       gcc_jit_rvalue *arg = args[i];
    1574                 :            : 
    1575                 :         50 :       RETURN_NULL_IF_FAIL_PRINTF3 (
    1576                 :            :         arg,
    1577                 :            :         ctxt, loc,
    1578                 :            :         "NULL argument %i to fn_ptr: %s"
    1579                 :            :         " (type: %s)",
    1580                 :            :         i + 1,
    1581                 :            :         fn_ptr->get_debug_string (),
    1582                 :            :         param_type->get_debug_string ());
    1583                 :            : 
    1584                 :         50 :       RETURN_NULL_IF_FAIL_PRINTF6 (
    1585                 :            :         compatible_types (param_type,
    1586                 :            :                           arg->get_type ()),
    1587                 :            :         ctxt, loc,
    1588                 :            :         "mismatching types for argument %d of fn_ptr: %s:"
    1589                 :            :         " assignment to param %d (type: %s) from %s (type: %s)",
    1590                 :            :         i + 1,
    1591                 :            :         fn_ptr->get_debug_string (),
    1592                 :            :         i + 1,
    1593                 :            :         param_type->get_debug_string (),
    1594                 :            :         arg->get_debug_string (),
    1595                 :            :         arg->get_type ()->get_debug_string ());
    1596                 :            :     }
    1597                 :            : 
    1598                 :         15 :   return (gcc_jit_rvalue *)(
    1599                 :         15 :             ctxt->new_call_through_ptr (loc,
    1600                 :            :                                         fn_ptr,
    1601                 :            :                                         numargs,
    1602                 :         15 :                                         (gcc::jit::recording::rvalue **)args));
    1603                 :            : }
    1604                 :            : 
    1605                 :            : /* Helper function for determining if we can cast an rvalue from SRC_TYPE
    1606                 :            :    to DST_TYPE, for use by gcc_jit_context_new_cast.
    1607                 :            : 
    1608                 :            :    We only permit these kinds of cast:
    1609                 :            : 
    1610                 :            :      int <-> float
    1611                 :            :      int <-> bool
    1612                 :            :      P*  <-> Q*   for pointer types P and Q.  */
    1613                 :            : 
    1614                 :            : static bool
    1615                 :        244 : is_valid_cast (gcc::jit::recording::type *src_type,
    1616                 :            :                gcc_jit_type *dst_type)
    1617                 :            : {
    1618                 :        244 :   bool src_is_int = src_type->is_int ();
    1619                 :        244 :   bool dst_is_int = dst_type->is_int ();
    1620                 :        244 :   bool src_is_float = src_type->is_float ();
    1621                 :        244 :   bool dst_is_float = dst_type->is_float ();
    1622                 :        244 :   bool src_is_bool = src_type->is_bool ();
    1623                 :        244 :   bool dst_is_bool = dst_type->is_bool ();
    1624                 :            : 
    1625                 :        244 :   if (src_is_int)
    1626                 :         95 :     if (dst_is_int || dst_is_float || dst_is_bool)
    1627                 :            :       return true;
    1628                 :            : 
    1629                 :        149 :   if (src_is_float)
    1630                 :         15 :     if (dst_is_int || dst_is_float)
    1631                 :            :       return true;
    1632                 :            : 
    1633                 :        134 :   if (src_is_bool)
    1634                 :         34 :     if (dst_is_int || dst_is_bool)
    1635                 :            :       return true;
    1636                 :            : 
    1637                 :            :   /* Permit casts between pointer types.  */
    1638                 :        100 :   gcc::jit::recording::type *deref_src_type = src_type->is_pointer ();
    1639                 :        100 :   gcc::jit::recording::type *deref_dst_type = dst_type->is_pointer ();
    1640                 :        100 :   if (deref_src_type && deref_dst_type)
    1641                 :         90 :     return true;
    1642                 :            : 
    1643                 :            :   return false;
    1644                 :            : }
    1645                 :            : 
    1646                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1647                 :            : 
    1648                 :            :    After error-checking, the real work is done by the
    1649                 :            :    gcc::jit::recording::context::new_cast method in jit-recording.c.  */
    1650                 :            : 
    1651                 :            : gcc_jit_rvalue *
    1652                 :        244 : gcc_jit_context_new_cast (gcc_jit_context *ctxt,
    1653                 :            :                           gcc_jit_location *loc,
    1654                 :            :                           gcc_jit_rvalue *rvalue,
    1655                 :            :                           gcc_jit_type *type)
    1656                 :            : {
    1657                 :        244 :   RETURN_NULL_IF_FAIL (ctxt, NULL, loc, "NULL context");
    1658                 :        488 :   JIT_LOG_FUNC (ctxt->get_logger ());
    1659                 :            :   /* LOC can be NULL.  */
    1660                 :        244 :   RETURN_NULL_IF_FAIL (rvalue, ctxt, loc, "NULL rvalue");
    1661                 :        244 :   RETURN_NULL_IF_FAIL (type, ctxt, loc, "NULL type");
    1662                 :        244 :   RETURN_NULL_IF_FAIL_PRINTF3 (
    1663                 :            :     is_valid_cast (rvalue->get_type (), type),
    1664                 :            :     ctxt, loc,
    1665                 :            :     "cannot cast %s from type: %s to type: %s",
    1666                 :            :     rvalue->get_debug_string (),
    1667                 :            :     rvalue->get_type ()->get_debug_string (),
    1668                 :            :     type->get_debug_string ());
    1669                 :            : 
    1670                 :        234 :   return static_cast <gcc_jit_rvalue *> (ctxt->new_cast (loc, rvalue, type));
    1671                 :            : }
    1672                 :            : 
    1673                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1674                 :            : 
    1675                 :            :    After error-checking, the real work is done by the
    1676                 :            :    gcc::jit::recording::context::new_array_access method in
    1677                 :            :    jit-recording.c.  */
    1678                 :            : 
    1679                 :            : extern gcc_jit_lvalue *
    1680                 :        404 : gcc_jit_context_new_array_access (gcc_jit_context *ctxt,
    1681                 :            :                                   gcc_jit_location *loc,
    1682                 :            :                                   gcc_jit_rvalue *ptr,
    1683                 :            :                                   gcc_jit_rvalue *index)
    1684                 :            : {
    1685                 :        404 :   RETURN_NULL_IF_FAIL (ctxt, NULL, loc, "NULL context");
    1686                 :        808 :   JIT_LOG_FUNC (ctxt->get_logger ());
    1687                 :            :   /* LOC can be NULL.  */
    1688                 :        404 :   RETURN_NULL_IF_FAIL (ptr, ctxt, loc, "NULL ptr");
    1689                 :        404 :   RETURN_NULL_IF_FAIL (index, ctxt, loc, "NULL index");
    1690                 :        404 :   RETURN_NULL_IF_FAIL_PRINTF2 (
    1691                 :            :     ptr->get_type ()->dereference (),
    1692                 :            :     ctxt, loc,
    1693                 :            :     "ptr: %s (type: %s) is not a pointer or array",
    1694                 :            :     ptr->get_debug_string (),
    1695                 :            :     ptr->get_type ()->get_debug_string ());
    1696                 :        404 :   RETURN_NULL_IF_FAIL_PRINTF2 (
    1697                 :            :     index->get_type ()->is_numeric (),
    1698                 :            :     ctxt, loc,
    1699                 :            :     "index: %s (type: %s) is not of numeric type",
    1700                 :            :     index->get_debug_string (),
    1701                 :            :     index->get_type ()->get_debug_string ());
    1702                 :            : 
    1703                 :        399 :   return (gcc_jit_lvalue *)ctxt->new_array_access (loc, ptr, index);
    1704                 :            : }
    1705                 :            : 
    1706                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1707                 :            : 
    1708                 :            :    After error-checking, the real work is done by the
    1709                 :            :    gcc::jit::recording::memento::get_context method in
    1710                 :            :    jit-recording.h.  */
    1711                 :            : 
    1712                 :            : gcc_jit_context *
    1713                 :        127 : gcc_jit_object_get_context (gcc_jit_object *obj)
    1714                 :            : {
    1715                 :        127 :   RETURN_NULL_IF_FAIL (obj, NULL, NULL, "NULL object");
    1716                 :            : 
    1717                 :        127 :   return static_cast <gcc_jit_context *> (obj->get_context ());
    1718                 :            : }
    1719                 :            : 
    1720                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1721                 :            : 
    1722                 :            :    After error-checking, the real work is done by the
    1723                 :            :    gcc::jit::recording::memento::get_debug_string method in
    1724                 :            :    jit-recording.c.  */
    1725                 :            : 
    1726                 :            : const char *
    1727                 :        925 : gcc_jit_object_get_debug_string (gcc_jit_object *obj)
    1728                 :            : {
    1729                 :        925 :   RETURN_NULL_IF_FAIL (obj, NULL, NULL, "NULL object");
    1730                 :            : 
    1731                 :        925 :   return obj->get_debug_string ();
    1732                 :            : }
    1733                 :            : 
    1734                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1735                 :            : 
    1736                 :            :    After error-checking, the real work is done by the
    1737                 :            :    gcc::jit::recording::lvalue::access_field method in
    1738                 :            :    jit-recording.c.  */
    1739                 :            : 
    1740                 :            : gcc_jit_lvalue *
    1741                 :        204 : gcc_jit_lvalue_access_field (gcc_jit_lvalue *struct_,
    1742                 :            :                              gcc_jit_location *loc,
    1743                 :            :                              gcc_jit_field *field)
    1744                 :            : {
    1745                 :        204 :   RETURN_NULL_IF_FAIL (struct_, NULL, loc, "NULL struct");
    1746                 :        204 :   gcc::jit::recording::context *ctxt = struct_->m_ctxt;
    1747                 :        408 :   JIT_LOG_FUNC (ctxt->get_logger ());
    1748                 :            :   /* LOC can be NULL.  */
    1749                 :        204 :   RETURN_NULL_IF_FAIL (field, ctxt, loc, "NULL field");
    1750                 :        204 :   RETURN_NULL_IF_FAIL_PRINTF1 (field->get_container (), field->m_ctxt, loc,
    1751                 :            :                                "field %s has not been placed in a struct",
    1752                 :            :                                field->get_debug_string ());
    1753                 :        204 :   gcc::jit::recording::type *underlying_type =
    1754                 :        204 :     struct_->get_type ();
    1755                 :        204 :   RETURN_NULL_IF_FAIL_PRINTF2 (
    1756                 :            :     (field->get_container ()->unqualified ()
    1757                 :            :      == underlying_type->unqualified ()),
    1758                 :            :     struct_->m_ctxt, loc,
    1759                 :            :     "%s is not a field of %s",
    1760                 :            :     field->get_debug_string (),
    1761                 :            :     underlying_type->get_debug_string ());
    1762                 :            : 
    1763                 :        199 :   return (gcc_jit_lvalue *)struct_->access_field (loc, field);
    1764                 :            : }
    1765                 :            : 
    1766                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1767                 :            : 
    1768                 :            :    After error-checking, the real work is done by the
    1769                 :            :    gcc::jit::recording::rvalue::access_field method in
    1770                 :            :    jit-recording.c.  */
    1771                 :            : 
    1772                 :            : gcc_jit_rvalue *
    1773                 :        124 : gcc_jit_rvalue_access_field (gcc_jit_rvalue *struct_,
    1774                 :            :                              gcc_jit_location *loc,
    1775                 :            :                              gcc_jit_field *field)
    1776                 :            : {
    1777                 :        124 :   RETURN_NULL_IF_FAIL (struct_, NULL, loc, "NULL struct");
    1778                 :        124 :   gcc::jit::recording::context *ctxt = struct_->m_ctxt;
    1779                 :        248 :   JIT_LOG_FUNC (ctxt->get_logger ());
    1780                 :            :   /* LOC can be NULL.  */
    1781                 :        124 :   RETURN_NULL_IF_FAIL (field, ctxt, loc, "NULL field");
    1782                 :        124 :   RETURN_NULL_IF_FAIL_PRINTF1 (field->get_container (), field->m_ctxt, loc,
    1783                 :            :                                "field %s has not been placed in a struct",
    1784                 :            :                                field->get_debug_string ());
    1785                 :        124 :   gcc::jit::recording::type *underlying_type =
    1786                 :        124 :     struct_->get_type ();
    1787                 :        124 :   RETURN_NULL_IF_FAIL_PRINTF2 (
    1788                 :            :     (field->get_container ()->unqualified ()
    1789                 :            :      == underlying_type->unqualified ()),
    1790                 :            :     struct_->m_ctxt, loc,
    1791                 :            :     "%s is not a field of %s",
    1792                 :            :     field->get_debug_string (),
    1793                 :            :     underlying_type->get_debug_string ());
    1794                 :            : 
    1795                 :        119 :   return (gcc_jit_rvalue *)struct_->access_field (loc, field);
    1796                 :            : }
    1797                 :            : 
    1798                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1799                 :            : 
    1800                 :            :    After error-checking, the real work is done by the
    1801                 :            :    gcc::jit::recording::rvalue::deference_field method in
    1802                 :            :    jit-recording.c.  */
    1803                 :            : 
    1804                 :            : gcc_jit_lvalue *
    1805                 :       1281 : gcc_jit_rvalue_dereference_field (gcc_jit_rvalue *ptr,
    1806                 :            :                                   gcc_jit_location *loc,
    1807                 :            :                                   gcc_jit_field *field)
    1808                 :            : {
    1809                 :       1281 :   RETURN_NULL_IF_FAIL (ptr, NULL, loc, "NULL ptr");
    1810                 :       2562 :   JIT_LOG_FUNC (ptr->get_context ()->get_logger ());
    1811                 :            :   /* LOC can be NULL.  */
    1812                 :       1281 :   RETURN_NULL_IF_FAIL (field, NULL, loc, "NULL field");
    1813                 :       1281 :   gcc::jit::recording::type *underlying_type =
    1814                 :       1281 :     ptr->get_type ()->is_pointer ();
    1815                 :       1281 :   RETURN_NULL_IF_FAIL_PRINTF1 (field->get_container (), field->m_ctxt, loc,
    1816                 :            :                                "field %s has not been placed in a struct",
    1817                 :            :                                field->get_debug_string ());
    1818                 :       1281 :   RETURN_NULL_IF_FAIL_PRINTF3 (
    1819                 :            :     underlying_type,
    1820                 :            :     ptr->m_ctxt, loc,
    1821                 :            :     "dereference of non-pointer %s (type: %s) when accessing ->%s",
    1822                 :            :     ptr->get_debug_string (),
    1823                 :            :     ptr->get_type ()->get_debug_string (),
    1824                 :            :     field->get_debug_string ());
    1825                 :       1271 :   RETURN_NULL_IF_FAIL_PRINTF2 (
    1826                 :            :     (field->get_container ()->unqualified ()
    1827                 :            :      == underlying_type->unqualified ()),
    1828                 :            :     ptr->m_ctxt, loc,
    1829                 :            :     "%s is not a field of %s",
    1830                 :            :     field->get_debug_string (),
    1831                 :            :     underlying_type->get_debug_string ());
    1832                 :            : 
    1833                 :       1261 :   return (gcc_jit_lvalue *)ptr->dereference_field (loc, field);
    1834                 :            : }
    1835                 :            : 
    1836                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1837                 :            : 
    1838                 :            :    After error-checking, the real work is done by the
    1839                 :            :    gcc::jit::recording::rvalue::deference method in
    1840                 :            :    jit-recording.c.  */
    1841                 :            : 
    1842                 :            : gcc_jit_lvalue *
    1843                 :        604 : gcc_jit_rvalue_dereference (gcc_jit_rvalue *rvalue,
    1844                 :            :                             gcc_jit_location *loc)
    1845                 :            : {
    1846                 :        604 :   RETURN_NULL_IF_FAIL (rvalue, NULL, loc, "NULL rvalue");
    1847                 :       1208 :   JIT_LOG_FUNC (rvalue->get_context ()->get_logger ());
    1848                 :            :   /* LOC can be NULL.  */
    1849                 :            : 
    1850                 :        604 :   gcc::jit::recording::type *underlying_type =
    1851                 :        604 :     rvalue->get_type ()->is_pointer ();
    1852                 :            : 
    1853                 :        604 :   RETURN_NULL_IF_FAIL_PRINTF2 (
    1854                 :            :     underlying_type,
    1855                 :            :     rvalue->m_ctxt, loc,
    1856                 :            :     "dereference of non-pointer %s (type: %s)",
    1857                 :            :     rvalue->get_debug_string (),
    1858                 :            :     rvalue->get_type ()->get_debug_string ());
    1859                 :            : 
    1860                 :        599 :   RETURN_NULL_IF_FAIL_PRINTF2 (
    1861                 :            :     !underlying_type->is_void (),
    1862                 :            :     rvalue->m_ctxt, loc,
    1863                 :            :     "dereference of void pointer %s (type: %s)",
    1864                 :            :     rvalue->get_debug_string (),
    1865                 :            :     rvalue->get_type ()->get_debug_string ());
    1866                 :            : 
    1867                 :        594 :   return (gcc_jit_lvalue *)rvalue->dereference (loc);
    1868                 :            : }
    1869                 :            : 
    1870                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1871                 :            : 
    1872                 :            :    After error-checking, the real work is done by the
    1873                 :            :    gcc::jit::recording::lvalue::get_address method in jit-recording.c.  */
    1874                 :            : 
    1875                 :            : gcc_jit_rvalue *
    1876                 :        233 : gcc_jit_lvalue_get_address (gcc_jit_lvalue *lvalue,
    1877                 :            :                             gcc_jit_location *loc)
    1878                 :            : {
    1879                 :        233 :   RETURN_NULL_IF_FAIL (lvalue, NULL, loc, "NULL lvalue");
    1880                 :        466 :   JIT_LOG_FUNC (lvalue->get_context ()->get_logger ());
    1881                 :            :   /* LOC can be NULL.  */
    1882                 :            : 
    1883                 :        233 :   return (gcc_jit_rvalue *)lvalue->get_address (loc);
    1884                 :            : }
    1885                 :            : 
    1886                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1887                 :            : 
    1888                 :            :    After error-checking, the real work is done by the
    1889                 :            :    gcc::jit::recording::function::new_local method in jit-recording.c.  */
    1890                 :            : 
    1891                 :            : gcc_jit_lvalue *
    1892                 :       4786 : gcc_jit_function_new_local (gcc_jit_function *func,
    1893                 :            :                             gcc_jit_location *loc,
    1894                 :            :                             gcc_jit_type *type,
    1895                 :            :                             const char *name)
    1896                 :            : {
    1897                 :       4786 :   RETURN_NULL_IF_FAIL (func, NULL, loc, "NULL function");
    1898                 :       4786 :   gcc::jit::recording::context *ctxt = func->m_ctxt;
    1899                 :       9572 :   JIT_LOG_FUNC (ctxt->get_logger ());
    1900                 :            :   /* LOC can be NULL.  */
    1901                 :       4786 :   RETURN_NULL_IF_FAIL (func->get_kind () != GCC_JIT_FUNCTION_IMPORTED,
    1902                 :            :                        ctxt, loc,
    1903                 :            :                        "Cannot add locals to an imported function");
    1904                 :       4786 :   RETURN_NULL_IF_FAIL (type, ctxt, loc, "NULL type");
    1905                 :       4786 :   RETURN_NULL_IF_FAIL (name, ctxt, loc, "NULL name");
    1906                 :       4786 :   RETURN_NULL_IF_FAIL_PRINTF2 (
    1907                 :            :     type->has_known_size (),
    1908                 :            :     ctxt, loc,
    1909                 :            :     "unknown size for local \"%s\" (type: %s)",
    1910                 :            :     name,
    1911                 :            :     type->get_debug_string ());
    1912                 :            : 
    1913                 :       4781 :   return (gcc_jit_lvalue *)func->new_local (loc, type, name);
    1914                 :            : }
    1915                 :            : 
    1916                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1917                 :            : 
    1918                 :            :    After error-checking, the real work is done by the
    1919                 :            :    gcc::jit::recording::block::add_eval method in jit-recording.c.  */
    1920                 :            : 
    1921                 :            : void
    1922                 :       3175 : gcc_jit_block_add_eval (gcc_jit_block *block,
    1923                 :            :                         gcc_jit_location *loc,
    1924                 :            :                         gcc_jit_rvalue *rvalue)
    1925                 :            : {
    1926                 :       3497 :   RETURN_IF_NOT_VALID_BLOCK (block, loc);
    1927                 :       3175 :   gcc::jit::recording::context *ctxt = block->get_context ();
    1928                 :       6028 :   JIT_LOG_FUNC (ctxt->get_logger ());
    1929                 :            :   /* LOC can be NULL.  */
    1930                 :       3175 :   RETURN_IF_FAIL (rvalue, ctxt, loc, "NULL rvalue");
    1931                 :            : 
    1932                 :       2853 :   gcc::jit::recording::statement *stmt = block->add_eval (loc, rvalue);
    1933                 :            : 
    1934                 :            :   /* "stmt" should be good enough to be usable in error-messages,
    1935                 :            :      but might still not be compilable; perform some more
    1936                 :            :      error-checking here.  We do this here so that the error messages
    1937                 :            :      can contain a stringified version of "stmt", whilst appearing
    1938                 :            :      as close as possible to the point of failure.  */
    1939                 :       2853 :   rvalue->verify_valid_within_stmt (__func__, stmt);
    1940                 :            : }
    1941                 :            : 
    1942                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1943                 :            : 
    1944                 :            :    After error-checking, the real work is done by the
    1945                 :            :    gcc::jit::recording::block::add_assignment method in
    1946                 :            :    jit-recording.c.  */
    1947                 :            : 
    1948                 :            : void
    1949                 :       6831 : gcc_jit_block_add_assignment (gcc_jit_block *block,
    1950                 :            :                               gcc_jit_location *loc,
    1951                 :            :                               gcc_jit_lvalue *lvalue,
    1952                 :            :                               gcc_jit_rvalue *rvalue)
    1953                 :            : {
    1954                 :       9585 :   RETURN_IF_NOT_VALID_BLOCK (block, loc);
    1955                 :       6831 :   gcc::jit::recording::context *ctxt = block->get_context ();
    1956                 :      10908 :   JIT_LOG_FUNC (ctxt->get_logger ());
    1957                 :            :   /* LOC can be NULL.  */
    1958                 :       9570 :   RETURN_IF_FAIL (lvalue, ctxt, loc, "NULL lvalue");
    1959                 :       6816 :   RETURN_IF_FAIL (rvalue, ctxt, loc, "NULL rvalue");
    1960                 :       6483 :   RETURN_IF_FAIL_PRINTF4 (
    1961                 :            :     compatible_types (lvalue->get_type (),
    1962                 :            :                       rvalue->get_type ()),
    1963                 :            :     ctxt, loc,
    1964                 :            :     "mismatching types:"
    1965                 :            :     " assignment to %s (type: %s) from %s (type: %s)",
    1966                 :            :     lvalue->get_debug_string (),
    1967                 :            :     lvalue->get_type ()->get_debug_string (),
    1968                 :            :     rvalue->get_debug_string (),
    1969                 :            :     rvalue->get_type ()->get_debug_string ());
    1970                 :            : 
    1971                 :       4077 :   gcc::jit::recording::statement *stmt = block->add_assignment (loc, lvalue, rvalue);
    1972                 :            : 
    1973                 :            :   /* "stmt" should be good enough to be usable in error-messages,
    1974                 :            :      but might still not be compilable; perform some more
    1975                 :            :      error-checking here.  We do this here so that the error messages
    1976                 :            :      can contain a stringified version of "stmt", whilst appearing
    1977                 :            :      as close as possible to the point of failure.  */
    1978                 :       4077 :   lvalue->verify_valid_within_stmt (__func__, stmt);
    1979                 :       4077 :   rvalue->verify_valid_within_stmt (__func__, stmt);
    1980                 :            : }
    1981                 :            : 
    1982                 :            : /* Public entrypoint.  See description in libgccjit.h.
    1983                 :            : 
    1984                 :            :    After error-checking, the real work is done by the
    1985                 :            :    gcc::jit::recording::block::add_assignment_op method in
    1986                 :            :    jit-recording.c.  */
    1987                 :            : 
    1988                 :            : void
    1989                 :        379 : gcc_jit_block_add_assignment_op (gcc_jit_block *block,
    1990                 :            :                                  gcc_jit_location *loc,
    1991                 :            :                                  gcc_jit_lvalue *lvalue,
    1992                 :            :                                  enum gcc_jit_binary_op op,
    1993                 :            :                                  gcc_jit_rvalue *rvalue)
    1994                 :            : {
    1995                 :        389 :   RETURN_IF_NOT_VALID_BLOCK (block, loc);
    1996                 :        379 :   gcc::jit::recording::context *ctxt = block->get_context ();
    1997                 :        748 :   JIT_LOG_FUNC (ctxt->get_logger ());
    1998                 :            :   /* LOC can be NULL.  */
    1999                 :        384 :   RETURN_IF_FAIL (lvalue, ctxt, loc, "NULL lvalue");
    2000                 :        374 :   RETURN_IF_FAIL_PRINTF1 (
    2001                 :            :     valid_binary_op_p (op),
    2002                 :            :     ctxt, loc,
    2003                 :            :     "unrecognized value for enum gcc_jit_binary_op: %i",
    2004                 :            :     op);
    2005                 :        374 :   RETURN_IF_FAIL (rvalue, ctxt, loc, "NULL rvalue");
    2006                 :        374 :   RETURN_IF_FAIL_PRINTF4 (
    2007                 :            :     compatible_types (lvalue->get_type (),
    2008                 :            :                       rvalue->get_type ()),
    2009                 :            :     ctxt, loc,
    2010                 :            :     "mismatching types:"
    2011                 :            :     " assignment to %s (type: %s) involving %s (type: %s)",
    2012                 :            :     lvalue->get_debug_string (),
    2013                 :            :     lvalue->get_type ()->get_debug_string (),
    2014                 :            :     rvalue->get_debug_string (),
    2015                 :            :     rvalue->get_type ()->get_debug_string ());
    2016                 :            : 
    2017                 :        369 :   gcc::jit::recording::statement *stmt = block->add_assignment_op (loc, lvalue, op, rvalue);
    2018                 :            : 
    2019                 :            :   /* "stmt" should be good enough to be usable in error-messages,
    2020                 :            :      but might still not be compilable; perform some more
    2021                 :            :      error-checking here.  We do this here so that the error messages
    2022                 :            :      can contain a stringified version of "stmt", whilst appearing
    2023                 :            :      as close as possible to the point of failure.  */
    2024                 :        369 :   lvalue->verify_valid_within_stmt (__func__, stmt);
    2025                 :        369 :   rvalue->verify_valid_within_stmt (__func__, stmt);
    2026                 :            : }
    2027                 :            : 
    2028                 :            : /* Internal helper function for determining if rvalue BOOLVAL is of
    2029                 :            :    boolean type.  For use by gcc_jit_block_end_with_conditional.  */
    2030                 :            : 
    2031                 :            : static bool
    2032                 :        824 : is_bool (gcc_jit_rvalue *boolval)
    2033                 :            : {
    2034                 :          0 :   gcc::jit::recording::type *actual_type = boolval->get_type ();
    2035                 :        824 :   gcc::jit::recording::type *bool_type =
    2036                 :        824 :     boolval->m_ctxt->get_type (GCC_JIT_TYPE_BOOL);
    2037                 :        824 :   return actual_type == bool_type;
    2038                 :            : }
    2039                 :            : 
    2040                 :            : /* Public entrypoint.  See description in libgccjit.h.
    2041                 :            : 
    2042                 :            :    After error-checking, the real work is done by the
    2043                 :            :    gcc::jit::recording::block::end_with_conditional method in
    2044                 :            :    jit-recording.c.  */
    2045                 :            : 
    2046                 :            : void
    2047                 :        824 : gcc_jit_block_end_with_conditional (gcc_jit_block *block,
    2048                 :            :                                     gcc_jit_location *loc,
    2049                 :            :                                     gcc_jit_rvalue *boolval,
    2050                 :            :                                     gcc_jit_block *on_true,
    2051                 :            :                                     gcc_jit_block *on_false)
    2052                 :            : {
    2053                 :        824 :   RETURN_IF_NOT_VALID_BLOCK (block, loc);
    2054                 :        824 :   gcc::jit::recording::context *ctxt = block->get_context ();
    2055                 :       1648 :   JIT_LOG_FUNC (ctxt->get_logger ());
    2056                 :            :   /* LOC can be NULL.  */
    2057                 :        824 :   RETURN_IF_FAIL (boolval, ctxt, loc, "NULL boolval");
    2058                 :        824 :   RETURN_IF_FAIL_PRINTF2 (
    2059                 :            :    is_bool (boolval), ctxt, loc,
    2060                 :            :    "%s (type: %s) is not of boolean type ",
    2061                 :            :    boolval->get_debug_string (),
    2062                 :            :    boolval->get_type ()->get_debug_string ());
    2063                 :        824 :   RETURN_IF_FAIL (on_true, ctxt, loc, "NULL on_true");
    2064                 :        824 :   RETURN_IF_FAIL (on_true, ctxt, loc, "NULL on_false");
    2065                 :        824 :   RETURN_IF_FAIL_PRINTF4 (
    2066                 :            :     block->get_function () == on_true->get_function (),
    2067                 :            :     ctxt, loc,
    2068                 :            :     "\"on_true\" block is not in same function:"
    2069                 :            :     " source block %s is in function %s"
    2070                 :            :     " whereas target block %s is in function %s",
    2071                 :            :     block->get_debug_string (),
    2072                 :            :     block->get_function ()->get_debug_string (),
    2073                 :            :     on_true->get_debug_string (),
    2074                 :            :     on_true->get_function ()->get_debug_string ());
    2075                 :        824 :   RETURN_IF_FAIL_PRINTF4 (
    2076                 :            :     block->get_function () == on_false->get_function (),
    2077                 :            :     ctxt, loc,
    2078                 :            :     "\"on_false\" block is not in same function:"
    2079                 :            :     " source block %s is in function %s"
    2080                 :            :     " whereas target block %s is in function %s",
    2081                 :            :     block->get_debug_string (),
    2082                 :            :     block->get_function ()->get_debug_string (),
    2083                 :            :     on_false->get_debug_string (),
    2084                 :            :     on_false->get_function ()->get_debug_string ());
    2085                 :            : 
    2086                 :        824 :   gcc::jit::recording::statement *stmt = block->end_with_conditional (loc, boolval, on_true, on_false);
    2087                 :            : 
    2088                 :            :   /* "stmt" should be good enough to be usable in error-messages,
    2089                 :            :      but might still not be compilable; perform some more
    2090                 :            :      error-checking here.  We do this here so that the error messages
    2091                 :            :      can contain a stringified version of "stmt", whilst appearing
    2092                 :            :      as close as possible to the point of failure.  */
    2093                 :        824 :   boolval->verify_valid_within_stmt (__func__, stmt);
    2094                 :            : }
    2095                 :            : 
    2096                 :            : /* Public entrypoint.  See description in libgccjit.h.
    2097                 :            : 
    2098                 :            :    After error-checking, the real work is done by the
    2099                 :            :    gcc::jit::recording::block::add_comment method in
    2100                 :            :    jit-recording.c.  */
    2101                 :            : 
    2102                 :            : void
    2103                 :        410 : gcc_jit_block_add_comment (gcc_jit_block *block,
    2104                 :            :                            gcc_jit_location *loc,
    2105                 :            :                            const char *text)
    2106                 :            : {
    2107                 :        410 :   RETURN_IF_NOT_VALID_BLOCK (block, loc);
    2108                 :        410 :   gcc::jit::recording::context *ctxt = block->get_context ();
    2109                 :        820 :   JIT_LOG_FUNC (ctxt->get_logger ());
    2110                 :            :   /* LOC can be NULL.  */
    2111                 :        410 :   RETURN_IF_FAIL (text, ctxt, loc, "NULL text");
    2112                 :            : 
    2113                 :        410 :   block->add_comment (loc, text);
    2114                 :            : }
    2115                 :            : 
    2116                 :            : /* Public entrypoint.  See description in libgccjit.h.
    2117                 :            : 
    2118                 :            :    After error-checking, the real work is done by the
    2119                 :            :    gcc::jit::recording::block::end_with_jump method in
    2120                 :            :    jit-recording.c.  */
    2121                 :            : 
    2122                 :            : void
    2123                 :       1122 : gcc_jit_block_end_with_jump (gcc_jit_block *block,
    2124                 :            :                              gcc_jit_location *loc,
    2125                 :            :                              gcc_jit_block *target)
    2126                 :            : {
    2127                 :       1127 :   RETURN_IF_NOT_VALID_BLOCK (block, loc);
    2128                 :       1122 :   gcc::jit::recording::context *ctxt = block->get_context ();
    2129                 :       2239 :   JIT_LOG_FUNC (ctxt->get_logger ());
    2130                 :            :   /* LOC can be NULL.  */
    2131                 :       1127 :   RETURN_IF_FAIL (target, ctxt, loc, "NULL target");
    2132                 :       1122 :   RETURN_IF_FAIL_PRINTF4 (
    2133                 :            :     block->get_function () == target->get_function (),
    2134                 :            :     ctxt, loc,
    2135                 :            :     "target block is not in same function:"
    2136                 :            :     " source block %s is in function %s"
    2137                 :            :     " whereas target block %s is in function %s",
    2138                 :            :     block->get_debug_string (),
    2139                 :            :     block->get_function ()->get_debug_string (),
    2140                 :            :     target->get_debug_string (),
    2141                 :            :     target->get_function ()->get_debug_string ());
    2142                 :            : 
    2143                 :       1117 :   block->end_with_jump (loc, target);
    2144                 :            : }
    2145                 :            : 
    2146                 :            : /* Public entrypoint.  See description in libgccjit.h.
    2147                 :            : 
    2148                 :            :    After error-checking, the real work is done by the
    2149                 :            :    gcc::jit::recording::block::end_with_return method in
    2150                 :            :    jit-recording.c.  */
    2151                 :            : 
    2152                 :            : void
    2153                 :       3369 : gcc_jit_block_end_with_return (gcc_jit_block *block,
    2154                 :            :                                gcc_jit_location *loc,
    2155                 :            :                                gcc_jit_rvalue *rvalue)
    2156                 :            : {
    2157                 :       3946 :   RETURN_IF_NOT_VALID_BLOCK (block, loc);
    2158                 :       3085 :   gcc::jit::recording::context *ctxt = block->get_context ();
    2159                 :       5593 :   JIT_LOG_FUNC (ctxt->get_logger ());
    2160                 :            :   /* LOC can be NULL.  */
    2161                 :       3085 :   gcc::jit::recording::function *func = block->get_function ();
    2162                 :       3598 :   RETURN_IF_FAIL (rvalue, ctxt, loc, "NULL rvalue");
    2163                 :       3021 :   RETURN_IF_FAIL_PRINTF4 (
    2164                 :            :     compatible_types (
    2165                 :            :       func->get_return_type (),
    2166                 :            :       rvalue->get_type ()),
    2167                 :            :     ctxt, loc,
    2168                 :            :     "mismatching types:"
    2169                 :            :     " return of %s (type: %s) in function %s (return type: %s)",
    2170                 :            :     rvalue->get_debug_string (),
    2171                 :            :     rvalue->get_type ()->get_debug_string (),
    2172                 :            :     func->get_debug_string (),
    2173                 :            :     func->get_return_type ()->get_debug_string ());
    2174                 :            : 
    2175                 :       2508 :   gcc::jit::recording::statement *stmt = block->end_with_return (loc, rvalue);
    2176                 :            : 
    2177                 :            :   /* "stmt" should be good enough to be usable in error-messages,
    2178                 :            :      but might still not be compilable; perform some more
    2179                 :            :      error-checking here.  We do this here so that the error messages
    2180                 :            :      can contain a stringified version of "stmt", whilst appearing
    2181                 :            :      as close as possible to the point of failure.  */
    2182                 :       2508 :   rvalue->verify_valid_within_stmt (__func__, stmt);
    2183                 :            : }
    2184                 :            : 
    2185                 :            : /* Public entrypoint.  See description in libgccjit.h.
    2186                 :            : 
    2187                 :            :    After error-checking, the real work is done by the
    2188                 :            :    gcc::jit::recording::block::end_with_return method in
    2189                 :            :    jit-recording.c.  */
    2190                 :            : 
    2191                 :            : void
    2192                 :        471 : gcc_jit_block_end_with_void_return (gcc_jit_block *block,
    2193                 :            :                                     gcc_jit_location *loc)
    2194                 :            : {
    2195                 :        471 :   RETURN_IF_NOT_VALID_BLOCK (block, loc);
    2196                 :        466 :   gcc::jit::recording::context *ctxt = block->get_context ();
    2197                 :        932 :   JIT_LOG_FUNC (ctxt->get_logger ());
    2198                 :            :   /* LOC can be NULL.  */
    2199                 :        466 :   gcc::jit::recording::function *func = block->get_function ();
    2200                 :        466 :   RETURN_IF_FAIL_PRINTF2 (
    2201                 :            :     func->get_return_type () == ctxt->get_type (GCC_JIT_TYPE_VOID),
    2202                 :            :     ctxt, loc,
    2203                 :            :     "mismatching types:"
    2204                 :            :     " void return in function %s (return type: %s)",
    2205                 :            :     func->get_debug_string (),
    2206                 :            :     func->get_return_type ()->get_debug_string ());
    2207                 :            : 
    2208                 :        466 :   block->end_with_return (loc, NULL);
    2209                 :            : }
    2210                 :            : 
    2211                 :            : /* Public entrypoint.  See description in libgccjit.h.
    2212                 :            : 
    2213                 :            :    After error-checking, the real work is done by the
    2214                 :            :    gcc::jit::recording::context::new_case method in
    2215                 :            :    jit-recording.c.  */
    2216                 :            : 
    2217                 :            : gcc_jit_case *
    2218                 :        110 : gcc_jit_context_new_case (gcc_jit_context *ctxt,
    2219                 :            :                           gcc_jit_rvalue *min_value,
    2220                 :            :                           gcc_jit_rvalue *max_value,
    2221                 :            :                           gcc_jit_block *block)
    2222                 :            : {
    2223                 :        110 :   RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context");
    2224                 :        220 :   JIT_LOG_FUNC (ctxt->get_logger ());
    2225                 :        110 :   RETURN_NULL_IF_FAIL (min_value, ctxt, NULL, "NULL min_value");
    2226                 :        110 :   RETURN_NULL_IF_FAIL (max_value, ctxt, NULL, "NULL max_value");
    2227                 :        110 :   RETURN_NULL_IF_FAIL (block, ctxt, NULL, "NULL block");
    2228                 :            : 
    2229                 :        110 :   RETURN_NULL_IF_FAIL_PRINTF1 (min_value->is_constant (), ctxt, NULL,
    2230                 :            :                                "min_value is not a constant: %s",
    2231                 :            :                                min_value->get_debug_string ());
    2232                 :        105 :   RETURN_NULL_IF_FAIL_PRINTF1 (max_value->is_constant (), ctxt, NULL,
    2233                 :            :                                "max_value is not a constant: %s",
    2234                 :            :                                max_value->get_debug_string ());
    2235                 :        105 :   RETURN_NULL_IF_FAIL_PRINTF2 (
    2236                 :            :     min_value->get_type ()->is_int (),
    2237                 :            :     ctxt, NULL,
    2238                 :            :     "min_value: %s (type: %s) is not of integer type",
    2239                 :            :     min_value->get_debug_string (),
    2240                 :            :     min_value->get_type ()->get_debug_string ());
    2241                 :        100 :   RETURN_NULL_IF_FAIL_PRINTF2 (
    2242                 :            :     max_value->get_type ()->is_int (),
    2243                 :            :     ctxt, NULL,
    2244                 :            :     "max_value: %s (type: %s) is not of integer type",
    2245                 :            :     max_value->get_debug_string (),
    2246                 :            :     max_value->get_type ()->get_debug_string ());
    2247                 :            : 
    2248                 :        100 :   wide_int wi_min, wi_max;
    2249                 :        100 :   if (!min_value->get_wide_int (&wi_min))
    2250                 :          0 :     gcc_unreachable ();
    2251                 :        100 :   if (!max_value->get_wide_int (&wi_max))
    2252                 :          0 :     gcc_unreachable ();
    2253                 :        100 :   RETURN_NULL_IF_FAIL_PRINTF2 (
    2254                 :            :     wi::les_p (wi_min, wi_max),
    2255                 :            :     ctxt, NULL,
    2256                 :            :     "min_value: %s > max_value: %s",
    2257                 :            :     min_value->get_debug_string (),
    2258                 :            :     max_value->get_debug_string ());
    2259                 :         95 :   return (gcc_jit_case *)ctxt->new_case (min_value,
    2260                 :            :                                          max_value,
    2261                 :         95 :                                          block);
    2262                 :            : }
    2263                 :            : 
    2264                 :            : /* Public entrypoint.  See description in libgccjit.h.
    2265                 :            : 
    2266                 :            :    After error-checking, this calls the trivial
    2267                 :            :    gcc::jit::recording::memento::as_object method (a case is a
    2268                 :            :    memento), in jit-recording.h.  */
    2269                 :            : 
    2270                 :            : gcc_jit_object *
    2271                 :         20 : gcc_jit_case_as_object (gcc_jit_case *case_)
    2272                 :            : {
    2273                 :         20 :   RETURN_NULL_IF_FAIL (case_, NULL, NULL, "NULL case");
    2274                 :            : 
    2275                 :         20 :   return static_cast <gcc_jit_object *> (case_->as_object ());
    2276                 :            : }
    2277                 :            : 
    2278                 :            : /* Helper function for gcc_jit_block_end_with_switch and
    2279                 :            :    valid_case_for_switch.  */
    2280                 :            : 
    2281                 :            : static bool
    2282                 :        145 : valid_dest_for_switch (gcc::jit::recording::context *ctxt,
    2283                 :            :                        gcc_jit_location *loc,
    2284                 :            :                        const char *api_funcname,
    2285                 :            :                        gcc::jit::recording::block *switch_block,
    2286                 :            :                        gcc::jit::recording::block *dest_block,
    2287                 :            :                        const char *dest_block_desc)
    2288                 :            : {
    2289                 :        145 :   if (!dest_block)
    2290                 :            :     {
    2291                 :          0 :       jit_error (ctxt, loc, "%s: NULL %s", api_funcname, dest_block_desc);
    2292                 :          0 :       return false;
    2293                 :            :     }
    2294                 :        145 :   gcc::jit::recording::function *switch_fn = switch_block->get_function ();
    2295                 :        145 :   gcc::jit::recording::function *dest_fn = dest_block->get_function ();
    2296                 :        145 :   if (switch_fn != dest_fn)
    2297                 :            :     {
    2298                 :          0 :       jit_error (ctxt, loc,
    2299                 :            :                  "%s: %s is not in same function:"
    2300                 :            :                  " switch block %s is in function %s"
    2301                 :            :                  " whereas %s %s is in function %s",
    2302                 :            :                  api_funcname,
    2303                 :            :                  dest_block_desc,
    2304                 :            :                  switch_block->get_debug_string (),
    2305                 :            :                  switch_fn->get_debug_string (),
    2306                 :            :                  dest_block_desc,
    2307                 :            :                  dest_block->get_debug_string (),
    2308                 :            :                  dest_fn->get_debug_string ());
    2309                 :          0 :       return false;
    2310                 :            :     }
    2311                 :            :   return true;
    2312                 :            : }
    2313                 :            : 
    2314                 :            : /* Helper function for gcc_jit_block_end_with_switch.  */
    2315                 :            : 
    2316                 :            : static bool
    2317                 :        115 : valid_case_for_switch (gcc::jit::recording::context *ctxt,
    2318                 :            :                        gcc_jit_location *loc,
    2319                 :            :                        const char *api_funcname,
    2320                 :            :                        gcc_jit_block *switch_block,
    2321                 :            :                        gcc_jit_rvalue *expr,
    2322                 :            :                        gcc_jit_case *case_,
    2323                 :            :                        const char *case_desc,
    2324                 :            :                        int case_idx)
    2325                 :            : {
    2326                 :        115 :   if (!case_)
    2327                 :            :     {
    2328                 :         20 :       jit_error (ctxt, loc,
    2329                 :            :                  "%s:"
    2330                 :            :                  " NULL case %i",
    2331                 :            :                  api_funcname,
    2332                 :            :                  case_idx);
    2333                 :         20 :       return false;
    2334                 :            :     }
    2335                 :         95 :   if (!valid_dest_for_switch (ctxt, loc,
    2336                 :            :                               api_funcname,
    2337                 :            :                               switch_block,
    2338                 :            :                               case_->get_dest_block (),
    2339                 :            :                               case_desc))
    2340                 :            :     return false;
    2341                 :         95 :   gcc::jit::recording::type *expr_type = expr->get_type ();
    2342                 :         95 :   if (expr_type != case_->get_min_value ()->get_type ())
    2343                 :            :     {
    2344                 :          5 :       jit_error (ctxt, loc,
    2345                 :            :                  "%s:"
    2346                 :            :                  " mismatching types between case and expression:"
    2347                 :            :                  " cases[%i]->min_value: %s (type: %s)"
    2348                 :            :                  " expr: %s (type: %s)",
    2349                 :            :                  api_funcname,
    2350                 :            :                  case_idx,
    2351                 :          5 :                  case_->get_min_value ()->get_debug_string (),
    2352                 :          5 :                  case_->get_min_value ()->get_type ()->get_debug_string (),
    2353                 :            :                  expr->get_debug_string (),
    2354                 :            :                  expr_type->get_debug_string ());
    2355                 :          5 :       return false;
    2356                 :            :     }
    2357                 :         90 :   if (expr_type != case_->get_max_value ()->get_type ())
    2358                 :            :     {
    2359                 :          0 :       jit_error (ctxt, loc,
    2360                 :            :                  "%s:"
    2361                 :            :                  " mismatching types between case and expression:"
    2362                 :            :                  " cases[%i]->max_value: %s (type: %s)"
    2363                 :            :                  " expr: %s (type: %s)",
    2364                 :            :                  api_funcname,
    2365                 :            :                  case_idx,
    2366                 :          0 :                  case_->get_max_value ()->get_debug_string (),
    2367                 :          0 :                  case_->get_max_value ()->get_type ()->get_debug_string (),
    2368                 :            :                  expr->get_debug_string (),
    2369                 :            :                  expr_type->get_debug_string ());
    2370                 :          0 :       return false;
    2371                 :            :     }
    2372                 :            :   return true;
    2373                 :            : }
    2374                 :            : 
    2375                 :            : /* A class for holding the data we need to perform error-checking
    2376                 :            :    on a libgccjit API call.  */
    2377                 :            : 
    2378                 :            : class api_call_validator
    2379                 :            : {
    2380                 :            :  public:
    2381                 :         50 :   api_call_validator (gcc::jit::recording::context *ctxt,
    2382                 :            :                       gcc_jit_location *loc,
    2383                 :            :                       const char *funcname)
    2384                 :         50 :   : m_ctxt (ctxt),
    2385                 :            :     m_loc (loc),
    2386                 :         50 :     m_funcname (funcname)
    2387                 :            :   {}
    2388                 :            : 
    2389                 :            :  protected:
    2390                 :            :   gcc::jit::recording::context *m_ctxt;
    2391                 :            :   gcc_jit_location *m_loc;
    2392                 :            :   const char *m_funcname;
    2393                 :            : };
    2394                 :            : 
    2395                 :            : /* A class for verifying that the ranges of cases within
    2396                 :            :    gcc_jit_block_end_with_switch don't overlap.  */
    2397                 :            : 
    2398                 :         30 : class case_range_validator : public api_call_validator
    2399                 :            : {
    2400                 :            :  public:
    2401                 :            :   case_range_validator (gcc::jit::recording::context *ctxt,
    2402                 :            :                         gcc_jit_location *loc,
    2403                 :            :                         const char *funcname);
    2404                 :            : 
    2405                 :            :   bool
    2406                 :            :   validate (gcc_jit_case *case_, int idx);
    2407                 :            : 
    2408                 :            :  private:
    2409                 :            :   static int
    2410                 :            :   case_compare (gcc::jit::recording::rvalue *k1,
    2411                 :            :                 gcc::jit::recording::rvalue *k2);
    2412                 :            : 
    2413                 :            :   static wide_int
    2414                 :            :   get_wide_int (gcc::jit::recording::rvalue *k);
    2415                 :            : 
    2416                 :            :  private:
    2417                 :            :   typed_splay_tree <gcc::jit::recording::rvalue *, gcc_jit_case *> m_cases;
    2418                 :            : };
    2419                 :            : 
    2420                 :            : /* case_range_validator's ctor.  */
    2421                 :            : 
    2422                 :         50 : case_range_validator::case_range_validator (gcc::jit::recording::context *ctxt,
    2423                 :            :                                             gcc_jit_location *loc,
    2424                 :         50 :                                             const char *funcname)
    2425                 :            : : api_call_validator (ctxt, loc, funcname),
    2426                 :         50 :   m_cases (case_compare, NULL, NULL)
    2427                 :            : {
    2428                 :         50 : }
    2429                 :            : 
    2430                 :            : /* Ensure that the range of CASE_ does not overlap with any of the
    2431                 :            :    ranges of cases we've already seen.
    2432                 :            :    Return true if everything is OK.
    2433                 :            :    Return false and emit an error if there is an overlap.
    2434                 :            :    Compare with c-family/c-common.c:c_add_case_label.  */
    2435                 :            : 
    2436                 :            : bool
    2437                 :         90 : case_range_validator::validate (gcc_jit_case *case_,
    2438                 :            :                                 int case_idx)
    2439                 :            : {
    2440                 :            :   /* Look up the LOW_VALUE in the table of case labels we already
    2441                 :            :      have.  */
    2442                 :         90 :   gcc_jit_case *other = m_cases.lookup (case_->get_min_value ());
    2443                 :            : 
    2444                 :            :   /* If there was not an exact match, check for overlapping ranges.  */
    2445                 :          0 :   if (!other)
    2446                 :            :     {
    2447                 :         90 :       gcc_jit_case *pred;
    2448                 :         90 :       gcc_jit_case *succ;
    2449                 :            : 
    2450                 :            :       /* Even though there wasn't an exact match, there might be an
    2451                 :            :          overlap between this case range and another case range.
    2452                 :            :          Since we've (inductively) not allowed any overlapping case
    2453                 :            :          ranges, we simply need to find the greatest low case label
    2454                 :            :          that is smaller that CASE_MIN_VALUE, and the smallest low case
    2455                 :            :          label that is greater than CASE_MAX_VALUE.  If there is an overlap
    2456                 :            :          it will occur in one of these two ranges.  */
    2457                 :         90 :       pred = m_cases.predecessor (case_->get_min_value ());
    2458                 :         90 :       succ = m_cases.successor (case_->get_max_value ());
    2459                 :            : 
    2460                 :            :       /* Check to see if the PRED overlaps.  It is smaller than
    2461                 :            :          the LOW_VALUE, so we only need to check its max value.  */
    2462                 :         90 :       if (pred)
    2463                 :            :         {
    2464                 :         45 :           wide_int wi_case_min = get_wide_int (case_->get_min_value ());
    2465                 :         45 :           wide_int wi_pred_max = get_wide_int (pred->get_max_value ());
    2466                 :         45 :           if (wi::ges_p (wi_pred_max, wi_case_min))
    2467                 :          5 :             other = pred;
    2468                 :            :         }
    2469                 :            : 
    2470                 :         90 :       if (!other && succ)
    2471                 :            :         {
    2472                 :            :           /* Check to see if the SUCC overlaps.  The low end of that
    2473                 :            :              range is bigger than the low end of the current range.  */
    2474                 :         20 :           wide_int wi_case_max = get_wide_int (case_->get_max_value ());
    2475                 :         20 :           wide_int wi_succ_min = get_wide_int (succ->get_min_value ());
    2476                 :         20 :           if (wi::les_p (wi_succ_min, wi_case_max))
    2477                 :          0 :             other = succ;
    2478                 :            :         }
    2479                 :            :     }
    2480                 :            : 
    2481                 :            :   /* If there was an overlap, issue an error.  */
    2482                 :         90 :   if (other)
    2483                 :            :     {
    2484                 :          5 :       jit_error (m_ctxt, m_loc,
    2485                 :            :                  "%s: duplicate (or overlapping) cases values:"
    2486                 :            :                  " case %i: %s overlaps %s",
    2487                 :            :                  m_funcname,
    2488                 :            :                  case_idx,
    2489                 :            :                  case_->get_debug_string (),
    2490                 :            :                  other->get_debug_string ());
    2491                 :          5 :       return false;
    2492                 :            :     }
    2493                 :            : 
    2494                 :            :   /* Register this case label in the splay tree.  */
    2495                 :         85 :   m_cases.insert (case_->get_min_value (),
    2496                 :            :                   case_);
    2497                 :         85 :   return true;
    2498                 :            : }
    2499                 :            : 
    2500                 :            : /* Compare with c-family/c-common.c:case_compare, which acts on tree
    2501                 :            :    nodes, rather than rvalue *.
    2502                 :            : 
    2503                 :            :    Comparator for case label values.  K1 and K2 must be constant integer
    2504                 :            :    values (anything else should have been rejected by
    2505                 :            :    gcc_jit_context_new_case.
    2506                 :            : 
    2507                 :            :    Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
    2508                 :            :    K2, and 0 if K1 and K2 are equal.  */
    2509                 :            : 
    2510                 :            : int
    2511                 :        570 : case_range_validator::case_compare (gcc::jit::recording::rvalue * k1,
    2512                 :            :                                     gcc::jit::recording::rvalue * k2)
    2513                 :            : {
    2514                 :        570 :   wide_int wi1 = get_wide_int (k1);
    2515                 :        570 :   wide_int wi2 = get_wide_int (k2);
    2516                 :        570 :   return wi::cmps(wi1, wi2);
    2517                 :            : }
    2518                 :            : 
    2519                 :            : /* Given a const int rvalue K, get the underlying value as a wide_int.  */
    2520                 :            : 
    2521                 :            : wide_int
    2522                 :       1270 : case_range_validator::get_wide_int (gcc::jit::recording::rvalue *k)
    2523                 :            : {
    2524                 :       1270 :   wide_int wi;
    2525                 :       1270 :   bool got_wi = k->get_wide_int (&wi);
    2526                 :       1270 :   gcc_assert (got_wi);
    2527                 :       1270 :   return wi;
    2528                 :            : }
    2529                 :            : 
    2530                 :            : /* Public entrypoint.  See description in libgccjit.h.
    2531                 :            : 
    2532                 :            :    After error-checking, the real work is done by the
    2533                 :            :    gcc::jit::recording::block::end_with_switch method in
    2534                 :            :    jit-recording.c.  */
    2535                 :            : 
    2536                 :            : void
    2537                 :         50 : gcc_jit_block_end_with_switch (gcc_jit_block *block,
    2538                 :            :                                gcc_jit_location *loc,
    2539                 :            :                                gcc_jit_rvalue *expr,
    2540                 :            :                                gcc_jit_block *default_block,
    2541                 :            :                                int num_cases,
    2542                 :            :                                gcc_jit_case **cases)
    2543                 :            : {
    2544                 :         80 :   RETURN_IF_NOT_VALID_BLOCK (block, loc);
    2545                 :         50 :   gcc::jit::recording::context *ctxt = block->get_context ();
    2546                 :         50 :   JIT_LOG_FUNC (ctxt->get_logger ());
    2547                 :            :   /* LOC can be NULL.  */
    2548                 :         80 :   RETURN_IF_FAIL (expr, ctxt, loc,
    2549                 :            :                   "NULL expr");
    2550                 :         50 :   gcc::jit::recording::type *expr_type = expr->get_type ();
    2551                 :         50 :   RETURN_IF_FAIL_PRINTF2 (
    2552                 :            :     expr_type->is_int (),
    2553                 :            :     ctxt, loc,
    2554                 :            :     "expr: %s (type: %s) is not of integer type",
    2555                 :            :     expr->get_debug_string (),
    2556                 :            :     expr_type->get_debug_string ());
    2557                 :         50 :   if (!valid_dest_for_switch (ctxt, loc,
    2558                 :            :                               __func__,
    2559                 :            :                               block,
    2560                 :            :                               default_block,
    2561                 :            :                               "default_block"))
    2562                 :            :     return;
    2563                 :         50 :   RETURN_IF_FAIL (num_cases >= 0, ctxt, loc, "num_cases < 0");
    2564                 :         20 :   case_range_validator crv (ctxt, loc, __func__);
    2565                 :        135 :   for (int i = 0; i < num_cases; i++)
    2566                 :            :     {
    2567                 :        115 :       char case_desc[32];
    2568                 :        115 :       snprintf (case_desc, sizeof (case_desc),
    2569                 :            :                 "cases[%i]", i);
    2570                 :        115 :       if (!valid_case_for_switch (ctxt, loc,
    2571                 :            :                                   __func__,
    2572                 :            :                                   block,
    2573                 :            :                                   expr,
    2574                 :        115 :                                   cases[i],
    2575                 :            :                                   case_desc,
    2576                 :            :                                   i))
    2577                 :         30 :         return;
    2578                 :         90 :       if (!crv.validate (cases[i], i))
    2579                 :            :         return;
    2580                 :            :     }
    2581                 :            : 
    2582                 :         20 :   block->end_with_switch (loc, expr, default_block,
    2583                 :            :                           num_cases,
    2584                 :            :                           (gcc::jit::recording::case_ **)cases);
    2585                 :            : }
    2586                 :            : 
    2587                 :            : /**********************************************************************
    2588                 :            :  Option-management
    2589                 :            :  **********************************************************************/
    2590                 :            : 
    2591                 :            : /* Public entrypoint.  See description in libgccjit.h.
    2592                 :            : 
    2593                 :            :    After error-checking, the real work is done by the
    2594                 :            :    gcc::jit::recording::context::set_str_option method in
    2595                 :            :    jit-recording.c.  */
    2596                 :            : 
    2597                 :            : void
    2598                 :       1342 : gcc_jit_context_set_str_option (gcc_jit_context *ctxt,
    2599                 :            :                                 enum gcc_jit_str_option opt,
    2600                 :            :                                 const char *value)
    2601                 :            : {
    2602                 :       1342 :   RETURN_IF_FAIL (ctxt, NULL, NULL, "NULL context");
    2603                 :       2684 :   JIT_LOG_FUNC (ctxt->get_logger ());
    2604                 :            :   /* opt is checked by the inner function.
    2605                 :            :      value can be NULL.  */
    2606                 :            : 
    2607                 :       1342 :   ctxt->set_str_option (opt, value);
    2608                 :            : }
    2609                 :            : 
    2610                 :            : /* Public entrypoint.  See description in libgccjit.h.
    2611                 :            : 
    2612                 :            :    After error-checking, the real work is done by the
    2613                 :            :    gcc::jit::recording::context::set_int_option method in
    2614                 :            :    jit-recording.c.  */
    2615                 :            : 
    2616                 :            : void
    2617                 :       1342 : gcc_jit_context_set_int_option (gcc_jit_context *ctxt,
    2618                 :            :                                 enum gcc_jit_int_option opt,
    2619                 :            :                                 int value)
    2620                 :            : {
    2621                 :       1342 :   RETURN_IF_FAIL (ctxt, NULL, NULL, "NULL context");
    2622                 :       2684 :   JIT_LOG_FUNC (ctxt->get_logger ());
    2623                 :            :   /* opt is checked by the inner function.  */
    2624                 :            : 
    2625                 :       1342 :   ctxt->set_int_option (opt, value);
    2626                 :            : }
    2627                 :            : 
    2628                 :            : /* Public entrypoint.  See description in libgccjit.h.
    2629                 :            : 
    2630                 :            :    After error-checking, the real work is done by the
    2631                 :            :    gcc::jit::recording::context::set_bool_option method in
    2632                 :            :    jit-recording.c.  */
    2633                 :            : 
    2634                 :            : void
    2635                 :       5515 : gcc_jit_context_set_bool_option (gcc_jit_context *ctxt,
    2636                 :            :                                  enum gcc_jit_bool_option opt,
    2637                 :            :                                  int value)
    2638                 :            : {
    2639                 :       5515 :   RETURN_IF_FAIL (ctxt, NULL, NULL, "NULL context");
    2640                 :      11030 :   JIT_LOG_FUNC (ctxt->get_logger ());
    2641                 :            :   /* opt is checked by the inner function.  */
    2642                 :            : 
    2643                 :       5515 :   ctxt->set_bool_option (opt, value);
    2644                 :            : }
    2645                 :            : 
    2646                 :            : /* Public entrypoint.  See description in libgccjit.h.
    2647                 :            : 
    2648                 :            :    After error-checking, the real work is done by the
    2649                 :            :    gcc::jit::recording::context::set_inner_bool_option method in
    2650                 :            :    jit-recording.c.  */
    2651                 :            : 
    2652                 :            : void
    2653                 :          5 : gcc_jit_context_set_bool_allow_unreachable_blocks (gcc_jit_context *ctxt,
    2654                 :            :                                                    int bool_value)
    2655                 :            : {
    2656                 :          5 :   RETURN_IF_FAIL (ctxt, NULL, NULL, "NULL context");
    2657                 :         10 :   JIT_LOG_FUNC (ctxt->get_logger ());
    2658                 :          5 :   ctxt->set_inner_bool_option (
    2659                 :            :     gcc::jit::INNER_BOOL_OPTION_ALLOW_UNREACHABLE_BLOCKS,
    2660                 :            :     bool_value);
    2661                 :            : }
    2662                 :            : 
    2663                 :            : /* Public entrypoint.  See description in libgccjit.h.
    2664                 :            : 
    2665                 :            :    After error-checking, the real work is done by the
    2666                 :            :    gcc::jit::recording::context::set_inner_bool_option method in
    2667                 :            :    jit-recording.c.  */
    2668                 :            : 
    2669                 :            : extern void
    2670                 :          5 : gcc_jit_context_set_bool_use_external_driver (gcc_jit_context *ctxt,
    2671                 :            :                                               int bool_value)
    2672                 :            : {
    2673                 :          5 :   RETURN_IF_FAIL (ctxt, NULL, NULL, "NULL context");
    2674                 :         10 :   JIT_LOG_FUNC (ctxt->get_logger ());
    2675                 :          5 :   ctxt->set_inner_bool_option (
    2676                 :            :     gcc::jit::INNER_BOOL_OPTION_USE_EXTERNAL_DRIVER,
    2677                 :            :     bool_value);
    2678                 :            : }
    2679                 :            : 
    2680                 :            : /* Public entrypoint.  See description in libgccjit.h.
    2681                 :            : 
    2682                 :            :    After error-checking, the real work is done by the
    2683                 :            :    gcc::jit::recording::context::add_command_line_option method in
    2684                 :            :    jit-recording.c.  */
    2685                 :            : 
    2686                 :            : void
    2687                 :         30 : gcc_jit_context_add_command_line_option (gcc_jit_context *ctxt,
    2688                 :            :                                          const char *optname)
    2689                 :            : {
    2690                 :         30 :   RETURN_IF_FAIL (ctxt, NULL, NULL, "NULL context");
    2691                 :         60 :   JIT_LOG_FUNC (ctxt->get_logger ());
    2692                 :         30 :   RETURN_IF_FAIL (optname, ctxt, NULL, "NULL optname");
    2693                 :         30 :   if (ctxt->get_logger ())
    2694                 :         30 :     ctxt->get_logger ()->log ("optname: %s", optname);
    2695                 :            : 
    2696                 :         30 :   ctxt->add_command_line_option (optname);
    2697                 :            : }
    2698                 :            : 
    2699                 :            : /* Public entrypoint.  See description in libgccjit.h.
    2700                 :            : 
    2701                 :            :    The real work is done by the
    2702                 :            :    gcc::jit::recording::context::add_driver_option method in
    2703                 :            :    jit-recording.c.  */
    2704                 :            : 
    2705                 :            : void
    2706                 :         10 : gcc_jit_context_add_driver_option (gcc_jit_context *ctxt,
    2707                 :            :                                    const char *optname)
    2708                 :            : {
    2709                 :         10 :   RETURN_IF_FAIL (ctxt, NULL, NULL, "NULL context");
    2710                 :         20 :   JIT_LOG_FUNC (ctxt->get_logger ());
    2711                 :         10 :   RETURN_IF_FAIL (optname, ctxt, NULL, "NULL optname");
    2712                 :         10 :   if (ctxt->get_logger ())
    2713                 :         10 :     ctxt->get_logger ()->log ("optname: %s", optname);
    2714                 :            : 
    2715                 :         10 :   ctxt->add_driver_option (optname);
    2716                 :            : }
    2717                 :            : 
    2718                 :            : /* Public entrypoint.  See description in libgccjit.h.
    2719                 :            : 
    2720                 :            :    After error-checking, the real work is done by the
    2721                 :            :    gcc::jit::recording::context::enable_dump method in
    2722                 :            :    jit-recording.c.  */
    2723                 :            : 
    2724                 :            : void
    2725                 :         50 : gcc_jit_context_enable_dump (gcc_jit_context *ctxt,
    2726                 :            :                              const char *dumpname,
    2727                 :            :                              char **out_ptr)
    2728                 :            : {
    2729                 :         50 :   RETURN_IF_FAIL (ctxt, NULL, NULL, "NULL context");
    2730                 :        100 :   JIT_LOG_FUNC (ctxt->get_logger ());
    2731                 :         50 :   RETURN_IF_FAIL (dumpname, ctxt, NULL, "NULL dumpname");
    2732                 :         50 :   RETURN_IF_FAIL (out_ptr, ctxt, NULL, "NULL out_ptr");
    2733                 :            : 
    2734                 :         50 :   ctxt->enable_dump (dumpname, out_ptr);
    2735                 :            : }
    2736                 :            : 
    2737                 :            : /* Public entrypoint.  See description in libgccjit.h.
    2738                 :            : 
    2739                 :            :    After error-checking, the real work is done by the
    2740                 :            :    gcc::jit::recording::context::compile method in
    2741                 :            :    jit-recording.c.  */
    2742                 :            : 
    2743                 :            : gcc_jit_result *
    2744                 :       1337 : gcc_jit_context_compile (gcc_jit_context *ctxt)
    2745                 :            : {
    2746                 :       1337 :   RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context");
    2747                 :            : 
    2748                 :       1337 :   JIT_LOG_FUNC (ctxt->get_logger ());
    2749                 :            : 
    2750                 :       1337 :   ctxt->log ("in-memory compile of ctxt: %p", (void *)ctxt);
    2751                 :            : 
    2752                 :       1337 :   gcc_jit_result *result = (gcc_jit_result *)ctxt->compile ();
    2753                 :            : 
    2754                 :       1337 :   ctxt->log ("%s: returning (gcc_jit_result *)%p",
    2755                 :            :              __func__, (void *)result);
    2756                 :            : 
    2757                 :       1337 :   return result;
    2758                 :            : }
    2759                 :            : 
    2760                 :            : /* Public entrypoint.  See description in libgccjit.h.
    2761                 :            : 
    2762                 :            :    After error-checking, the real work is done by the
    2763                 :            :    gcc::jit::recording::context::compile_to_file method in
    2764                 :            :    jit-recording.c.  */
    2765                 :            : 
    2766                 :            : void
    2767                 :         21 : gcc_jit_context_compile_to_file (gcc_jit_context *ctxt,
    2768                 :            :                                  enum gcc_jit_output_kind output_kind,
    2769                 :            :                                  const char *output_path)
    2770                 :            : {
    2771                 :         21 :   RETURN_IF_FAIL (ctxt, NULL, NULL, "NULL context");
    2772                 :         42 :   JIT_LOG_FUNC (ctxt->get_logger ());
    2773                 :         21 :   RETURN_IF_FAIL_PRINTF1 (
    2774                 :            :     ((output_kind >= GCC_JIT_OUTPUT_KIND_ASSEMBLER)
    2775                 :            :      && (output_kind <= GCC_JIT_OUTPUT_KIND_EXECUTABLE)),
    2776                 :            :     ctxt, NULL,
    2777                 :            :     "unrecognized output_kind: %i",
    2778                 :            :     output_kind);
    2779                 :         21 :   RETURN_IF_FAIL (output_path, ctxt, NULL, "NULL output_path");
    2780                 :            : 
    2781                 :         21 :   ctxt->log ("compile_to_file of ctxt: %p", (void *)ctxt);
    2782                 :         21 :   ctxt->log ("output_kind: %i", output_kind);
    2783                 :         21 :   ctxt->log ("output_path: %s", output_path);
    2784                 :            : 
    2785                 :         21 :   ctxt->compile_to_file (output_kind, output_path);
    2786                 :            : }
    2787                 :            : 
    2788                 :            : 
    2789                 :            : /* Public entrypoint.  See description in libgccjit.h.
    2790                 :            : 
    2791                 :            :    After error-checking, the real work is done by the
    2792                 :            :    gcc::jit::recording::context::dump_to_file method in
    2793                 :            :    jit-recording.c.  */
    2794                 :            : 
    2795                 :            : void
    2796                 :         14 : gcc_jit_context_dump_to_file (gcc_jit_context *ctxt,
    2797                 :            :                               const char *path,
    2798                 :            :                               int update_locations)
    2799                 :            : {
    2800                 :         14 :   RETURN_IF_FAIL (ctxt, NULL, NULL, "NULL context");
    2801                 :         28 :   JIT_LOG_FUNC (ctxt->get_logger ());
    2802                 :         14 :   RETURN_IF_FAIL (path, ctxt, NULL, "NULL path");
    2803                 :         14 :   ctxt->dump_to_file (path, update_locations);
    2804                 :            : }
    2805                 :            : 
    2806                 :            : /* Public entrypoint.  See description in libgccjit.h.  */
    2807                 :            : 
    2808                 :            : void
    2809                 :        762 : gcc_jit_context_set_logfile (gcc_jit_context *ctxt,
    2810                 :            :                              FILE *logfile,
    2811                 :            :                              int flags,
    2812                 :            :                              int verbosity)
    2813                 :            : {
    2814                 :        762 :   RETURN_IF_FAIL (ctxt, NULL, NULL, "NULL context");
    2815                 :       1524 :   JIT_LOG_FUNC (ctxt->get_logger ());
    2816                 :        762 :   RETURN_IF_FAIL ((flags == 0), ctxt, NULL, "flags must be 0 for now");
    2817                 :        762 :   RETURN_IF_FAIL ((verbosity == 0), ctxt, NULL, "verbosity must be 0 for now");
    2818                 :            : 
    2819                 :        762 :   gcc::jit::logger *logger;
    2820                 :        762 :   if (logfile)
    2821                 :        762 :     logger = new gcc::jit::logger (logfile, flags, verbosity);
    2822                 :            :   else
    2823                 :            :     logger = NULL;
    2824                 :        762 :   ctxt->set_logger (logger);
    2825                 :            : }
    2826                 :            : 
    2827                 :            : /* Public entrypoint.  See description in libgccjit.h.
    2828                 :            : 
    2829                 :            :    After error-checking, the real work is done by the
    2830                 :            :    gcc::jit::recording::context::dump_reproducer_to_file method in
    2831                 :            :    jit-recording.c.  */
    2832                 :            : 
    2833                 :            : void
    2834                 :        768 : gcc_jit_context_dump_reproducer_to_file (gcc_jit_context *ctxt,
    2835                 :            :                                          const char *path)
    2836                 :            : {
    2837                 :        768 :   RETURN_IF_FAIL (ctxt, NULL, NULL, "NULL context");
    2838                 :       1536 :   JIT_LOG_FUNC (ctxt->get_logger ());
    2839                 :        768 :   RETURN_IF_FAIL (path, ctxt, NULL, "NULL path");
    2840                 :        768 :   ctxt->dump_reproducer_to_file (path);
    2841                 :            : }
    2842                 :            : 
    2843                 :            : /* Public entrypoint.  See description in libgccjit.h.
    2844                 :            : 
    2845                 :            :    After error-checking, the real work is done by the
    2846                 :            :    gcc::jit::recording::context::get_first_error method in
    2847                 :            :    jit-recording.c.  */
    2848                 :            : 
    2849                 :            : const char *
    2850                 :        335 : gcc_jit_context_get_first_error (gcc_jit_context *ctxt)
    2851                 :            : {
    2852                 :        335 :   RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context");
    2853                 :        670 :   JIT_LOG_FUNC (ctxt->get_logger ());
    2854                 :            : 
    2855                 :        335 :   return ctxt->get_first_error ();
    2856                 :            : }
    2857                 :            : 
    2858                 :            : /* Public entrypoint.  See description in libgccjit.h.
    2859                 :            : 
    2860                 :            :    After error-checking, the real work is done by the
    2861                 :            :    gcc::jit::recording::context::get_last_error method in
    2862                 :            :    jit-recording.c.  */
    2863                 :            : 
    2864                 :            : const char *
    2865                 :         10 : gcc_jit_context_get_last_error (gcc_jit_context *ctxt)
    2866                 :            : {
    2867                 :         10 :   RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context");
    2868                 :            : 
    2869                 :         10 :   return ctxt->get_last_error ();
    2870                 :            : }
    2871                 :            : 
    2872                 :            : /* Public entrypoint.  See description in libgccjit.h.
    2873                 :            : 
    2874                 :            :    After error-checking, the real work is done by the
    2875                 :            :    gcc::jit::result::get_code method in jit-result.c.  */
    2876                 :            : 
    2877                 :            : void *
    2878                 :       2147 : gcc_jit_result_get_code (gcc_jit_result *result,
    2879                 :            :                          const char *fnname)
    2880                 :            : {
    2881                 :       2147 :   RETURN_NULL_IF_FAIL (result, NULL, NULL, "NULL result");
    2882                 :       4294 :   JIT_LOG_FUNC (result->get_logger ());
    2883                 :       2147 :   RETURN_NULL_IF_FAIL (fnname, NULL, NULL, "NULL fnname");
    2884                 :            : 
    2885                 :       2147 :   result->log ("locating fnname: %s", fnname);
    2886                 :       2147 :   void *code = result->get_code (fnname);
    2887                 :       2147 :   result->log ("%s: returning (void *)%p", __func__, code);
    2888                 :            : 
    2889                 :       2147 :   return code;
    2890                 :            : }
    2891                 :            : 
    2892                 :            : /* Public entrypoint.  See description in libgccjit.h.
    2893                 :            : 
    2894                 :            :    After error-checking, the real work is done by the
    2895                 :            :    gcc::jit::result::get_global method in jit-result.c.  */
    2896                 :            : 
    2897                 :            : void *
    2898                 :         30 : gcc_jit_result_get_global (gcc_jit_result *result,
    2899                 :            :                            const char *name)
    2900                 :            : {
    2901                 :         30 :   RETURN_NULL_IF_FAIL (result, NULL, NULL, "NULL result");
    2902                 :         60 :   JIT_LOG_FUNC (result->get_logger ());
    2903                 :         30 :   RETURN_NULL_IF_FAIL (name, NULL, NULL, "NULL name");
    2904                 :            : 
    2905                 :         30 :   void *global = result->get_global (name);
    2906                 :         30 :   result->log ("%s: returning (void *)%p", __func__, global);
    2907                 :            : 
    2908                 :         30 :   return global;
    2909                 :            : }
    2910                 :            : 
    2911                 :            : /* Public entrypoint.  See description in libgccjit.h.
    2912                 :            : 
    2913                 :            :    After error-checking, this is essentially a wrapper around the
    2914                 :            :    destructor for gcc::jit::result in jit-result.c.  */
    2915                 :            : 
    2916                 :            : void
    2917                 :       1337 : gcc_jit_result_release (gcc_jit_result *result)
    2918                 :            : {
    2919                 :       1337 :   RETURN_IF_FAIL (result, NULL, NULL, "NULL result");
    2920                 :       1674 :   JIT_LOG_FUNC (result->get_logger ());
    2921                 :        837 :   result->log ("deleting result: %p", (void *)result);
    2922                 :        837 :   delete result;
    2923                 :            : }
    2924                 :            : 
    2925                 :            : /**********************************************************************
    2926                 :            :  Timing support.
    2927                 :            :  **********************************************************************/
    2928                 :            : 
    2929                 :            : /* Create a gcc_jit_timer instance, and start timing.  */
    2930                 :            : 
    2931                 :            : gcc_jit_timer *
    2932                 :         14 : gcc_jit_timer_new (void)
    2933                 :            : {
    2934                 :         14 :   gcc_jit_timer *timer = new gcc_jit_timer ();
    2935                 :         14 :   timer->start (TV_TOTAL);
    2936                 :         14 :   timer->push (TV_JIT_CLIENT_CODE);
    2937                 :         14 :   return timer;
    2938                 :            : }
    2939                 :            : 
    2940                 :            : /* Release a gcc_jit_timer instance.  */
    2941                 :            : 
    2942                 :            : void
    2943                 :         14 : gcc_jit_timer_release (gcc_jit_timer *timer)
    2944                 :            : {
    2945                 :         14 :   RETURN_IF_FAIL (timer, NULL, NULL, "NULL timer");
    2946                 :            : 
    2947                 :         14 :   delete timer;
    2948                 :            : }
    2949                 :            : 
    2950                 :            : /* Associate a gcc_jit_timer instance with a context.  */
    2951                 :            : 
    2952                 :            : void
    2953                 :        400 : gcc_jit_context_set_timer (gcc_jit_context *ctxt,
    2954                 :            :                            gcc_jit_timer *timer)
    2955                 :            : {
    2956                 :        400 :   RETURN_IF_FAIL (ctxt, NULL, NULL, "NULL ctxt");
    2957                 :        400 :   RETURN_IF_FAIL (timer, ctxt, NULL, "NULL timer");
    2958                 :            : 
    2959                 :        400 :   ctxt->set_timer (timer);
    2960                 :            : }
    2961                 :            : 
    2962                 :            : /* Get the timer associated with a context (if any).  */
    2963                 :            : 
    2964                 :            : gcc_jit_timer *
    2965                 :          0 : gcc_jit_context_get_timer (gcc_jit_context *ctxt)
    2966                 :            : {
    2967                 :          0 :   RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL ctxt");
    2968                 :            : 
    2969                 :          0 :   return (gcc_jit_timer *)ctxt->get_timer ();
    2970                 :            : }
    2971                 :            : 
    2972                 :            : /* Push the given item onto the timing stack.  */
    2973                 :            : 
    2974                 :            : void
    2975                 :       1605 : gcc_jit_timer_push (gcc_jit_timer *timer,
    2976                 :            :                     const char *item_name)
    2977                 :            : {
    2978                 :       1605 :   RETURN_IF_FAIL (timer, NULL, NULL, "NULL timer");
    2979                 :       1605 :   RETURN_IF_FAIL (item_name, NULL, NULL, "NULL item_name");
    2980                 :       1605 :   timer->push_client_item (item_name);
    2981                 :            : }
    2982                 :            : 
    2983                 :            : /* Pop the top item from the timing stack.  */
    2984                 :            : 
    2985                 :            : void
    2986                 :       1610 : gcc_jit_timer_pop (gcc_jit_timer *timer,
    2987                 :            :                    const char *item_name)
    2988                 :            : {
    2989                 :       1610 :   RETURN_IF_FAIL (timer, NULL, NULL, "NULL timer");
    2990                 :            : 
    2991                 :       1610 :   if (item_name)
    2992                 :            :     {
    2993                 :       1610 :       const char *top_item_name = timer->get_topmost_item_name ();
    2994                 :            : 
    2995                 :       1610 :       RETURN_IF_FAIL_PRINTF1
    2996                 :            :         (top_item_name, NULL, NULL,
    2997                 :            :          "pop of empty timing stack (attempting to pop: \"%s\")",
    2998                 :            :          item_name);
    2999                 :            : 
    3000                 :       1610 :       RETURN_IF_FAIL_PRINTF2
    3001                 :            :         (strcmp (item_name, top_item_name) == 0, NULL, NULL,
    3002                 :            :          "mismatching item_name:"
    3003                 :            :          " top of timing stack: \"%s\","
    3004                 :            :          " attempting to pop: \"%s\"",
    3005                 :            :          top_item_name,
    3006                 :            :          item_name);
    3007                 :            :     }
    3008                 :            : 
    3009                 :       1600 :   timer->pop_client_item ();
    3010                 :            : }
    3011                 :            : 
    3012                 :            : /* Print timing information to the given stream about activity since
    3013                 :            :    the timer was started.  */
    3014                 :            : 
    3015                 :            : void
    3016                 :          4 : gcc_jit_timer_print (gcc_jit_timer *timer,
    3017                 :            :                      FILE *f_out)
    3018                 :            : {
    3019                 :          4 :   RETURN_IF_FAIL (timer, NULL, NULL, "NULL timer");
    3020                 :          4 :   RETURN_IF_FAIL (f_out, NULL, NULL, "NULL f_out");
    3021                 :            : 
    3022                 :          4 :   timer->pop (TV_JIT_CLIENT_CODE);
    3023                 :          4 :   timer->stop (TV_TOTAL);
    3024                 :          4 :   timer->print (f_out);
    3025                 :          4 :   timer->start (TV_TOTAL);
    3026                 :          4 :   timer->push (TV_JIT_CLIENT_CODE);
    3027                 :            : }
    3028                 :            : 
    3029                 :            : /* Public entrypoint.  See description in libgccjit.h.
    3030                 :            : 
    3031                 :            :    After error-checking, the real work is effectively done by the
    3032                 :            :    gcc::jit::base_call::set_require_tail_call setter in jit-recording.h.  */
    3033                 :            : 
    3034                 :            : void
    3035                 :         20 : gcc_jit_rvalue_set_bool_require_tail_call (gcc_jit_rvalue *rvalue,
    3036                 :            :                                            int require_tail_call)
    3037                 :            : {
    3038                 :         20 :   RETURN_IF_FAIL (rvalue, NULL, NULL, "NULL call");
    3039                 :         40 :   JIT_LOG_FUNC (rvalue->get_context ()->get_logger ());
    3040                 :            : 
    3041                 :            :   /* Verify that it's a call.  */
    3042                 :         20 :   gcc::jit::recording::base_call *call = rvalue->dyn_cast_base_call ();
    3043                 :         20 :   RETURN_IF_FAIL_PRINTF1 (call, NULL, NULL, "not a call: %s",
    3044                 :            :                           rvalue->get_debug_string ());
    3045                 :            : 
    3046                 :         20 :   call->set_require_tail_call (require_tail_call);
    3047                 :            : }
    3048                 :            : 
    3049                 :            : /* Public entrypoint.  See description in libgccjit.h.
    3050                 :            : 
    3051                 :            :    After error-checking, the real work is done by the
    3052                 :            :    gcc::jit::recording::type::get_aligned method, in
    3053                 :            :    jit-recording.c.  */
    3054                 :            : 
    3055                 :            : gcc_jit_type *
    3056                 :        145 : gcc_jit_type_get_aligned (gcc_jit_type *type,
    3057                 :            :                           size_t alignment_in_bytes)
    3058                 :            : {
    3059                 :        145 :   RETURN_NULL_IF_FAIL (type, NULL, NULL, "NULL type");
    3060                 :            : 
    3061                 :        145 :   gcc::jit::recording::context *ctxt = type->m_ctxt;
    3062                 :            : 
    3063                 :        290 :   JIT_LOG_FUNC (ctxt->get_logger ());
    3064                 :            : 
    3065                 :        145 :   RETURN_NULL_IF_FAIL_PRINTF1
    3066                 :            :     (pow2_or_zerop (alignment_in_bytes), ctxt, NULL,
    3067                 :            :      "alignment not a power of two: %zi",
    3068                 :            :      alignment_in_bytes);
    3069                 :            : 
    3070                 :        140 :   return (gcc_jit_type *)type->get_aligned (alignment_in_bytes);
    3071                 :            : }
    3072                 :            : 
    3073                 :            : /* Public entrypoint.  See description in libgccjit.h.
    3074                 :            : 
    3075                 :            :    After error-checking, the real work is done by the
    3076                 :            :    gcc::jit::recording::type::get_vector method, in
    3077                 :            :    jit-recording.c.  */
    3078                 :            : 
    3079                 :            : gcc_jit_type *
    3080                 :         55 : gcc_jit_type_get_vector (gcc_jit_type *type, size_t num_units)
    3081                 :            : {
    3082                 :         55 :   RETURN_NULL_IF_FAIL (type, NULL, NULL, "NULL type");
    3083                 :            : 
    3084                 :         55 :   gcc::jit::recording::context *ctxt = type->m_ctxt;
    3085                 :            : 
    3086                 :        110 :   JIT_LOG_FUNC (ctxt->get_logger ());
    3087                 :            : 
    3088                 :         55 :   RETURN_NULL_IF_FAIL_PRINTF1
    3089                 :            :     (type->is_int () || type->is_float (), ctxt, NULL,
    3090                 :            :      "type is not integral or floating point: %s",
    3091                 :            :      type->get_debug_string ());
    3092                 :            : 
    3093                 :         50 :   RETURN_NULL_IF_FAIL_PRINTF1
    3094                 :            :     (pow2_or_zerop (num_units), ctxt, NULL,
    3095                 :            :      "num_units not a power of two: %zi",
    3096                 :            :      num_units);
    3097                 :            : 
    3098                 :         45 :   return (gcc_jit_type *)type->get_vector (num_units);
    3099                 :            : }
    3100                 :            : 
    3101                 :            : /* Public entrypoint.  See description in libgccjit.h.
    3102                 :            : 
    3103                 :            :    After error-checking, the real work is done by the
    3104                 :            :    gcc::jit::recording::function::get_address method, in
    3105                 :            :    jit-recording.c.  */
    3106                 :            : 
    3107                 :            : gcc_jit_rvalue *
    3108                 :         15 : gcc_jit_function_get_address (gcc_jit_function *fn,
    3109                 :            :                               gcc_jit_location *loc)
    3110                 :            : {
    3111                 :         15 :   RETURN_NULL_IF_FAIL (fn, NULL, NULL, "NULL function");
    3112                 :            : 
    3113                 :         15 :   gcc::jit::recording::context *ctxt = fn->m_ctxt;
    3114                 :            : 
    3115                 :         30 :   JIT_LOG_FUNC (ctxt->get_logger ());
    3116                 :            :   /* LOC can be NULL.  */
    3117                 :            : 
    3118                 :         15 :   return (gcc_jit_rvalue *)fn->get_address (loc);
    3119                 :            : }
    3120                 :            : 
    3121                 :            : /* Public entrypoint.  See description in libgccjit.h.
    3122                 :            : 
    3123                 :            :    After error-checking, the real work is done by the
    3124                 :            :    gcc::jit::recording::context::new_rvalue_from_vector method, in
    3125                 :            :    jit-recording.c.  */
    3126                 :            : 
    3127                 :            : extern gcc_jit_rvalue *
    3128                 :         75 : gcc_jit_context_new_rvalue_from_vector (gcc_jit_context *ctxt,
    3129                 :            :                                         gcc_jit_location *loc,
    3130                 :            :                                         gcc_jit_type *vec_type,
    3131                 :            :                                         size_t num_elements,
    3132                 :            :                                         gcc_jit_rvalue **elements)
    3133                 :            : {
    3134                 :         75 :   RETURN_NULL_IF_FAIL (ctxt, NULL, loc, "NULL ctxt");
    3135                 :        150 :   JIT_LOG_FUNC (ctxt->get_logger ());
    3136                 :            : 
    3137                 :            :   /* LOC can be NULL.  */
    3138                 :         75 :   RETURN_NULL_IF_FAIL (vec_type, ctxt, loc, "NULL vec_type");
    3139                 :            : 
    3140                 :            :   /* "vec_type" must be a vector type.  */
    3141                 :         75 :   gcc::jit::recording::vector_type *as_vec_type
    3142                 :         75 :     = vec_type->dyn_cast_vector_type ();
    3143                 :         75 :   RETURN_NULL_IF_FAIL_PRINTF1 (as_vec_type, ctxt, loc,
    3144                 :            :                                "%s is not a vector type",
    3145                 :            :                                vec_type->get_debug_string ());
    3146                 :            : 
    3147                 :            :   /* "num_elements" must match.  */
    3148                 :         75 :   RETURN_NULL_IF_FAIL_PRINTF1 (
    3149                 :            :     num_elements == as_vec_type->get_num_units (), ctxt, loc,
    3150                 :            :     "num_elements != %zi", as_vec_type->get_num_units ());
    3151                 :            : 
    3152                 :            :   /* "elements must be non-NULL.  */
    3153                 :         75 :   RETURN_NULL_IF_FAIL (elements, ctxt, loc, "NULL elements");
    3154                 :            : 
    3155                 :            :   /* Each of "elements" must be non-NULL and of the correct type.  */
    3156                 :         75 :   gcc::jit::recording::type *element_type
    3157                 :         75 :     = as_vec_type->get_element_type ();
    3158                 :        375 :   for (size_t i = 0; i < num_elements; i++)
    3159                 :            :     {
    3160                 :        300 :       RETURN_NULL_IF_FAIL_PRINTF1 (
    3161                 :            :         elements[i], ctxt, loc, "NULL elements[%zi]", i);
    3162                 :        300 :       RETURN_NULL_IF_FAIL_PRINTF4 (
    3163                 :            :         compatible_types (element_type,
    3164                 :            :                           elements[i]->get_type ()),
    3165                 :            :         ctxt, loc,
    3166                 :            :         "mismatching type for element[%zi] (expected type: %s): %s (type: %s)",
    3167                 :            :         i,
    3168                 :            :         element_type->get_debug_string (),
    3169                 :            :         elements[i]->get_debug_string (),
    3170                 :            :         elements[i]->get_type ()->get_debug_string ());
    3171                 :            :     }
    3172                 :            : 
    3173                 :         75 :   return (gcc_jit_rvalue *)ctxt->new_rvalue_from_vector
    3174                 :         75 :     (loc,
    3175                 :            :      as_vec_type,
    3176                 :         75 :      (gcc::jit::recording::rvalue **)elements);
    3177                 :            : }

Generated by: LCOV version 1.0

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