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

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

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