gcc/jit/libgccjit++.h

   1 /* A C++ API for libgccjit, purely as inline wrapper functions.
   2    Copyright (C) 2014 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it
   7 under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 3, or (at your option)
   9 any later version.
  10
  11 GCC is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef LIBGCCJIT_PLUS_PLUS_H
  21 #define LIBGCCJIT_PLUS_PLUS_H
  22
  23 #include "libgccjit.h"
  24
  25 #include <limits>
  26 #include <ostream>
  27 #include <vector>
  28
  29 /****************************************************************************
  30  C++ API
  31  ****************************************************************************/
  32
  33 namespace gccjit
  34 {
  35   /* Indentation indicates inheritance.  */
  36   class context;
  37   class error;
  38   class object;
  39     class location;
  40     class field;
  41     class type;
  42       class struct_;
  43     class function;
  44     class block;
  45     class rvalue;
  46      class lvalue;
  47        class param;
  48
  49   /* Errors within the API become C++ exceptions of this class.  */
  50   class error
  51   {
  52   };
  53
  54   class object
  55   {
  56   public:
  57     context get_context () const;
  58
  59     std::string get_debug_string () const;
  60
  61   protected:
  62     object ();
  63     object (gcc_jit_object *obj);
  64
  65     gcc_jit_object *get_inner_object () const;
  66
  67   private:
  68     gcc_jit_object *m_inner_obj;
  69   };
  70
  71   inline std::ostream& operator << (std::ostream& stream, const object &obj);
  72
  73   /* Some client code will want to supply source code locations, others
  74      won't.  To avoid doubling the number of entrypoints, everything
  75      accepting a location also has a default argument.  To do this, the
  76      other classes need to see that "location" has a default constructor,
  77      hence we need to declare it first.  */
  78   class location : public object
  79   {
  80   public:
  81     location ();
  82     location (gcc_jit_location *loc);
  83
  84     gcc_jit_location *get_inner_location () const;
  85   };
  86
  87   class context
  88   {
  89   public:
  90     static context acquire ();
  91     context ();
  92     context (gcc_jit_context *ctxt);
  93
  94     gccjit::context new_child_context ();
  95
  96     gcc_jit_context *get_inner_context () { return m_inner_ctxt; }
  97
  98     void release ();
  99
 100     gcc_jit_result *compile ();
 101
 102     void dump_to_file (const std::string &path,
 103                        bool update_locations);
 104
 105     void set_str_option (enum gcc_jit_str_option opt,
 106                          const char *value);
 107
 108     void set_int_option (enum gcc_jit_int_option opt,
 109                          int value);
 110
 111     void set_bool_option (enum gcc_jit_bool_option opt,
 112                           int value);
 113
 114     location
 115     new_location (const std::string &filename,
 116                   int line,
 117                   int column);
 118
 119     type get_type (enum gcc_jit_types kind);
 120     type get_int_type (size_t num_bytes, int is_signed);
 121
 122     /* A way to map a specific int type, using the compiler to
 123        get the details automatically e.g.:
 124           gccjit::type type = get_int_type <my_int_type_t> ();  */
 125     template <typename T>
 126     type get_int_type ();
 127
 128     type new_array_type (type element_type, int num_elements,
 129                          location loc = location ());
 130
 131     field new_field (type type_, const std::string &name,
 132                      location loc = location ());
 133
 134     struct_ new_struct_type (const std::string &name,
 135                              std::vector<field> &fields,
 136                              location loc = location ());
 137
 138     struct_ new_opaque_struct_type (const std::string &name,
 139                                     location loc = location ());
 140
 141     param new_param (type type_,
 142                      const std::string &name,
 143                      location loc = location ());
 144
 145     function new_function (enum gcc_jit_function_kind kind,
 146                            type return_type,
 147                            const std::string &name,
 148                            std::vector<param> &params,
 149                            int is_variadic,
 150                            location loc = location ());
 151
 152     function get_builtin_function (const std::string &name);
 153
 154     lvalue new_global (type type_,
 155                        const std::string &name,
 156                        location loc = location ());
 157
 158     rvalue new_rvalue (type numeric_type,
 159                        int value) const;
 160     rvalue zero (type numeric_type) const;
 161     rvalue one (type numeric_type) const;
 162     rvalue new_rvalue (type numeric_type,
 163                        double value) const;
 164     rvalue new_rvalue (type pointer_type,
 165                        void *value) const;
 166     rvalue new_rvalue (const std::string &value) const;
 167
 168     /* Generic unary operations...  */
 169     rvalue new_unary_op (enum gcc_jit_unary_op op,
 170                          type result_type,
 171                          rvalue a,
 172                          location loc = location ());
 173
 174     /* ...and shorter ways to spell the various specific kinds of
 175        unary op.  */
 176     rvalue new_minus (type result_type,
 177                       rvalue a,
 178                       location loc = location ());
 179     rvalue new_bitwise_negate (type result_type,
 180                                rvalue a,
 181                                location loc = location ());
 182     rvalue new_logical_negate (type result_type,
 183                                rvalue a,
 184                                location loc = location ());
 185
 186     /* Generic binary operations...  */
 187     rvalue new_binary_op (enum gcc_jit_binary_op op,
 188                           type result_type,
 189                           rvalue a, rvalue b,
 190                           location loc = location ());
 191
 192     /* ...and shorter ways to spell the various specific kinds of
 193        binary op.  */
 194     rvalue new_plus (type result_type,
 195                      rvalue a, rvalue b,
 196                      location loc = location ());
 197     rvalue new_minus (type result_type,
 198                       rvalue a, rvalue b,
 199                       location loc = location ());
 200     rvalue new_mult (type result_type,
 201                      rvalue a, rvalue b,
 202                      location loc = location ());
 203     rvalue new_divide (type result_type,
 204                        rvalue a, rvalue b,
 205                        location loc = location ());
 206     rvalue new_modulo (type result_type,
 207                        rvalue a, rvalue b,
 208                        location loc = location ());
 209     rvalue new_bitwise_and (type result_type,
 210                             rvalue a, rvalue b,
 211                             location loc = location ());
 212     rvalue new_bitwise_xor (type result_type,
 213                             rvalue a, rvalue b,
 214                             location loc = location ());
 215     rvalue new_bitwise_or (type result_type,
 216                            rvalue a, rvalue b,
 217                            location loc = location ());
 218     rvalue new_logical_and (type result_type,
 219                             rvalue a, rvalue b,
 220                             location loc = location ());
 221     rvalue new_logical_or (type result_type,
 222                            rvalue a, rvalue b,
 223                            location loc = location ());
 224
 225     /* Generic comparisons...  */
 226     rvalue new_comparison (enum gcc_jit_comparison op,
 227                            rvalue a, rvalue b,
 228                            location loc = location ());
 229     /* ...and shorter ways to spell the various specific kinds of
 230        comparison.  */
 231     rvalue new_eq (rvalue a, rvalue b,
 232                    location loc = location ());
 233     rvalue new_ne (rvalue a, rvalue b,
 234                    location loc = location ());
 235     rvalue new_lt (rvalue a, rvalue b,
 236                    location loc = location ());
 237     rvalue new_le (rvalue a, rvalue b,
 238                    location loc = location ());
 239     rvalue new_gt (rvalue a, rvalue b,
 240                    location loc = location ());
 241     rvalue new_ge (rvalue a, rvalue b,
 242                    location loc = location ());
 243
 244     /* The most general way of creating a function call.  */
 245     rvalue new_call (function func,
 246                      std::vector<rvalue> &args,
 247                      location loc = location ());
 248
 249     /* In addition, we provide a series of overloaded "new_call" methods
 250        for specific numbers of args (from 0 - 6), to avoid the need for
 251        client code to manually build a vector.  */
 252     rvalue new_call (function func,
 253                      location loc = location ());
 254     rvalue new_call (function func,
 255                      rvalue arg0,
 256                      location loc = location ());
 257     rvalue new_call (function func,
 258                      rvalue arg0, rvalue arg1,
 259                      location loc = location ());
 260     rvalue new_call (function func,
 261                      rvalue arg0, rvalue arg1, rvalue arg2,
 262                      location loc = location ());
 263     rvalue new_call (function func,
 264                      rvalue arg0, rvalue arg1, rvalue arg2,
 265                      rvalue arg3,
 266                      location loc = location ());
 267     rvalue new_call (function func,
 268                      rvalue arg0, rvalue arg1, rvalue arg2,
 269                      rvalue arg3, rvalue arg4,
 270                      location loc = location ());
 271     rvalue new_call (function func,
 272                      rvalue arg0, rvalue arg1, rvalue arg2,
 273                      rvalue arg3, rvalue arg4, rvalue arg5,
 274                      location loc = location ());
 275
 276     rvalue new_cast (rvalue expr,
 277                      type type_,
 278                      location loc = location ());
 279
 280     lvalue new_array_access (rvalue ptr,
 281                              rvalue index,
 282                              location loc = location ());
 283
 284   private:
 285     gcc_jit_context *m_inner_ctxt;
 286   };
 287
 288   class field : public object
 289   {
 290   public:
 291     field ();
 292     field (gcc_jit_field *inner);
 293
 294     gcc_jit_field *get_inner_field () const;
 295   };
 296
 297   class type : public object
 298   {
 299   public:
 300     type ();
 301     type (gcc_jit_type *inner);
 302
 303     gcc_jit_type *get_inner_type () const;
 304
 305     type get_pointer ();
 306     type get_volatile ();
 307
 308     // Shortcuts for getting values of numeric types:
 309     rvalue zero ();
 310     rvalue one ();
 311  };
 312
 313   class struct_ : public type
 314   {
 315   public:
 316     struct_ ();
 317     struct_ (gcc_jit_struct *inner);
 318
 319     gcc_jit_struct *get_inner_struct () const;
 320   };
 321
 322   class function : public object
 323   {
 324   public:
 325     function ();
 326     function (gcc_jit_function *func);
 327
 328     gcc_jit_function *get_inner_function () const;
 329
 330     void dump_to_dot (const std::string &path);
 331
 332     param get_param (int index) const;
 333
 334     block new_block ();
 335     block new_block (const std::string &name);
 336
 337     lvalue new_local (type type_,
 338                       const std::string &name,
 339                       location loc = location ());
 340
 341     /* A series of overloaded operator () with various numbers of arguments
 342        for a very terse way of creating a call to this function.  The call
 343        is created within the same context as the function itself, which may
 344        not be what you want.  */
 345     rvalue operator() (location loc = location ());
 346     rvalue operator() (rvalue arg0,
 347                        location loc = location ());
 348     rvalue operator() (rvalue arg0, rvalue arg1,
 349                        location loc = location ());
 350     rvalue operator() (rvalue arg0, rvalue arg1, rvalue arg2,
 351                        location loc = location ());
 352   };
 353
 354   class block : public object
 355   {
 356   public:
 357     block ();
 358     block (gcc_jit_block *inner);
 359
 360     gcc_jit_block *get_inner_block () const;
 361
 362     function get_function () const;
 363
 364     void add_eval (rvalue rvalue,
 365                    location loc = location ());
 366
 367     void add_assignment (lvalue lvalue,
 368                          rvalue rvalue,
 369                          location loc = location ());
 370
 371     void add_assignment_op (lvalue lvalue,
 372                             enum gcc_jit_binary_op op,
 373                             rvalue rvalue,
 374                             location loc = location ());
 375
 376     /* A way to add a function call to the body of a function being
 377        defined, with various numbers of args.  */
 378     rvalue add_call (function other,
 379                      location loc = location ());
 380     rvalue add_call (function other,
 381                      rvalue arg0,
 382                      location loc = location ());
 383     rvalue add_call (function other,
 384                      rvalue arg0, rvalue arg1,
 385                      location loc = location ());
 386     rvalue add_call (function other,
 387                      rvalue arg0, rvalue arg1, rvalue arg2,
 388                      location loc = location ());
 389     rvalue add_call (function other,
 390                      rvalue arg0, rvalue arg1, rvalue arg2, rvalue arg3,
 391                      location loc = location ());
 392
 393     void add_comment (const std::string &text,
 394                       location loc = location ());
 395
 396     void end_with_conditional (rvalue boolval,
 397                                block on_true,
 398                                block on_false,
 399                                location loc = location ());
 400
 401     void end_with_jump (block target,
 402                         location loc = location ());
 403
 404     void end_with_return (rvalue rvalue,
 405                           location loc = location ());
 406     void end_with_return (location loc = location ());
 407
 408   };
 409
 410   class rvalue : public object
 411   {
 412   public:
 413     rvalue ();
 414     rvalue (gcc_jit_rvalue *inner);
 415     gcc_jit_rvalue *get_inner_rvalue () const;
 416
 417     type get_type ();
 418
 419     rvalue access_field (field field,
 420                          location loc = location ());
 421
 422     lvalue dereference_field (field field,
 423                               location loc = location ());
 424
 425     lvalue dereference (location loc = location ());
 426
 427     rvalue cast_to (type type_,
 428                     location loc = location ());
 429
 430     /* Array access.  */
 431     lvalue operator[] (rvalue index);
 432     lvalue operator[] (int index);
 433   };
 434
 435   class lvalue : public rvalue
 436   {
 437   public:
 438     lvalue ();
 439     lvalue (gcc_jit_lvalue *inner);
 440
 441     gcc_jit_lvalue *get_inner_lvalue () const;
 442
 443     lvalue access_field (field field,
 444                          location loc = location ());
 445
 446     rvalue get_address (location loc = location ());
 447   };
 448
 449   class param : public lvalue
 450   {
 451   public:
 452     param ();
 453     param (gcc_jit_param *inner);
 454
 455     gcc_jit_param *get_inner_param () const;
 456   };
 457
 458
 459   /* Overloaded operators, for those who want the most terse API
 460      (at the possible risk of being a little too magical).
 461
 462      In each case, the first parameter is used to determine which context
 463      owns the resulting expression, and, where appropriate,  what the
 464      latter's type is. */
 465
 466   /* Unary operators.  */
 467   rvalue operator- (rvalue a); // unary minus
 468   rvalue operator~ (rvalue a); // unary bitwise negate
 469   rvalue operator! (rvalue a); // unary logical negate
 470
 471   /* Binary operators.  */
 472   rvalue operator+ (rvalue a, rvalue b);
 473   rvalue operator- (rvalue a, rvalue b);
 474   rvalue operator* (rvalue a, rvalue b);
 475   rvalue operator/ (rvalue a, rvalue b);
 476   rvalue operator% (rvalue a, rvalue b);
 477   rvalue operator& (rvalue a, rvalue b); //  bitwise and
 478   rvalue operator^ (rvalue a, rvalue b); // bitwise_xor
 479   rvalue operator| (rvalue a, rvalue b); // bitwise_or
 480   rvalue operator&& (rvalue a, rvalue b); // logical_and
 481   rvalue operator|| (rvalue a, rvalue b); // logical_or
 482
 483   /* Comparisons.  */
 484   rvalue operator== (rvalue a, rvalue b);
 485   rvalue operator!= (rvalue a, rvalue b);
 486   rvalue operator< (rvalue a, rvalue b);
 487   rvalue operator<= (rvalue a, rvalue b);
 488   rvalue operator> (rvalue a, rvalue b);
 489   rvalue operator>= (rvalue a, rvalue b);
 490
 491   /* Dereferencing. */
 492   lvalue operator* (rvalue ptr);
 493 }
 494
 495 /****************************************************************************
 496  Implementation of the API
 497  ****************************************************************************/
 498 namespace gccjit {
 499
 500 // class context
 501 inline context context::acquire ()
 502 {
 503   return context (gcc_jit_context_acquire ());
 504 }
 505 inline context::context () : m_inner_ctxt (NULL) {}
 506 inline context::context (gcc_jit_context *inner) : m_inner_ctxt (inner)
 507 {
 508   if (!inner)
 509     throw error ();
 510 }
 511
 512 inline gccjit::context
 513 context::new_child_context ()
 514 {
 515   return context (gcc_jit_context_new_child_context (m_inner_ctxt));
 516 }
 517
 518 inline void
 519 context::release ()
 520 {
 521   gcc_jit_context_release (m_inner_ctxt);
 522   m_inner_ctxt = NULL;
 523 }
 524
 525 inline gcc_jit_result *
 526 context::compile ()
 527 {
 528   gcc_jit_result *result = gcc_jit_context_compile (m_inner_ctxt);
 529   if (!result)
 530     throw error ();
 531   return result;
 532 }
 533
 534 inline void
 535 context::dump_to_file (const std::string &path,
 536                        bool update_locations)
 537 {
 538   gcc_jit_context_dump_to_file (m_inner_ctxt,
 539                                 path.c_str (),
 540                                 update_locations);
 541 }
 542
 543 inline void
 544 context::set_str_option (enum gcc_jit_str_option opt,
 545                          const char *value)
 546 {
 547   gcc_jit_context_set_str_option (m_inner_ctxt, opt, value);
 548
 549 }
 550
 551 inline void
 552 context::set_int_option (enum gcc_jit_int_option opt,
 553                          int value)
 554 {
 555   gcc_jit_context_set_int_option (m_inner_ctxt, opt, value);
 556
 557 }
 558
 559 inline void
 560 context::set_bool_option (enum gcc_jit_bool_option opt,
 561                           int value)
 562 {
 563   gcc_jit_context_set_bool_option (m_inner_ctxt, opt, value);
 564
 565 }
 566
 567 inline location
 568 context::new_location (const std::string &filename,
 569                        int line,
 570                        int column)
 571 {
 572   return location (gcc_jit_context_new_location (m_inner_ctxt,
 573                                                  filename.c_str (),
 574                                                  line,
 575                                                  column));
 576 }
 577
 578 inline type
 579 context::get_type (enum gcc_jit_types kind)
 580 {
 581   return type (gcc_jit_context_get_type (m_inner_ctxt, kind));
 582 }
 583
 584 inline type
 585 context::get_int_type (size_t num_bytes, int is_signed)
 586 {
 587   return type (gcc_jit_context_get_int_type (m_inner_ctxt,
 588                                              num_bytes,
 589                                              is_signed));
 590 }
 591
 592 template <typename T>
 593 inline type
 594 context::get_int_type ()
 595 {
 596   return get_int_type (sizeof (T), std::numeric_limits<T>::is_signed);
 597 }
 598
 599 inline type
 600 context::new_array_type (type element_type, int num_elements, location loc)
 601 {
 602   return type (gcc_jit_context_new_array_type (
 603                  m_inner_ctxt,
 604                  loc.get_inner_location (),
 605                  element_type.get_inner_type (),
 606                  num_elements));
 607 }
 608
 609 inline field
 610 context::new_field (type type_, const std::string &name, location loc)
 611 {
 612   return field (gcc_jit_context_new_field (m_inner_ctxt,
 613                                            loc.get_inner_location (),
 614                                            type_.get_inner_type (),
 615                                            name.c_str ()));
 616 }
 617
 618 inline struct_
 619 context::new_struct_type (const std::string &name,
 620                           std::vector<field> &fields,
 621                           location loc)
 622 {
 623   /* Treat std::vector as an array, relying on it not being resized: */
 624   field *as_array_of_wrappers = &fields[0];
 625
 626   /* Treat the array as being of the underlying pointers, relying on
 627      the wrapper type being such a pointer internally.  */
 628   gcc_jit_field **as_array_of_ptrs =
 629     reinterpret_cast<gcc_jit_field **> (as_array_of_wrappers);
 630
 631   return struct_ (gcc_jit_context_new_struct_type (m_inner_ctxt,
 632                                                    loc.get_inner_location (),
 633                                                    name.c_str (),
 634                                                    fields.size (),
 635                                                    as_array_of_ptrs));
 636 }
 637
 638 inline struct_
 639 context::new_opaque_struct_type (const std::string &name,
 640                                  location loc)
 641 {
 642   return struct_ (gcc_jit_context_new_opaque_struct (
 643                     m_inner_ctxt,
 644                     loc.get_inner_location (),
 645                     name.c_str ()));
 646 }
 647
 648 inline param
 649 context::new_param (type type_,
 650                     const std::string &name,
 651                     location loc)
 652 {
 653   return param (gcc_jit_context_new_param (m_inner_ctxt,
 654                                            loc.get_inner_location (),
 655                                            type_.get_inner_type (),
 656                                            name.c_str ()));
 657 }
 658
 659 inline function
 660 context::new_function (enum gcc_jit_function_kind kind,
 661                        type return_type,
 662                        const std::string &name,
 663                        std::vector<param> &params,
 664                        int is_variadic,
 665                        location loc)
 666 {
 667   /* Treat std::vector as an array, relying on it not being resized: */
 668   param *as_array_of_wrappers = &params[0];
 669
 670   /* Treat the array as being of the underlying pointers, relying on
 671      the wrapper type being such a pointer internally.  */
 672   gcc_jit_param **as_array_of_ptrs =
 673     reinterpret_cast<gcc_jit_param **> (as_array_of_wrappers);
 674
 675   return function (gcc_jit_context_new_function (m_inner_ctxt,
 676                                                  loc.get_inner_location (),
 677                                                  kind,
 678                                                  return_type.get_inner_type (),
 679                                                  name.c_str (),
 680                                                  params.size (),
 681                                                  as_array_of_ptrs,
 682                                                  is_variadic));
 683 }
 684
 685 inline function
 686 context::get_builtin_function (const std::string &name)
 687 {
 688   return function (gcc_jit_context_get_builtin_function (m_inner_ctxt,
 689                                                          name.c_str ()));
 690 }
 691
 692 inline lvalue
 693 context::new_global (type type_,
 694                      const std::string &name,
 695                      location loc)
 696 {
 697   return lvalue (gcc_jit_context_new_global (m_inner_ctxt,
 698                                              loc.get_inner_location (),
 699                                              type_.get_inner_type (),
 700                                              name.c_str ()));
 701 }
 702
 703 inline rvalue
 704 context::new_rvalue (type numeric_type,
 705                      int value) const
 706 {
 707   return rvalue (
 708     gcc_jit_context_new_rvalue_from_int (m_inner_ctxt,
 709                                          numeric_type.get_inner_type (),
 710                                          value));
 711 }
 712
 713 inline rvalue
 714 context::zero (type numeric_type) const
 715 {
 716   return rvalue (gcc_jit_context_zero (m_inner_ctxt,
 717                                        numeric_type.get_inner_type ()));
 718 }
 719
 720 inline rvalue
 721 context::one (type numeric_type) const
 722 {
 723   return rvalue (gcc_jit_context_one (m_inner_ctxt,
 724                                        numeric_type.get_inner_type ()));
 725 }
 726
 727 inline rvalue
 728 context::new_rvalue (type numeric_type,
 729                      double value) const
 730 {
 731   return rvalue (
 732     gcc_jit_context_new_rvalue_from_double (m_inner_ctxt,
 733                                             numeric_type.get_inner_type (),
 734                                             value));
 735 }
 736
 737 inline rvalue
 738 context::new_rvalue (type pointer_type,
 739                      void *value) const
 740 {
 741   return rvalue (
 742     gcc_jit_context_new_rvalue_from_ptr (m_inner_ctxt,
 743                                          pointer_type.get_inner_type (),
 744                                          value));
 745 }
 746
 747 inline rvalue
 748 context::new_rvalue (const std::string &value) const
 749 {
 750   return rvalue (
 751     gcc_jit_context_new_string_literal (m_inner_ctxt, value.c_str ()));
 752 }
 753
 754 inline rvalue
 755 context::new_unary_op (enum gcc_jit_unary_op op,
 756                        type result_type,
 757                        rvalue a,
 758                        location loc)
 759 {
 760   return rvalue (gcc_jit_context_new_unary_op (m_inner_ctxt,
 761                                                loc.get_inner_location (),
 762                                                op,
 763                                                result_type.get_inner_type (),
 764                                                a.get_inner_rvalue ()));
 765 }
 766 inline rvalue
 767 context::new_minus (type result_type,
 768                     rvalue a,
 769                     location loc)
 770 {
 771   return rvalue (new_unary_op (GCC_JIT_UNARY_OP_MINUS,
 772                                result_type, a, loc));
 773 }
 774 inline rvalue
 775 context::new_bitwise_negate (type result_type,
 776                              rvalue a,
 777                              location loc)
 778 {
 779   return rvalue (new_unary_op (GCC_JIT_UNARY_OP_BITWISE_NEGATE,
 780                                result_type, a, loc));
 781 }
 782 inline rvalue
 783 context::new_logical_negate (type result_type,
 784                              rvalue a,
 785                              location loc)
 786 {
 787   return rvalue (new_unary_op (GCC_JIT_UNARY_OP_LOGICAL_NEGATE,
 788                                result_type, a, loc));
 789 }
 790
 791 inline rvalue
 792 context::new_binary_op (enum gcc_jit_binary_op op,
 793                         type result_type,
 794                         rvalue a, rvalue b,
 795                         location loc)
 796 {
 797   return rvalue (gcc_jit_context_new_binary_op (m_inner_ctxt,
 798                                                 loc.get_inner_location (),
 799                                                 op,
 800                                                 result_type.get_inner_type (),
 801                                                 a.get_inner_rvalue (),
 802                                                 b.get_inner_rvalue ()));
 803 }
 804 inline rvalue
 805 context::new_plus (type result_type,
 806                    rvalue a, rvalue b,
 807                    location loc)
 808 {
 809   return new_binary_op (GCC_JIT_BINARY_OP_PLUS,
 810                         result_type, a, b, loc);
 811 }
 812 inline rvalue
 813 context::new_minus (type result_type,
 814                     rvalue a, rvalue b,
 815                     location loc)
 816 {
 817   return new_binary_op (GCC_JIT_BINARY_OP_MINUS,
 818                         result_type, a, b, loc);
 819 }
 820 inline rvalue
 821 context::new_mult (type result_type,
 822                    rvalue a, rvalue b,
 823                    location loc)
 824 {
 825   return new_binary_op (GCC_JIT_BINARY_OP_MULT,
 826                         result_type, a, b, loc);
 827 }
 828 inline rvalue
 829 context::new_divide (type result_type,
 830                      rvalue a, rvalue b,
 831                      location loc)
 832 {
 833   return new_binary_op (GCC_JIT_BINARY_OP_DIVIDE,
 834                         result_type, a, b, loc);
 835 }
 836 inline rvalue
 837 context::new_modulo (type result_type,
 838                      rvalue a, rvalue b,
 839                      location loc)
 840 {
 841   return new_binary_op (GCC_JIT_BINARY_OP_MODULO,
 842                         result_type, a, b, loc);
 843 }
 844 inline rvalue
 845 context::new_bitwise_and (type result_type,
 846                           rvalue a, rvalue b,
 847                           location loc)
 848 {
 849   return new_binary_op (GCC_JIT_BINARY_OP_BITWISE_AND,
 850                         result_type, a, b, loc);
 851 }
 852 inline rvalue
 853 context::new_bitwise_xor (type result_type,
 854                           rvalue a, rvalue b,
 855                           location loc)
 856 {
 857   return new_binary_op (GCC_JIT_BINARY_OP_BITWISE_XOR,
 858                         result_type, a, b, loc);
 859 }
 860 inline rvalue
 861 context::new_bitwise_or (type result_type,
 862                          rvalue a, rvalue b,
 863                          location loc)
 864 {
 865   return new_binary_op (GCC_JIT_BINARY_OP_BITWISE_OR,
 866                         result_type, a, b, loc);
 867 }
 868 inline rvalue
 869 context::new_logical_and (type result_type,
 870                           rvalue a, rvalue b,
 871                           location loc)
 872 {
 873   return new_binary_op (GCC_JIT_BINARY_OP_LOGICAL_AND,
 874                         result_type, a, b, loc);
 875 }
 876 inline rvalue
 877 context::new_logical_or (type result_type,
 878                          rvalue a, rvalue b,
 879                          location loc)
 880 {
 881   return new_binary_op (GCC_JIT_BINARY_OP_LOGICAL_OR,
 882                         result_type, a, b, loc);
 883 }
 884
 885 inline rvalue
 886 context::new_comparison (enum gcc_jit_comparison op,
 887                          rvalue a, rvalue b,
 888                          location loc)
 889 {
 890   return rvalue (gcc_jit_context_new_comparison (m_inner_ctxt,
 891                                                  loc.get_inner_location (),
 892                                                  op,
 893                                                  a.get_inner_rvalue (),
 894                                                  b.get_inner_rvalue ()));
 895 }
 896 inline rvalue
 897 context::new_eq (rvalue a, rvalue b,
 898                  location loc)
 899 {
 900   return new_comparison (GCC_JIT_COMPARISON_EQ,
 901                          a, b, loc);
 902 }
 903 inline rvalue
 904 context::new_ne (rvalue a, rvalue b,
 905                  location loc)
 906 {
 907   return new_comparison (GCC_JIT_COMPARISON_NE,
 908                          a, b, loc);
 909 }
 910 inline rvalue
 911 context::new_lt (rvalue a, rvalue b,
 912                  location loc)
 913 {
 914   return new_comparison (GCC_JIT_COMPARISON_LT,
 915                          a, b, loc);
 916 }
 917 inline rvalue
 918 context::new_le (rvalue a, rvalue b,
 919                  location loc)
 920 {
 921   return new_comparison (GCC_JIT_COMPARISON_LE,
 922                          a, b, loc);
 923 }
 924 inline rvalue
 925 context::new_gt (rvalue a, rvalue b,
 926                  location loc)
 927 {
 928   return new_comparison (GCC_JIT_COMPARISON_GT,
 929                          a, b, loc);
 930 }
 931 inline rvalue
 932 context::new_ge (rvalue a, rvalue b,
 933                  location loc)
 934 {
 935   return new_comparison (GCC_JIT_COMPARISON_GE,
 936                          a, b, loc);
 937 }
 938
 939 inline rvalue
 940 context::new_call (function func,
 941                    std::vector<rvalue> &args,
 942                    location loc)
 943 {
 944   /* Treat std::vector as an array, relying on it not being resized: */
 945   rvalue *as_array_of_wrappers = &args[0];
 946
 947   /* Treat the array as being of the underlying pointers, relying on
 948      the wrapper type being such a pointer internally.  */
 949   gcc_jit_rvalue **as_array_of_ptrs =
 950     reinterpret_cast<gcc_jit_rvalue **> (as_array_of_wrappers);
 951   return gcc_jit_context_new_call (m_inner_ctxt,
 952                                    loc.get_inner_location (),
 953                                    func.get_inner_function (),
 954                                    args.size (),
 955                                    as_array_of_ptrs);
 956 }
 957 inline rvalue
 958 context::new_call (function func,
 959                    location loc)
 960 {
 961   std::vector<rvalue> args;
 962   return new_call (func, args, loc);
 963 }
 964
 965 inline rvalue
 966 context::new_call (function func,
 967                    rvalue arg0,
 968                    location loc)
 969 {
 970   std::vector<rvalue> args(1);
 971   args[0] = arg0;
 972   return new_call (func, args, loc);
 973 }
 974 inline rvalue
 975 context::new_call (function func,
 976                    rvalue arg0, rvalue arg1,
 977                    location loc)
 978 {
 979   std::vector<rvalue> args(2);
 980   args[0] = arg0;
 981   args[1] = arg1;
 982   return new_call (func, args, loc);
 983 }
 984 inline rvalue
 985 context::new_call (function func,
 986                    rvalue arg0, rvalue arg1, rvalue arg2,
 987                    location loc)
 988 {
 989   std::vector<rvalue> args(3);
 990   args[0] = arg0;
 991   args[1] = arg1;
 992   args[2] = arg2;
 993   return new_call (func, args, loc);
 994 }
 995 inline rvalue
 996 context::new_call (function func,
 997                    rvalue arg0, rvalue arg1, rvalue arg2,
 998                    rvalue arg3,
 999                    location loc)
1000 {
1001   std::vector<rvalue> args(4);
1002   args[0] = arg0;
1003   args[1] = arg1;
1004   args[2] = arg2;
1005   args[3] = arg3;
1006   return new_call (func, args, loc);
1007 }
1008 inline rvalue
1009 context::new_call (function func,
1010                    rvalue arg0, rvalue arg1, rvalue arg2,
1011                    rvalue arg3, rvalue arg4,
1012                    location loc)
1013 {
1014   std::vector<rvalue> args(5);
1015   args[0] = arg0;
1016   args[1] = arg1;
1017   args[2] = arg2;
1018   args[3] = arg3;
1019   args[4] = arg4;
1020   return new_call (func, args, loc);
1021 }
1022 inline rvalue
1023 context::new_call (function func,
1024                    rvalue arg0, rvalue arg1, rvalue arg2,
1025                    rvalue arg3, rvalue arg4, rvalue arg5,
1026                    location loc)
1027 {
1028   std::vector<rvalue> args(6);
1029   args[0] = arg0;
1030   args[1] = arg1;
1031   args[2] = arg2;
1032   args[3] = arg3;
1033   args[4] = arg4;
1034   args[5] = arg5;
1035   return new_call (func, args, loc);
1036 }
1037
1038 inline rvalue
1039 context::new_cast (rvalue expr,
1040                    type type_,
1041                    location loc)
1042 {
1043   return rvalue (gcc_jit_context_new_cast (m_inner_ctxt,
1044                                            loc.get_inner_location (),
1045                                            expr.get_inner_rvalue (),
1046                                            type_.get_inner_type ()));
1047 }
1048
1049 inline lvalue
1050 context::new_array_access (rvalue ptr,
1051                            rvalue index,
1052                            location loc)
1053 {
1054   return lvalue (gcc_jit_context_new_array_access (m_inner_ctxt,
1055                                                    loc.get_inner_location (),
1056                                                    ptr.get_inner_rvalue (),
1057                                                    index.get_inner_rvalue ()));
1058 }
1059
1060 // class object
1061 inline context
1062 object::get_context () const
1063 {
1064   return context (gcc_jit_object_get_context (m_inner_obj));
1065 }
1066
1067 inline std::string
1068 object::get_debug_string () const
1069 {
1070   return gcc_jit_object_get_debug_string (m_inner_obj);
1071 }
1072
1073 inline object::object () : m_inner_obj (NULL) {}
1074 inline object::object (gcc_jit_object *obj) : m_inner_obj (obj)
1075 {
1076   if (!obj)
1077     throw error ();
1078 }
1079
1080 inline gcc_jit_object *
1081 object::get_inner_object () const
1082 {
1083   return m_inner_obj;
1084 }
1085
1086 inline std::ostream&
1087 operator << (std::ostream& stream, const object &obj)
1088 {
1089   return stream << obj.get_debug_string ();
1090 }
1091
1092 // class location
1093 inline location::location () : object () {}
1094 inline location::location (gcc_jit_location *loc)
1095   : object (gcc_jit_location_as_object (loc))
1096 {}
1097
1098 inline gcc_jit_location *
1099 location::get_inner_location () const
1100 {
1101   /* Manual downcast: */
1102   return reinterpret_cast<gcc_jit_location *> (get_inner_object ());
1103 }
1104
1105 // class field
1106 inline field::field () : object () {}
1107 inline field::field (gcc_jit_field *inner)
1108   : object (gcc_jit_field_as_object (inner))
1109 {}
1110
1111 inline gcc_jit_field *
1112 field::get_inner_field () const
1113 {
1114   /* Manual downcast: */
1115   return reinterpret_cast<gcc_jit_field *> (get_inner_object ());
1116 }
1117
1118 // class type
1119 inline type::type () : object () {}
1120 inline type::type (gcc_jit_type *inner)
1121   : object (gcc_jit_type_as_object (inner))
1122 {}
1123
1124 inline gcc_jit_type *
1125 type::get_inner_type () const
1126 {
1127   /* Manual downcast: */
1128   return reinterpret_cast<gcc_jit_type *> (get_inner_object ());
1129 }
1130
1131 inline type
1132 type::get_pointer ()
1133 {
1134   return type (gcc_jit_type_get_pointer (get_inner_type ()));
1135 }
1136
1137 inline type
1138 type::get_volatile ()
1139 {
1140   return type (gcc_jit_type_get_volatile (get_inner_type ()));
1141 }
1142
1143 inline rvalue
1144 type::zero ()
1145 {
1146   return get_context ().new_rvalue (*this, 0);
1147 }
1148
1149 inline rvalue
1150 type::one ()
1151 {
1152   return get_context ().new_rvalue (*this, 1);
1153 }
1154
1155 // class struct_
1156 inline struct_::struct_ () : type (NULL) {}
1157 inline struct_::struct_ (gcc_jit_struct *inner) :
1158   type (gcc_jit_struct_as_type (inner))
1159 {
1160 }
1161
1162 inline gcc_jit_struct *
1163 struct_::get_inner_struct () const
1164 {
1165   /* Manual downcast: */
1166   return reinterpret_cast<gcc_jit_struct *> (get_inner_object ());
1167 }
1168
1169 // class function
1170 inline function::function () : object () {}
1171 inline function::function (gcc_jit_function *inner)
1172   : object (gcc_jit_function_as_object (inner))
1173 {}
1174
1175 inline gcc_jit_function *
1176 function::get_inner_function () const
1177 {
1178   /* Manual downcast: */
1179   return reinterpret_cast<gcc_jit_function *> (get_inner_object ());
1180 }
1181
1182 inline void
1183 function::dump_to_dot (const std::string &path)
1184 {
1185   gcc_jit_function_dump_to_dot (get_inner_function (),
1186                                 path.c_str ());
1187 }
1188
1189 inline param
1190 function::get_param (int index) const
1191 {
1192   return param (gcc_jit_function_get_param (get_inner_function (),
1193                                             index));
1194 }
1195
1196 inline block
1197 function::new_block ()
1198 {
1199   return block (gcc_jit_function_new_block (get_inner_function (),
1200                                             NULL));
1201 }
1202
1203 inline block
1204 function::new_block (const std::string &name)
1205 {
1206   return block (gcc_jit_function_new_block (get_inner_function (),
1207                                             name.c_str ()));
1208 }
1209
1210 inline lvalue
1211 function::new_local (type type_,
1212                      const std::string &name,
1213                      location loc)
1214 {
1215   return lvalue (gcc_jit_function_new_local (get_inner_function (),
1216                                              loc.get_inner_location (),
1217                                              type_.get_inner_type (),
1218                                              name.c_str ()));
1219 }
1220
1221 inline function
1222 block::get_function () const
1223 {
1224   return function (gcc_jit_block_get_function ( get_inner_block ()));
1225 }
1226
1227 inline void
1228 block::add_eval (rvalue rvalue,
1229                  location loc)
1230 {
1231   gcc_jit_block_add_eval (get_inner_block (),
1232                           loc.get_inner_location (),
1233                           rvalue.get_inner_rvalue ());
1234 }
1235
1236 inline void
1237 block::add_assignment (lvalue lvalue,
1238                        rvalue rvalue,
1239                        location loc)
1240 {
1241   gcc_jit_block_add_assignment (get_inner_block (),
1242                                 loc.get_inner_location (),
1243                                 lvalue.get_inner_lvalue (),
1244                                 rvalue.get_inner_rvalue ());
1245 }
1246
1247 inline void
1248 block::add_assignment_op (lvalue lvalue,
1249                           enum gcc_jit_binary_op op,
1250                           rvalue rvalue,
1251                           location loc)
1252 {
1253   gcc_jit_block_add_assignment_op (get_inner_block (),
1254                                    loc.get_inner_location (),
1255                                    lvalue.get_inner_lvalue (),
1256                                    op,
1257                                    rvalue.get_inner_rvalue ());
1258 }
1259
1260 inline void
1261 block::add_comment (const std::string &text,
1262                     location loc)
1263 {
1264   gcc_jit_block_add_comment (get_inner_block (),
1265                              loc.get_inner_location (),
1266                              text.c_str ());
1267 }
1268
1269 inline void
1270 block::end_with_conditional (rvalue boolval,
1271                              block on_true,
1272                              block on_false,
1273                              location loc)
1274 {
1275   gcc_jit_block_end_with_conditional (get_inner_block (),
1276                                       loc.get_inner_location (),
1277                                       boolval.get_inner_rvalue (),
1278                                       on_true.get_inner_block (),
1279                                       on_false.get_inner_block ());
1280 }
1281
1282 inline void
1283 block::end_with_jump (block target,
1284                       location loc)
1285 {
1286   gcc_jit_block_end_with_jump (get_inner_block (),
1287                                loc.get_inner_location (),
1288                                target.get_inner_block ());
1289 }
1290
1291 inline void
1292 block::end_with_return (rvalue rvalue,
1293                         location loc)
1294 {
1295   gcc_jit_block_end_with_return (get_inner_block (),
1296                                  loc.get_inner_location (),
1297                                  rvalue.get_inner_rvalue ());
1298 }
1299
1300 inline void
1301 block::end_with_return (location loc)
1302 {
1303   gcc_jit_block_end_with_void_return (get_inner_block (),
1304                                       loc.get_inner_location ());
1305 }
1306
1307 inline rvalue
1308 block::add_call (function other,
1309                  location loc)
1310 {
1311   rvalue c = get_context ().new_call (other, loc);
1312   add_eval (c);
1313   return c;
1314 }
1315 inline rvalue
1316 block::add_call (function other,
1317                  rvalue arg0,
1318                  location loc)
1319 {
1320   rvalue c = get_context ().new_call (other, arg0, loc);
1321   add_eval (c);
1322   return c;
1323 }
1324 inline rvalue
1325 block::add_call (function other,
1326                  rvalue arg0, rvalue arg1,
1327                  location loc)
1328 {
1329   rvalue c = get_context ().new_call (other, arg0, arg1, loc);
1330   add_eval (c);
1331   return c;
1332 }
1333 inline rvalue
1334 block::add_call (function other,
1335                  rvalue arg0, rvalue arg1, rvalue arg2,
1336                  location loc)
1337 {
1338   rvalue c = get_context ().new_call (other, arg0, arg1, arg2, loc);
1339   add_eval (c);
1340   return c;
1341 }
1342
1343 inline rvalue
1344 block::add_call (function other,
1345                  rvalue arg0, rvalue arg1, rvalue arg2, rvalue arg3,
1346                  location loc)
1347 {
1348   rvalue c = get_context ().new_call (other, arg0, arg1, arg2, arg3, loc);
1349   add_eval (c);
1350   return c;
1351 }
1352
1353 inline rvalue
1354 function::operator() (location loc)
1355 {
1356   return get_context ().new_call (*this, loc);
1357 }
1358 inline rvalue
1359 function::operator() (rvalue arg0,
1360                       location loc)
1361 {
1362   return get_context ().new_call (*this,
1363                                   arg0,
1364                                   loc);
1365 }
1366 inline rvalue
1367 function::operator() (rvalue arg0, rvalue arg1,
1368                       location loc)
1369 {
1370   return get_context ().new_call (*this,
1371                                   arg0, arg1,
1372                                   loc);
1373 }
1374 inline rvalue
1375 function::operator() (rvalue arg0, rvalue arg1, rvalue arg2,
1376                       location loc)
1377 {
1378   return get_context ().new_call (*this,
1379                                   arg0, arg1, arg2,
1380                                   loc);
1381 }
1382
1383 // class block
1384 inline block::block () : object () {}
1385 inline block::block (gcc_jit_block *inner)
1386   : object (gcc_jit_block_as_object (inner))
1387 {}
1388
1389 inline gcc_jit_block *
1390 block::get_inner_block () const
1391 {
1392   /* Manual downcast: */
1393   return reinterpret_cast<gcc_jit_block *> (get_inner_object ());
1394 }
1395
1396 //  class rvalue
1397 inline rvalue::rvalue () : object () {}
1398 inline rvalue::rvalue (gcc_jit_rvalue *inner)
1399   : object (gcc_jit_rvalue_as_object (inner))
1400 {}
1401
1402 inline gcc_jit_rvalue *
1403 rvalue::get_inner_rvalue () const
1404 {
1405   /* Manual downcast: */
1406   return reinterpret_cast<gcc_jit_rvalue *> (get_inner_object ());
1407 }
1408
1409 inline type
1410 rvalue::get_type ()
1411 {
1412   return type (gcc_jit_rvalue_get_type (get_inner_rvalue ()));
1413 }
1414
1415 inline rvalue
1416 rvalue::access_field (field field,
1417                       location loc)
1418 {
1419   return rvalue (gcc_jit_rvalue_access_field (get_inner_rvalue (),
1420                                               loc.get_inner_location (),
1421                                               field.get_inner_field ()));
1422 }
1423
1424 inline lvalue
1425 rvalue::dereference_field (field field,
1426                            location loc)
1427 {
1428   return lvalue (gcc_jit_rvalue_dereference_field (get_inner_rvalue (),
1429                                                    loc.get_inner_location (),
1430                                                    field.get_inner_field ()));
1431 }
1432
1433 inline lvalue
1434 rvalue::dereference (location loc)
1435 {
1436   return lvalue (gcc_jit_rvalue_dereference (get_inner_rvalue (),
1437                                              loc.get_inner_location ()));
1438 }
1439
1440 inline rvalue
1441 rvalue::cast_to (type type_,
1442                  location loc)
1443 {
1444   return get_context ().new_cast (*this, type_, loc);
1445 }
1446
1447 inline lvalue
1448 rvalue::operator[] (rvalue index)
1449 {
1450   return get_context ().new_array_access (*this, index);
1451 }
1452
1453 inline lvalue
1454 rvalue::operator[] (int index)
1455 {
1456   context ctxt = get_context ();
1457   type int_t = ctxt.get_int_type <int> ();
1458   return ctxt.new_array_access (*this,
1459                                 ctxt.new_rvalue (int_t,
1460                                                  index));
1461 }
1462
1463 // class lvalue : public rvalue
1464 inline lvalue::lvalue () : rvalue () {}
1465 inline lvalue::lvalue (gcc_jit_lvalue *inner)
1466   : rvalue (gcc_jit_lvalue_as_rvalue (inner))
1467 {}
1468
1469 inline gcc_jit_lvalue *
1470 lvalue::get_inner_lvalue () const
1471 {
1472   /* Manual downcast: */
1473   return reinterpret_cast<gcc_jit_lvalue *> (get_inner_object ());
1474 }
1475
1476 inline lvalue
1477 lvalue::access_field (field field, location loc)
1478 {
1479   return lvalue (gcc_jit_lvalue_access_field (get_inner_lvalue (),
1480                                               loc.get_inner_location (),
1481                                               field.get_inner_field ()));
1482 }
1483
1484 inline rvalue
1485 lvalue::get_address (location loc)
1486 {
1487   return rvalue (gcc_jit_lvalue_get_address (get_inner_lvalue (),
1488                                              loc.get_inner_location ()));
1489 }
1490
1491 // class param : public lvalue
1492 inline param::param () : lvalue () {}
1493 inline param::param (gcc_jit_param *inner)
1494   : lvalue (gcc_jit_param_as_lvalue (inner))
1495 {}
1496
1497 /* Overloaded operators.  */
1498 // Unary operators
1499 inline rvalue operator- (rvalue a)
1500 {
1501   return a.get_context ().new_minus (a.get_type (), a);
1502 }
1503 inline rvalue operator~ (rvalue a)
1504 {
1505   return a.get_context ().new_bitwise_negate (a.get_type (), a);
1506 }
1507 inline rvalue operator! (rvalue a)
1508 {
1509   return a.get_context ().new_logical_negate (a.get_type (), a);
1510 }
1511
1512 // Binary operators
1513 inline rvalue operator+ (rvalue a, rvalue b)
1514 {
1515   return a.get_context ().new_plus (a.get_type (), a, b);
1516 }
1517 inline rvalue operator- (rvalue a, rvalue b)
1518 {
1519   return a.get_context ().new_minus (a.get_type (), a, b);
1520 }
1521 inline rvalue operator* (rvalue a, rvalue b)
1522 {
1523   return a.get_context ().new_mult (a.get_type (), a, b);
1524 }
1525 inline rvalue operator/ (rvalue a, rvalue b)
1526 {
1527   return a.get_context ().new_divide (a.get_type (), a, b);
1528 }
1529 inline rvalue operator% (rvalue a, rvalue b)
1530 {
1531   return a.get_context ().new_modulo (a.get_type (), a, b);
1532 }
1533 inline rvalue operator& (rvalue a, rvalue b)
1534 {
1535   return a.get_context ().new_bitwise_and (a.get_type (), a, b);
1536 }
1537 inline rvalue operator^ (rvalue a, rvalue b)
1538 {
1539   return a.get_context ().new_bitwise_xor (a.get_type (), a, b);
1540 }
1541 inline rvalue operator| (rvalue a, rvalue b)
1542 {
1543   return a.get_context ().new_bitwise_or (a.get_type (), a, b);
1544 }
1545 inline rvalue operator&& (rvalue a, rvalue b)
1546 {
1547   return a.get_context ().new_logical_and (a.get_type (), a, b);
1548 }
1549 inline rvalue operator|| (rvalue a, rvalue b)
1550 {
1551   return a.get_context ().new_logical_or (a.get_type (), a, b);
1552 }
1553
1554 /* Comparisons.  */
1555 inline rvalue operator== (rvalue a, rvalue b)
1556 {
1557   return a.get_context ().new_eq (a, b);
1558 }
1559 inline rvalue operator!= (rvalue a, rvalue b)
1560 {
1561   return a.get_context ().new_ne (a, b);
1562 }
1563 inline rvalue operator< (rvalue a, rvalue b)
1564 {
1565   return a.get_context ().new_lt (a, b);
1566 }
1567 inline rvalue operator<= (rvalue a, rvalue b)
1568 {
1569   return a.get_context ().new_le (a, b);
1570 }
1571 inline rvalue operator> (rvalue a, rvalue b)
1572 {
1573   return a.get_context ().new_gt (a, b);
1574 }
1575 inline rvalue operator>= (rvalue a, rvalue b)
1576 {
1577   return a.get_context ().new_ge (a, b);
1578 }
1579
1580 /* Dereferencing. */
1581 inline lvalue operator* (rvalue ptr)
1582 {
1583   return ptr.dereference ();
1584 }
1585
1586 } // namespace gccjit
1587
1588 #endif /* #ifndef LIBGCCJIT_PLUS_PLUS_H */