gcc/jit/jit-recording.h

   1 /* Internals of libgccjit: classes for recording calls made to the JIT API.
   2    Copyright (C) 2013-2020 Free Software Foundation, Inc.
   3    Contributed by David Malcolm <dmalcolm@redhat.com>.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it
   8 under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 3, or (at your option)
  10 any later version.
  11
  12 GCC is distributed in the hope that it will be useful, but
  13 WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #ifndef JIT_RECORDING_H
  22 #define JIT_RECORDING_H
  23
  24 #include "jit-common.h"
  25 #include "jit-logging.h"
  26
  27 class timer;
  28
  29 namespace gcc {
  30
  31 namespace jit {
  32
  33 extern const char * const unary_op_reproducer_strings[];
  34 extern const char * const binary_op_reproducer_strings[];
  35
  36 class result;
  37 class dump;
  38 class reproducer;
  39
  40 /**********************************************************************
  41  Recording.
  42  **********************************************************************/
  43
  44 namespace recording {
  45
  46 playback::location *
  47 playback_location (replayer *r, location *loc);
  48
  49 const char *
  50 playback_string (string *str);
  51
  52 playback::block *
  53 playback_block (block *b);
  54
  55 /* A recording of a call to gcc_jit_context_enable_dump.  */
  56 struct requested_dump
  57 {
  58   const char *m_dumpname;
  59   char **m_out_ptr;
  60 };
  61
  62 /* A JIT-compilation context.  */
  63 class context : public log_user
  64 {
  65 public:
  66   context (context *parent_ctxt);
  67   ~context ();
  68
  69   builtins_manager *
  70   get_builtins_manager ();
  71
  72   void record (memento *m);
  73   void replay_into (replayer *r);
  74   void disassociate_from_playback ();
  75
  76   string *
  77   new_string (const char *text);
  78
  79   location *
  80   new_location (const char *filename,
  81                 int line,
  82                 int column,
  83                 bool created_by_user);
  84
  85   type *
  86   get_type (enum gcc_jit_types type);
  87
  88   type *
  89   get_int_type (int num_bytes, int is_signed);
  90
  91   type *
  92   new_array_type (location *loc,
  93                   type *element_type,
  94                   int num_elements);
  95
  96   field *
  97   new_field (location *loc,
  98              type *type,
  99              const char *name);
 100
 101   field *
 102   new_bitfield (location *loc,
 103                 type *type,
 104                 int width,
 105                 const char *name);
 106
 107   struct_ *
 108   new_struct_type (location *loc,
 109                    const char *name);
 110
 111   union_ *
 112   new_union_type (location *loc,
 113                   const char *name);
 114
 115   function_type *
 116   new_function_type (type *return_type,
 117                      int num_params,
 118                      type **param_types,
 119                      int is_variadic);
 120
 121   type *
 122   new_function_ptr_type (location *loc,
 123                          type *return_type,
 124                          int num_params,
 125                          type **param_types,
 126                          int is_variadic);
 127
 128   param *
 129   new_param (location *loc,
 130              type *type,
 131              const char *name);
 132
 133   function *
 134   new_function (location *loc,
 135                 enum gcc_jit_function_kind kind,
 136                 type *return_type,
 137                 const char *name,
 138                 int num_params,
 139                 param **params,
 140                 int is_variadic,
 141                 enum built_in_function builtin_id);
 142
 143   function *
 144   get_builtin_function (const char *name);
 145
 146   lvalue *
 147   new_global (location *loc,
 148               enum gcc_jit_global_kind kind,
 149               type *type,
 150               const char *name);
 151
 152   template <typename HOST_TYPE>
 153   rvalue *
 154   new_rvalue_from_const (type *type,
 155                          HOST_TYPE value);
 156
 157   rvalue *
 158   new_string_literal (const char *value);
 159
 160   rvalue *
 161   new_rvalue_from_vector (location *loc,
 162                           vector_type *type,
 163                           rvalue **elements);
 164
 165   rvalue *
 166   new_unary_op (location *loc,
 167                 enum gcc_jit_unary_op op,
 168                 type *result_type,
 169                 rvalue *a);
 170
 171   rvalue *
 172   new_binary_op (location *loc,
 173                  enum gcc_jit_binary_op op,
 174                  type *result_type,
 175                  rvalue *a, rvalue *b);
 176
 177   rvalue *
 178   new_comparison (location *loc,
 179                   enum gcc_jit_comparison op,
 180                   rvalue *a, rvalue *b);
 181
 182   rvalue *
 183   new_call (location *loc,
 184             function *func,
 185             int numargs, rvalue **args);
 186
 187   rvalue *
 188   new_call_through_ptr (location *loc,
 189                         rvalue *fn_ptr,
 190                         int numargs, rvalue **args);
 191
 192   rvalue *
 193   new_cast (location *loc,
 194             rvalue *expr,
 195             type *type_);
 196
 197   lvalue *
 198   new_array_access (location *loc,
 199                     rvalue *ptr,
 200                     rvalue *index);
 201
 202   case_ *
 203   new_case (rvalue *min_value,
 204             rvalue *max_value,
 205             block *block);
 206
 207   void
 208   set_str_option (enum gcc_jit_str_option opt,
 209                   const char *value);
 210
 211   void
 212   set_int_option (enum gcc_jit_int_option opt,
 213                   int value);
 214
 215   void
 216   set_bool_option (enum gcc_jit_bool_option opt,
 217                    int value);
 218
 219   void
 220   set_inner_bool_option (enum inner_bool_option inner_opt,
 221                          int value);
 222
 223   void
 224   add_command_line_option (const char *optname);
 225
 226   void
 227   append_command_line_options (vec <char *> *argvec);
 228
 229   void
 230   add_driver_option (const char *optname);
 231
 232   void
 233   append_driver_options (auto_string_vec *argvec);
 234
 235   void
 236   enable_dump (const char *dumpname,
 237                char **out_ptr);
 238
 239   const char *
 240   get_str_option (enum gcc_jit_str_option opt) const
 241   {
 242     return m_str_options[opt];
 243   }
 244
 245   int
 246   get_int_option (enum gcc_jit_int_option opt) const
 247   {
 248     return m_int_options[opt];
 249   }
 250
 251   int
 252   get_bool_option (enum gcc_jit_bool_option opt) const
 253   {
 254     return m_bool_options[opt];
 255   }
 256
 257   int
 258   get_inner_bool_option (enum inner_bool_option opt) const
 259   {
 260     return m_inner_bool_options[opt];
 261   }
 262
 263   result *
 264   compile ();
 265
 266   void
 267   compile_to_file (enum gcc_jit_output_kind output_kind,
 268                    const char *output_path);
 269
 270   void
 271   add_error (location *loc, const char *fmt, ...)
 272       GNU_PRINTF(3, 4);
 273
 274   void
 275   add_error_va (location *loc, const char *fmt, va_list ap)
 276       GNU_PRINTF(3, 0);
 277
 278   const char *
 279   get_first_error () const;
 280
 281   const char *
 282   get_last_error () const;
 283
 284   bool errors_occurred () const
 285   {
 286     if (m_parent_ctxt)
 287       if (m_parent_ctxt->errors_occurred ())
 288         return true;
 289     return m_error_count;
 290   }
 291
 292   type *get_opaque_FILE_type ();
 293
 294   void dump_to_file (const char *path, bool update_locations);
 295
 296   void dump_reproducer_to_file (const char *path);
 297
 298   void
 299   get_all_requested_dumps (vec <recording::requested_dump> *out);
 300
 301   void set_timer (timer *t) { m_timer = t; }
 302   timer *get_timer () const { return m_timer; }
 303
 304 private:
 305   void log_all_options () const;
 306   void log_str_option (enum gcc_jit_str_option opt) const;
 307   void log_int_option (enum gcc_jit_int_option opt) const;
 308   void log_bool_option (enum gcc_jit_bool_option opt) const;
 309   void log_inner_bool_option (enum inner_bool_option opt) const;
 310
 311   void validate ();
 312
 313 private:
 314   context *m_parent_ctxt;
 315
 316   /* The ultimate ancestor of the contexts within a family tree of
 317      contexts.  This has itself as its own m_toplevel_ctxt.  */
 318   context *m_toplevel_ctxt;
 319
 320   timer *m_timer;
 321
 322   int m_error_count;
 323
 324   char *m_first_error_str;
 325   bool m_owns_first_error_str;
 326
 327   char *m_last_error_str;
 328   bool m_owns_last_error_str;
 329
 330   char *m_str_options[GCC_JIT_NUM_STR_OPTIONS];
 331   int m_int_options[GCC_JIT_NUM_INT_OPTIONS];
 332   bool m_bool_options[GCC_JIT_NUM_BOOL_OPTIONS];
 333   bool m_inner_bool_options[NUM_INNER_BOOL_OPTIONS];
 334   auto_vec <char *> m_command_line_options;
 335   auto_vec <char *> m_driver_options;
 336
 337   /* Dumpfiles that were requested via gcc_jit_context_enable_dump.  */
 338   auto_vec<requested_dump> m_requested_dumps;
 339
 340   /* Recorded API usage.  */
 341   auto_vec<memento *> m_mementos;
 342
 343   /* Specific recordings, for use by dump_to_file.  */
 344   auto_vec<compound_type *> m_compound_types;
 345   auto_vec<global *> m_globals;
 346   auto_vec<function *> m_functions;
 347
 348   type *m_basic_types[NUM_GCC_JIT_TYPES];
 349   type *m_FILE_type;
 350
 351   builtins_manager *m_builtins_manager; // lazily created
 352 };
 353
 354
 355 /* An object with lifetime managed by the context i.e.
 356    it lives until the context is released, at which
 357    point it itself is cleaned up.  */
 358
 359 class memento
 360 {
 361 public:
 362   virtual ~memento () {}
 363
 364   /* Hook for replaying this.  */
 365   virtual void replay_into (replayer *r) = 0;
 366
 367   void set_playback_obj (void *obj) { m_playback_obj = obj; }
 368
 369
 370   /* Get the context that owns this object.
 371
 372      Implements the post-error-checking part of
 373      gcc_jit_object_get_context.  */
 374   context *get_context () { return m_ctxt; }
 375
 376   memento *
 377   as_object () { return this; }
 378
 379   /* Debugging hook, for use in generating error messages etc.
 380      Implements the post-error-checking part of
 381      gcc_jit_object_get_debug_string.  */
 382   const char *
 383   get_debug_string ();
 384
 385   virtual void write_to_dump (dump &d);
 386   virtual void write_reproducer (reproducer &r) = 0;
 387   virtual location *dyn_cast_location () { return NULL; }
 388
 389 protected:
 390   memento (context *ctxt)
 391   : m_ctxt (ctxt),
 392     m_playback_obj (NULL),
 393     m_debug_string (NULL)
 394   {
 395     gcc_assert (ctxt);
 396   }
 397
 398   string *new_string (const char *text) { return m_ctxt->new_string (text); }
 399
 400 private:
 401   virtual string * make_debug_string () = 0;
 402
 403 public:
 404   context *m_ctxt;
 405
 406 protected:
 407   void *m_playback_obj;
 408
 409 private:
 410   string *m_debug_string;
 411 };
 412
 413 /* or just use std::string? */
 414 class string : public memento
 415 {
 416 public:
 417   string (context *ctxt, const char *text);
 418   ~string ();
 419
 420   const char *c_str () { return m_buffer; }
 421
 422   static string * from_printf (context *ctxt, const char *fmt, ...)
 423     GNU_PRINTF(2, 3);
 424
 425   void replay_into (replayer *) FINAL OVERRIDE {}
 426
 427 private:
 428   string * make_debug_string () FINAL OVERRIDE;
 429   void write_reproducer (reproducer &r) FINAL OVERRIDE;
 430
 431 private:
 432   size_t m_len;
 433   char *m_buffer;
 434 };
 435
 436 class location : public memento
 437 {
 438 public:
 439   location (context *ctxt, string *filename, int line, int column,
 440             bool created_by_user)
 441   : memento (ctxt),
 442     m_filename (filename),
 443     m_line (line),
 444     m_column (column),
 445     m_created_by_user (created_by_user)
 446  {}
 447
 448   void replay_into (replayer *r) FINAL OVERRIDE;
 449
 450   playback::location *
 451   playback_location (replayer *r)
 452   {
 453     /* Normally during playback, we can walk forwards through the list of
 454        recording objects, playing them back.  The ordering of recording
 455        ensures that everything that a recording object refers to has
 456        already been played back, so we can simply look up the relevant
 457        m_playback_obj.
 458
 459        Locations are an exception, due to the "write_to_dump" method of
 460        recording::statement.  This method can set a new location on a
 461        statement after the statement is created, and thus the location
 462        appears in the context's memento list *after* the statement that
 463        refers to it.
 464
 465        In such circumstances, the statement is replayed *before* the location,
 466        when the latter doesn't yet have a playback object.
 467
 468        Hence we need to ensure that locations have playback objects.  */
 469     if (!m_playback_obj)
 470       {
 471         replay_into (r);
 472       }
 473     gcc_assert (m_playback_obj);
 474     return static_cast <playback::location *> (m_playback_obj);
 475   }
 476
 477   location *dyn_cast_location () FINAL OVERRIDE { return this; }
 478   bool created_by_user () const { return m_created_by_user; }
 479
 480 private:
 481   string * make_debug_string () FINAL OVERRIDE;
 482   void write_reproducer (reproducer &r) FINAL OVERRIDE;
 483
 484 private:
 485   string *m_filename;
 486   int m_line;
 487   int m_column;
 488   bool m_created_by_user;
 489 };
 490
 491 class type : public memento
 492 {
 493 public:
 494   type *get_pointer ();
 495   type *get_const ();
 496   type *get_volatile ();
 497   type *get_aligned (size_t alignment_in_bytes);
 498   type *get_vector (size_t num_units);
 499
 500   /* Get the type obtained when dereferencing this type.
 501
 502      This will return NULL if it's not valid to dereference this type.
 503      The caller is responsible for setting an error.  */
 504   virtual type *dereference () = 0;
 505
 506   /* Dynamic casts.  */
 507   virtual function_type *dyn_cast_function_type () { return NULL; }
 508   virtual function_type *as_a_function_type() { gcc_unreachable (); return NULL; }
 509   virtual struct_ *dyn_cast_struct () { return NULL; }
 510   virtual vector_type *dyn_cast_vector_type () { return NULL; }
 511
 512   /* Is it typesafe to copy to this type from rtype?  */
 513   virtual bool accepts_writes_from (type *rtype)
 514   {
 515     gcc_assert (rtype);
 516     return this->unqualified ()->is_same_type_as (rtype->unqualified ());
 517   }
 518
 519   virtual bool is_same_type_as (type *other)
 520   {
 521     return this == other;
 522   }
 523
 524   /* Strip off "const" etc */
 525   virtual type *unqualified ()
 526   {
 527     return this;
 528   }
 529
 530   virtual bool is_int () const = 0;
 531   virtual bool is_float () const = 0;
 532   virtual bool is_bool () const = 0;
 533   virtual type *is_pointer () = 0;
 534   virtual type *is_array () = 0;
 535   virtual bool is_void () const { return false; }
 536   virtual bool has_known_size () const { return true; }
 537
 538   bool is_numeric () const
 539   {
 540     return is_int () || is_float () || is_bool ();
 541   }
 542
 543   playback::type *
 544   playback_type ()
 545   {
 546     return static_cast <playback::type *> (m_playback_obj);
 547   }
 548
 549   virtual const char *access_as_type (reproducer &r);
 550
 551 protected:
 552   type (context *ctxt)
 553     : memento (ctxt),
 554     m_pointer_to_this_type (NULL)
 555   {}
 556
 557 private:
 558   type *m_pointer_to_this_type;
 559 };
 560
 561 /* Result of "gcc_jit_context_get_type".  */
 562 class memento_of_get_type : public type
 563 {
 564 public:
 565   memento_of_get_type (context *ctxt,
 566                        enum gcc_jit_types kind)
 567   : type (ctxt),
 568     m_kind (kind) {}
 569
 570   type *dereference () FINAL OVERRIDE;
 571
 572   bool accepts_writes_from (type *rtype) FINAL OVERRIDE
 573   {
 574     if (m_kind == GCC_JIT_TYPE_VOID_PTR)
 575       if (rtype->is_pointer ())
 576         {
 577           /* LHS (this) is type (void *), and the RHS is a pointer:
 578              accept it:  */
 579           return true;
 580         }
 581
 582     return type::accepts_writes_from (rtype);
 583   }
 584
 585   bool is_int () const FINAL OVERRIDE;
 586   bool is_float () const FINAL OVERRIDE;
 587   bool is_bool () const FINAL OVERRIDE;
 588   type *is_pointer () FINAL OVERRIDE { return dereference (); }
 589   type *is_array () FINAL OVERRIDE { return NULL; }
 590   bool is_void () const FINAL OVERRIDE { return m_kind == GCC_JIT_TYPE_VOID; }
 591
 592 public:
 593   void replay_into (replayer *r) FINAL OVERRIDE;
 594
 595 private:
 596   string * make_debug_string () FINAL OVERRIDE;
 597   void write_reproducer (reproducer &r) FINAL OVERRIDE;
 598
 599 private:
 600   enum gcc_jit_types m_kind;
 601 };
 602
 603 /* Result of "gcc_jit_type_get_pointer".  */
 604 class memento_of_get_pointer : public type
 605 {
 606 public:
 607   memento_of_get_pointer (type *other_type)
 608   : type (other_type->m_ctxt),
 609     m_other_type (other_type) {}
 610
 611   type *dereference () FINAL OVERRIDE { return m_other_type; }
 612
 613   bool accepts_writes_from (type *rtype) FINAL OVERRIDE;
 614
 615   void replay_into (replayer *r) FINAL OVERRIDE;
 616
 617   bool is_int () const FINAL OVERRIDE { return false; }
 618   bool is_float () const FINAL OVERRIDE { return false; }
 619   bool is_bool () const FINAL OVERRIDE { return false; }
 620   type *is_pointer () FINAL OVERRIDE { return m_other_type; }
 621   type *is_array () FINAL OVERRIDE { return NULL; }
 622
 623 private:
 624   string * make_debug_string () FINAL OVERRIDE;
 625   void write_reproducer (reproducer &r) FINAL OVERRIDE;
 626
 627 private:
 628   type *m_other_type;
 629 };
 630
 631 /* A decorated version of a type, for get_const, get_volatile,
 632    get_aligned, and get_vector.  */
 633
 634 class decorated_type : public type
 635 {
 636 public:
 637   decorated_type (type *other_type)
 638   : type (other_type->m_ctxt),
 639     m_other_type (other_type) {}
 640
 641   type *dereference () FINAL OVERRIDE { return m_other_type->dereference (); }
 642
 643   bool is_int () const FINAL OVERRIDE { return m_other_type->is_int (); }
 644   bool is_float () const FINAL OVERRIDE { return m_other_type->is_float (); }
 645   bool is_bool () const FINAL OVERRIDE { return m_other_type->is_bool (); }
 646   type *is_pointer () FINAL OVERRIDE { return m_other_type->is_pointer (); }
 647   type *is_array () FINAL OVERRIDE { return m_other_type->is_array (); }
 648
 649 protected:
 650   type *m_other_type;
 651 };
 652
 653 /* Result of "gcc_jit_type_get_const".  */
 654 class memento_of_get_const : public decorated_type
 655 {
 656 public:
 657   memento_of_get_const (type *other_type)
 658   : decorated_type (other_type) {}
 659
 660   bool accepts_writes_from (type */*rtype*/) FINAL OVERRIDE
 661   {
 662     /* Can't write to a "const".  */
 663     return false;
 664   }
 665
 666   /* Strip off the "const", giving the underlying type.  */
 667   type *unqualified () FINAL OVERRIDE { return m_other_type; }
 668
 669   void replay_into (replayer *) FINAL OVERRIDE;
 670
 671 private:
 672   string * make_debug_string () FINAL OVERRIDE;
 673   void write_reproducer (reproducer &r) FINAL OVERRIDE;
 674 };
 675
 676 /* Result of "gcc_jit_type_get_volatile".  */
 677 class memento_of_get_volatile : public decorated_type
 678 {
 679 public:
 680   memento_of_get_volatile (type *other_type)
 681   : decorated_type (other_type) {}
 682
 683   /* Strip off the "volatile", giving the underlying type.  */
 684   type *unqualified () FINAL OVERRIDE { return m_other_type; }
 685
 686   void replay_into (replayer *) FINAL OVERRIDE;
 687
 688 private:
 689   string * make_debug_string () FINAL OVERRIDE;
 690   void write_reproducer (reproducer &r) FINAL OVERRIDE;
 691 };
 692
 693 /* Result of "gcc_jit_type_get_aligned".  */
 694 class memento_of_get_aligned : public decorated_type
 695 {
 696 public:
 697   memento_of_get_aligned (type *other_type, size_t alignment_in_bytes)
 698   : decorated_type (other_type),
 699     m_alignment_in_bytes (alignment_in_bytes) {}
 700
 701   /* Strip off the alignment, giving the underlying type.  */
 702   type *unqualified () FINAL OVERRIDE { return m_other_type; }
 703
 704   void replay_into (replayer *) FINAL OVERRIDE;
 705
 706 private:
 707   string * make_debug_string () FINAL OVERRIDE;
 708   void write_reproducer (reproducer &r) FINAL OVERRIDE;
 709
 710 private:
 711   size_t m_alignment_in_bytes;
 712 };
 713
 714 /* Result of "gcc_jit_type_get_vector".  */
 715 class vector_type : public decorated_type
 716 {
 717 public:
 718   vector_type (type *other_type, size_t num_units)
 719   : decorated_type (other_type),
 720     m_num_units (num_units) {}
 721
 722   size_t get_num_units () const { return m_num_units; }
 723
 724   vector_type *dyn_cast_vector_type () FINAL OVERRIDE { return this; }
 725
 726   type *get_element_type () { return m_other_type; }
 727
 728   void replay_into (replayer *) FINAL OVERRIDE;
 729
 730 private:
 731   string * make_debug_string () FINAL OVERRIDE;
 732   void write_reproducer (reproducer &r) FINAL OVERRIDE;
 733
 734 private:
 735   size_t m_num_units;
 736 };
 737
 738 class array_type : public type
 739 {
 740  public:
 741   array_type (context *ctxt,
 742               location *loc,
 743               type *element_type,
 744               int num_elements)
 745   : type (ctxt),
 746     m_loc (loc),
 747     m_element_type (element_type),
 748     m_num_elements (num_elements)
 749   {}
 750
 751   type *dereference () FINAL OVERRIDE;
 752
 753   bool is_int () const FINAL OVERRIDE { return false; }
 754   bool is_float () const FINAL OVERRIDE { return false; }
 755   bool is_bool () const FINAL OVERRIDE { return false; }
 756   type *is_pointer () FINAL OVERRIDE { return NULL; }
 757   type *is_array () FINAL OVERRIDE { return m_element_type; }
 758
 759   void replay_into (replayer *) FINAL OVERRIDE;
 760
 761  private:
 762   string * make_debug_string () FINAL OVERRIDE;
 763   void write_reproducer (reproducer &r) FINAL OVERRIDE;
 764
 765  private:
 766   location *m_loc;
 767   type *m_element_type;
 768   int m_num_elements;
 769 };
 770
 771 class function_type : public type
 772 {
 773 public:
 774   function_type (context *ctxt,
 775                  type *return_type,
 776                  int num_params,
 777                  type **param_types,
 778                  int is_variadic);
 779
 780   type *dereference () FINAL OVERRIDE;
 781   function_type *dyn_cast_function_type () FINAL OVERRIDE { return this; }
 782   function_type *as_a_function_type () FINAL OVERRIDE { return this; }
 783
 784   bool is_same_type_as (type *other) FINAL OVERRIDE;
 785
 786   bool is_int () const FINAL OVERRIDE { return false; }
 787   bool is_float () const FINAL OVERRIDE { return false; }
 788   bool is_bool () const FINAL OVERRIDE { return false; }
 789   type *is_pointer () FINAL OVERRIDE { return NULL; }
 790   type *is_array () FINAL OVERRIDE { return NULL; }
 791
 792   void replay_into (replayer *) FINAL OVERRIDE;
 793
 794   type * get_return_type () const { return m_return_type; }
 795   const vec<type *> &get_param_types () const { return m_param_types; }
 796   int is_variadic () const { return m_is_variadic; }
 797
 798   string * make_debug_string_with_ptr ();
 799
 800   void
 801   write_deferred_reproducer (reproducer &r,
 802                              memento *ptr_type);
 803
 804  private:
 805   string * make_debug_string () FINAL OVERRIDE;
 806   string * make_debug_string_with (const char *);
 807   void write_reproducer (reproducer &r) FINAL OVERRIDE;
 808
 809 private:
 810   type *m_return_type;
 811   auto_vec<type *> m_param_types;
 812   int m_is_variadic;
 813 };
 814
 815 class field : public memento
 816 {
 817 public:
 818   field (context *ctxt,
 819          location *loc,
 820          type *type,
 821          string *name)
 822   : memento (ctxt),
 823     m_loc (loc),
 824     m_type (type),
 825     m_name (name),
 826     m_container (NULL)
 827   {}
 828
 829   type * get_type () const { return m_type; }
 830
 831   compound_type * get_container () const { return m_container; }
 832   void set_container (compound_type *c) { m_container = c; }
 833
 834   void replay_into (replayer *) OVERRIDE;
 835
 836   void write_to_dump (dump &d) OVERRIDE;
 837
 838   playback::field *
 839   playback_field () const
 840   {
 841     return static_cast <playback::field *> (m_playback_obj);
 842   }
 843
 844 private:
 845   string * make_debug_string () OVERRIDE;
 846   void write_reproducer (reproducer &r) OVERRIDE;
 847
 848 protected:
 849   location *m_loc;
 850   type *m_type;
 851   string *m_name;
 852   compound_type *m_container;
 853 };
 854
 855
 856 class bitfield : public field
 857 {
 858 public:
 859   bitfield (context *ctxt,
 860             location *loc,
 861             type *type,
 862             int width,
 863             string *name)
 864     : field (ctxt, loc, type, name),
 865       m_width (width)
 866   {}
 867
 868   void replay_into (replayer *) FINAL OVERRIDE;
 869
 870   void write_to_dump (dump &d) FINAL OVERRIDE;
 871
 872 private:
 873   string * make_debug_string () FINAL OVERRIDE;
 874   void write_reproducer (reproducer &r) FINAL OVERRIDE;
 875
 876 private:
 877   int m_width;
 878 };
 879
 880 /* Base class for struct_ and union_ */
 881 class compound_type : public type
 882 {
 883 public:
 884   compound_type (context *ctxt,
 885                  location *loc,
 886                  string *name);
 887
 888   string *get_name () const { return m_name; }
 889   location *get_loc () const { return m_loc; }
 890   fields * get_fields () { return m_fields; }
 891
 892   void
 893   set_fields (location *loc,
 894               int num_fields,
 895               field **fields);
 896
 897   type *dereference () FINAL OVERRIDE;
 898
 899   bool is_int () const FINAL OVERRIDE { return false; }
 900   bool is_float () const FINAL OVERRIDE { return false; }
 901   bool is_bool () const FINAL OVERRIDE { return false; }
 902   type *is_pointer () FINAL OVERRIDE { return NULL; }
 903   type *is_array () FINAL OVERRIDE { return NULL; }
 904
 905   bool has_known_size () const FINAL OVERRIDE { return m_fields != NULL; }
 906
 907   playback::compound_type *
 908   playback_compound_type ()
 909   {
 910     return static_cast <playback::compound_type *> (m_playback_obj);
 911   }
 912
 913 private:
 914   location *m_loc;
 915   string *m_name;
 916   fields *m_fields;
 917 };
 918
 919 class struct_ : public compound_type
 920 {
 921 public:
 922   struct_ (context *ctxt,
 923            location *loc,
 924            string *name);
 925
 926   struct_ *dyn_cast_struct () FINAL OVERRIDE { return this; }
 927
 928   type *
 929   as_type () { return this; }
 930
 931   void replay_into (replayer *r) FINAL OVERRIDE;
 932
 933   const char *access_as_type (reproducer &r) FINAL OVERRIDE;
 934
 935 private:
 936   string * make_debug_string () FINAL OVERRIDE;
 937   void write_reproducer (reproducer &r) FINAL OVERRIDE;
 938 };
 939
 940 // memento of struct_::set_fields
 941 class fields : public memento
 942 {
 943 public:
 944   fields (compound_type *struct_or_union,
 945           int num_fields,
 946           field **fields);
 947
 948   void replay_into (replayer *r) FINAL OVERRIDE;
 949
 950   void write_to_dump (dump &d) FINAL OVERRIDE;
 951
 952   int length () const { return m_fields.length (); }
 953   field *get_field (int i) const { return m_fields[i]; }
 954
 955 private:
 956   string * make_debug_string () FINAL OVERRIDE;
 957   void write_reproducer (reproducer &r) FINAL OVERRIDE;
 958
 959 private:
 960   compound_type *m_struct_or_union;
 961   auto_vec<field *> m_fields;
 962 };
 963
 964 class union_ : public compound_type
 965 {
 966 public:
 967   union_ (context *ctxt,
 968           location *loc,
 969           string *name);
 970
 971   void replay_into (replayer *r) FINAL OVERRIDE;
 972
 973 private:
 974   string * make_debug_string () FINAL OVERRIDE;
 975   void write_reproducer (reproducer &r) FINAL OVERRIDE;
 976 };
 977
 978 /* An abstract base class for operations that visit all rvalues within an
 979    expression tree.
 980    Currently the only implementation is class rvalue_usage_validator within
 981    jit-recording.c.  */
 982
 983 class rvalue_visitor
 984 {
 985  public:
 986   virtual ~rvalue_visitor () {}
 987   virtual void visit (rvalue *rvalue) = 0;
 988 };
 989
 990 /* When generating debug strings for rvalues we mimic C, so we need to
 991    mimic C's precedence levels when handling compound expressions.
 992    These are in order from strongest precedence to weakest.  */
 993 enum precedence
 994 {
 995   PRECEDENCE_PRIMARY,
 996   PRECEDENCE_POSTFIX,
 997   PRECEDENCE_UNARY,
 998   PRECEDENCE_CAST,
 999   PRECEDENCE_MULTIPLICATIVE,
1000   PRECEDENCE_ADDITIVE,
1001   PRECEDENCE_SHIFT,
1002   PRECEDENCE_RELATIONAL,
1003   PRECEDENCE_EQUALITY,
1004   PRECEDENCE_BITWISE_AND,
1005   PRECEDENCE_BITWISE_XOR,
1006   PRECEDENCE_BITWISE_IOR,
1007   PRECEDENCE_LOGICAL_AND,
1008   PRECEDENCE_LOGICAL_OR
1009 };
1010
1011 class rvalue : public memento
1012 {
1013 public:
1014   rvalue (context *ctxt,
1015           location *loc,
1016           type *type_)
1017   : memento (ctxt),
1018     m_loc (loc),
1019     m_type (type_),
1020     m_scope (NULL),
1021     m_parenthesized_string (NULL)
1022   {
1023     gcc_assert (type_);
1024   }
1025
1026   location * get_loc () const { return m_loc; }
1027
1028   /* Get the recording::type of this rvalue.
1029
1030      Implements the post-error-checking part of
1031      gcc_jit_rvalue_get_type.  */
1032   type * get_type () const { return m_type; }
1033
1034   playback::rvalue *
1035   playback_rvalue () const
1036   {
1037     return static_cast <playback::rvalue *> (m_playback_obj);
1038   }
1039   rvalue *
1040   access_field (location *loc,
1041                 field *field);
1042
1043   lvalue *
1044   dereference_field (location *loc,
1045                      field *field);
1046
1047   lvalue *
1048   dereference (location *loc);
1049
1050   void
1051   verify_valid_within_stmt (const char *api_funcname, statement *s);
1052
1053   virtual void visit_children (rvalue_visitor *v) = 0;
1054
1055   void set_scope (function *scope);
1056   function *get_scope () const { return m_scope; }
1057
1058   /* Dynamic casts.  */
1059   virtual param *dyn_cast_param () { return NULL; }
1060   virtual base_call *dyn_cast_base_call () { return NULL; }
1061
1062   virtual const char *access_as_rvalue (reproducer &r);
1063
1064   /* Get the debug string, wrapped in parentheses.  */
1065   const char *
1066   get_debug_string_parens (enum precedence outer_prec);
1067
1068   virtual bool is_constant () const { return false; }
1069   virtual bool get_wide_int (wide_int *) const { return false; }
1070
1071 private:
1072   virtual enum precedence get_precedence () const = 0;
1073
1074 protected:
1075   location *m_loc;
1076   type *m_type;
1077
1078  private:
1079   function *m_scope; /* NULL for globals, non-NULL for locals/params */
1080   string *m_parenthesized_string;
1081 };
1082
1083 class lvalue : public rvalue
1084 {
1085 public:
1086   lvalue (context *ctxt,
1087           location *loc,
1088           type *type_)
1089     : rvalue (ctxt, loc, type_)
1090     {}
1091
1092   playback::lvalue *
1093   playback_lvalue () const
1094   {
1095     return static_cast <playback::lvalue *> (m_playback_obj);
1096   }
1097
1098   lvalue *
1099   access_field (location *loc,
1100                 field *field);
1101
1102   rvalue *
1103   get_address (location *loc);
1104
1105   rvalue *
1106   as_rvalue () { return this; }
1107
1108   const char *access_as_rvalue (reproducer &r) OVERRIDE;
1109   virtual const char *access_as_lvalue (reproducer &r);
1110 };
1111
1112 class param : public lvalue
1113 {
1114 public:
1115   param (context *ctxt,
1116          location *loc,
1117          type *type,
1118          string *name)
1119     : lvalue (ctxt, loc, type),
1120     m_name (name) {}
1121
1122   lvalue *
1123   as_lvalue () { return this; }
1124
1125   void replay_into (replayer *r) FINAL OVERRIDE;
1126
1127   void visit_children (rvalue_visitor *) FINAL OVERRIDE {}
1128
1129   playback::param *
1130   playback_param () const
1131   {
1132     return static_cast <playback::param *> (m_playback_obj);
1133   }
1134
1135   param *dyn_cast_param () FINAL OVERRIDE { return this; }
1136
1137   const char *access_as_rvalue (reproducer &r) FINAL OVERRIDE;
1138   const char *access_as_lvalue (reproducer &r) FINAL OVERRIDE;
1139
1140 private:
1141   string * make_debug_string () FINAL OVERRIDE { return m_name; }
1142   void write_reproducer (reproducer &r) FINAL OVERRIDE;
1143   enum precedence get_precedence () const FINAL OVERRIDE
1144   {
1145     return PRECEDENCE_PRIMARY;
1146   }
1147
1148 private:
1149   string *m_name;
1150 };
1151
1152 class function : public memento
1153 {
1154 public:
1155   function (context *ctxt,
1156             location *loc,
1157             enum gcc_jit_function_kind kind,
1158             type *return_type,
1159             string *name,
1160             int num_params,
1161             param **params,
1162             int is_variadic,
1163             enum built_in_function builtin_id);
1164
1165   void replay_into (replayer *r) FINAL OVERRIDE;
1166
1167   playback::function *
1168   playback_function () const
1169   {
1170     return static_cast <playback::function *> (m_playback_obj);
1171   }
1172
1173   enum gcc_jit_function_kind get_kind () const { return m_kind; }
1174
1175   lvalue *
1176   new_local (location *loc,
1177              type *type,
1178              const char *name);
1179
1180   block*
1181   new_block (const char *name);
1182
1183   location *get_loc () const { return m_loc; }
1184   type *get_return_type () const { return m_return_type; }
1185   string * get_name () const { return m_name; }
1186   const vec<param *> &get_params () const { return m_params; }
1187
1188   /* Get the given param by index.
1189      Implements the post-error-checking part of
1190      gcc_jit_function_get_param.  */
1191   param *get_param (int i) const { return m_params[i]; }
1192
1193   bool is_variadic () const { return m_is_variadic; }
1194
1195   void write_to_dump (dump &d) FINAL OVERRIDE;
1196
1197   void validate ();
1198
1199   void dump_to_dot (const char *path);
1200
1201   rvalue *get_address (location *loc);
1202
1203 private:
1204   string * make_debug_string () FINAL OVERRIDE;
1205   void write_reproducer (reproducer &r) FINAL OVERRIDE;
1206
1207 private:
1208   location *m_loc;
1209   enum gcc_jit_function_kind m_kind;
1210   type *m_return_type;
1211   string *m_name;
1212   auto_vec<param *> m_params;
1213   int m_is_variadic;
1214   enum built_in_function m_builtin_id;
1215   auto_vec<local *> m_locals;
1216   auto_vec<block *> m_blocks;
1217   type *m_fn_ptr_type;
1218 };
1219
1220 class block : public memento
1221 {
1222 public:
1223   block (function *func, int index, string *name)
1224   : memento (func->m_ctxt),
1225     m_func (func),
1226     m_index (index),
1227     m_name (name),
1228     m_statements (),
1229     m_has_been_terminated (false),
1230     m_is_reachable (false)
1231   {
1232   }
1233
1234   /* Get the recording::function containing this block.
1235      Implements the post-error-checking part of
1236      gcc_jit_block_get_function.  */
1237   function *get_function () { return m_func; }
1238
1239   bool has_been_terminated () { return m_has_been_terminated; }
1240   bool is_reachable () { return m_is_reachable; }
1241
1242   statement *
1243   add_eval (location *loc,
1244             rvalue *rvalue);
1245
1246   statement *
1247   add_assignment (location *loc,
1248                   lvalue *lvalue,
1249                   rvalue *rvalue);
1250
1251   statement *
1252   add_assignment_op (location *loc,
1253                      lvalue *lvalue,
1254                      enum gcc_jit_binary_op op,
1255                      rvalue *rvalue);
1256
1257   statement *
1258   add_comment (location *loc,
1259                const char *text);
1260
1261   statement *
1262   end_with_conditional (location *loc,
1263                         rvalue *boolval,
1264                         block *on_true,
1265                         block *on_false);
1266
1267   statement *
1268   end_with_jump (location *loc,
1269                  block *target);
1270
1271   statement *
1272   end_with_return (location *loc,
1273                    rvalue *rvalue);
1274
1275   statement *
1276   end_with_switch (location *loc,
1277                    rvalue *expr,
1278                    block *default_block,
1279                    int num_cases,
1280                    case_ **cases);
1281
1282   playback::block *
1283   playback_block () const
1284   {
1285     return static_cast <playback::block *> (m_playback_obj);
1286   }
1287
1288   void write_to_dump (dump &d) FINAL OVERRIDE;
1289
1290   bool validate ();
1291
1292   location *get_loc () const;
1293
1294   statement *get_first_statement () const;
1295   statement *get_last_statement () const;
1296
1297   vec <block *> get_successor_blocks () const;
1298
1299 private:
1300   string * make_debug_string () FINAL OVERRIDE;
1301   void write_reproducer (reproducer &r) FINAL OVERRIDE;
1302
1303   void replay_into (replayer *r) FINAL OVERRIDE;
1304
1305   void dump_to_dot (pretty_printer *pp);
1306   void dump_edges_to_dot (pretty_printer *pp);
1307
1308 private:
1309   function *m_func;
1310   int m_index;
1311   string *m_name;
1312   auto_vec<statement *> m_statements;
1313   bool m_has_been_terminated;
1314   bool m_is_reachable;
1315
1316   friend class function;
1317 };
1318
1319 class global : public lvalue
1320 {
1321 public:
1322   global (context *ctxt,
1323           location *loc,
1324           enum gcc_jit_global_kind kind,
1325           type *type,
1326           string *name)
1327   : lvalue (ctxt, loc, type),
1328     m_kind (kind),
1329     m_name (name)
1330   {}
1331
1332   void replay_into (replayer *) FINAL OVERRIDE;
1333
1334   void visit_children (rvalue_visitor *) FINAL OVERRIDE {}
1335
1336   void write_to_dump (dump &d) FINAL OVERRIDE;
1337
1338 private:
1339   string * make_debug_string () FINAL OVERRIDE { return m_name; }
1340   void write_reproducer (reproducer &r) FINAL OVERRIDE;
1341   enum precedence get_precedence () const FINAL OVERRIDE
1342   {
1343     return PRECEDENCE_PRIMARY;
1344   }
1345
1346 private:
1347   enum gcc_jit_global_kind m_kind;
1348   string *m_name;
1349 };
1350
1351 template <typename HOST_TYPE>
1352 class memento_of_new_rvalue_from_const : public rvalue
1353 {
1354 public:
1355   memento_of_new_rvalue_from_const (context *ctxt,
1356                                     location *loc,
1357                                     type *type,
1358                                     HOST_TYPE value)
1359   : rvalue (ctxt, loc, type),
1360     m_value (value) {}
1361
1362   void replay_into (replayer *r) FINAL OVERRIDE;
1363
1364   void visit_children (rvalue_visitor *) FINAL OVERRIDE {}
1365
1366   bool is_constant () const FINAL OVERRIDE { return true; }
1367
1368   bool get_wide_int (wide_int *out) const FINAL OVERRIDE;
1369
1370 private:
1371   string * make_debug_string () FINAL OVERRIDE;
1372   void write_reproducer (reproducer &r) FINAL OVERRIDE;
1373   enum precedence get_precedence () const FINAL OVERRIDE
1374   {
1375     return PRECEDENCE_PRIMARY;
1376   }
1377
1378 private:
1379   HOST_TYPE m_value;
1380 };
1381
1382 class memento_of_new_string_literal : public rvalue
1383 {
1384 public:
1385   memento_of_new_string_literal (context *ctxt,
1386                                  location *loc,
1387                                  string *value)
1388   : rvalue (ctxt, loc, ctxt->get_type (GCC_JIT_TYPE_CONST_CHAR_PTR)),
1389     m_value (value) {}
1390
1391   void replay_into (replayer *r) FINAL OVERRIDE;
1392
1393   void visit_children (rvalue_visitor *) FINAL OVERRIDE {}
1394
1395 private:
1396   string * make_debug_string () FINAL OVERRIDE;
1397   void write_reproducer (reproducer &r) FINAL OVERRIDE;
1398   enum precedence get_precedence () const FINAL OVERRIDE
1399   {
1400     return PRECEDENCE_PRIMARY;
1401   }
1402
1403 private:
1404   string *m_value;
1405 };
1406
1407 class memento_of_new_rvalue_from_vector : public rvalue
1408 {
1409 public:
1410   memento_of_new_rvalue_from_vector (context *ctxt,
1411                                      location *loc,
1412                                      vector_type *type,
1413                                      rvalue **elements);
1414
1415   void replay_into (replayer *r) FINAL OVERRIDE;
1416
1417   void visit_children (rvalue_visitor *) FINAL OVERRIDE;
1418
1419 private:
1420   string * make_debug_string () FINAL OVERRIDE;
1421   void write_reproducer (reproducer &r) FINAL OVERRIDE;
1422   enum precedence get_precedence () const FINAL OVERRIDE
1423   {
1424     return PRECEDENCE_PRIMARY;
1425   }
1426
1427 private:
1428   vector_type *m_vector_type;
1429   auto_vec<rvalue *> m_elements;
1430 };
1431
1432 class unary_op : public rvalue
1433 {
1434 public:
1435   unary_op (context *ctxt,
1436             location *loc,
1437             enum gcc_jit_unary_op op,
1438             type *result_type,
1439             rvalue *a)
1440   : rvalue (ctxt, loc, result_type),
1441     m_op (op),
1442     m_a (a)
1443   {}
1444
1445   void replay_into (replayer *r) FINAL OVERRIDE;
1446
1447   void visit_children (rvalue_visitor *v) FINAL OVERRIDE;
1448
1449 private:
1450   string * make_debug_string () FINAL OVERRIDE;
1451   void write_reproducer (reproducer &r) FINAL OVERRIDE;
1452   enum precedence get_precedence () const FINAL OVERRIDE
1453   {
1454     return PRECEDENCE_UNARY;
1455   }
1456
1457 private:
1458   enum gcc_jit_unary_op m_op;
1459   rvalue *m_a;
1460 };
1461
1462 class binary_op : public rvalue
1463 {
1464 public:
1465   binary_op (context *ctxt,
1466              location *loc,
1467              enum gcc_jit_binary_op op,
1468              type *result_type,
1469              rvalue *a, rvalue *b)
1470   : rvalue (ctxt, loc, result_type),
1471     m_op (op),
1472     m_a (a),
1473     m_b (b) {}
1474
1475   void replay_into (replayer *r) FINAL OVERRIDE;
1476
1477   void visit_children (rvalue_visitor *v) FINAL OVERRIDE;
1478
1479 private:
1480   string * make_debug_string () FINAL OVERRIDE;
1481   void write_reproducer (reproducer &r) FINAL OVERRIDE;
1482   enum precedence get_precedence () const FINAL OVERRIDE;
1483
1484 private:
1485   enum gcc_jit_binary_op m_op;
1486   rvalue *m_a;
1487   rvalue *m_b;
1488 };
1489
1490 class comparison : public rvalue
1491 {
1492 public:
1493   comparison (context *ctxt,
1494               location *loc,
1495               enum gcc_jit_comparison op,
1496               rvalue *a, rvalue *b)
1497   : rvalue (ctxt, loc, ctxt->get_type (GCC_JIT_TYPE_BOOL)),
1498     m_op (op),
1499     m_a (a),
1500     m_b (b)
1501   {}
1502
1503   void replay_into (replayer *r) FINAL OVERRIDE;
1504
1505   void visit_children (rvalue_visitor *v) FINAL OVERRIDE;
1506
1507 private:
1508   string * make_debug_string () FINAL OVERRIDE;
1509   void write_reproducer (reproducer &r) FINAL OVERRIDE;
1510   enum precedence get_precedence () const FINAL OVERRIDE;
1511
1512 private:
1513   enum gcc_jit_comparison m_op;
1514   rvalue *m_a;
1515   rvalue *m_b;
1516 };
1517
1518 class cast : public rvalue
1519 {
1520 public:
1521   cast (context *ctxt,
1522         location *loc,
1523         rvalue *a,
1524         type *type_)
1525   : rvalue (ctxt, loc, type_),
1526     m_rvalue (a)
1527   {}
1528
1529   void replay_into (replayer *r) FINAL OVERRIDE;
1530
1531   void visit_children (rvalue_visitor *v) FINAL OVERRIDE;
1532
1533 private:
1534   string * make_debug_string () FINAL OVERRIDE;
1535   void write_reproducer (reproducer &r) FINAL OVERRIDE;
1536   enum precedence get_precedence () const FINAL OVERRIDE
1537   {
1538     return PRECEDENCE_CAST;
1539   }
1540
1541 private:
1542   rvalue *m_rvalue;
1543 };
1544
1545 class base_call : public rvalue
1546 {
1547  public:
1548   base_call (context *ctxt,
1549              location *loc,
1550              type *type_,
1551              int numargs,
1552              rvalue **args);
1553
1554   enum precedence get_precedence () const FINAL OVERRIDE
1555   {
1556     return PRECEDENCE_POSTFIX;
1557   }
1558
1559   base_call *dyn_cast_base_call () FINAL OVERRIDE { return this; }
1560
1561   void set_require_tail_call (bool require_tail_call)
1562   {
1563     m_require_tail_call = require_tail_call;
1564   }
1565
1566  protected:
1567   void write_reproducer_tail_call (reproducer &r, const char *id);
1568
1569  protected:
1570   auto_vec<rvalue *> m_args;
1571   bool m_require_tail_call;
1572 };
1573
1574 class call : public base_call
1575 {
1576 public:
1577   call (context *ctxt,
1578         location *loc,
1579         function *func,
1580         int numargs,
1581         rvalue **args);
1582
1583   void replay_into (replayer *r) FINAL OVERRIDE;
1584
1585   void visit_children (rvalue_visitor *v) FINAL OVERRIDE;
1586
1587 private:
1588   string * make_debug_string () FINAL OVERRIDE;
1589   void write_reproducer (reproducer &r) FINAL OVERRIDE;
1590
1591 private:
1592   function *m_func;
1593 };
1594
1595 class call_through_ptr : public base_call
1596 {
1597 public:
1598   call_through_ptr (context *ctxt,
1599                     location *loc,
1600                     rvalue *fn_ptr,
1601                     int numargs,
1602                     rvalue **args);
1603
1604   void replay_into (replayer *r) FINAL OVERRIDE;
1605
1606   void visit_children (rvalue_visitor *v) FINAL OVERRIDE;
1607
1608 private:
1609   string * make_debug_string () FINAL OVERRIDE;
1610   void write_reproducer (reproducer &r) FINAL OVERRIDE;
1611
1612 private:
1613   rvalue *m_fn_ptr;
1614 };
1615
1616 class array_access : public lvalue
1617 {
1618 public:
1619   array_access (context *ctxt,
1620                 location *loc,
1621                 rvalue *ptr,
1622                 rvalue *index)
1623   : lvalue (ctxt, loc, ptr->get_type ()->dereference ()),
1624     m_ptr (ptr),
1625     m_index (index)
1626   {}
1627
1628   void replay_into (replayer *r) FINAL OVERRIDE;
1629
1630   void visit_children (rvalue_visitor *v) FINAL OVERRIDE;
1631
1632 private:
1633   string * make_debug_string () FINAL OVERRIDE;
1634   void write_reproducer (reproducer &r) FINAL OVERRIDE;
1635   enum precedence get_precedence () const FINAL OVERRIDE
1636   {
1637     return PRECEDENCE_POSTFIX;
1638   }
1639
1640 private:
1641   rvalue *m_ptr;
1642   rvalue *m_index;
1643 };
1644
1645 class access_field_of_lvalue : public lvalue
1646 {
1647 public:
1648   access_field_of_lvalue (context *ctxt,
1649                           location *loc,
1650                           lvalue *val,
1651                           field *field)
1652   : lvalue (ctxt, loc, field->get_type ()),
1653     m_lvalue (val),
1654     m_field (field)
1655   {}
1656
1657   void replay_into (replayer *r) FINAL OVERRIDE;
1658
1659   void visit_children (rvalue_visitor *v) FINAL OVERRIDE;
1660
1661 private:
1662   string * make_debug_string () FINAL OVERRIDE;
1663   void write_reproducer (reproducer &r) FINAL OVERRIDE;
1664   enum precedence get_precedence () const FINAL OVERRIDE
1665   {
1666     return PRECEDENCE_POSTFIX;
1667   }
1668
1669 private:
1670   lvalue *m_lvalue;
1671   field *m_field;
1672 };
1673
1674 class access_field_rvalue : public rvalue
1675 {
1676 public:
1677   access_field_rvalue (context *ctxt,
1678                        location *loc,
1679                        rvalue *val,
1680                        field *field)
1681   : rvalue (ctxt, loc, field->get_type ()),
1682     m_rvalue (val),
1683     m_field (field)
1684   {}
1685
1686   void replay_into (replayer *r) FINAL OVERRIDE;
1687
1688   void visit_children (rvalue_visitor *v) FINAL OVERRIDE;
1689
1690 private:
1691   string * make_debug_string () FINAL OVERRIDE;
1692   void write_reproducer (reproducer &r) FINAL OVERRIDE;
1693   enum precedence get_precedence () const FINAL OVERRIDE
1694   {
1695     return PRECEDENCE_POSTFIX;
1696   }
1697
1698 private:
1699   rvalue *m_rvalue;
1700   field *m_field;
1701 };
1702
1703 class dereference_field_rvalue : public lvalue
1704 {
1705 public:
1706   dereference_field_rvalue (context *ctxt,
1707                             location *loc,
1708                             rvalue *val,
1709                             field *field)
1710   : lvalue (ctxt, loc, field->get_type ()),
1711     m_rvalue (val),
1712     m_field (field)
1713   {}
1714
1715   void replay_into (replayer *r) FINAL OVERRIDE;
1716
1717   void visit_children (rvalue_visitor *v) FINAL OVERRIDE;
1718
1719 private:
1720   string * make_debug_string () FINAL OVERRIDE;
1721   void write_reproducer (reproducer &r) FINAL OVERRIDE;
1722   enum precedence get_precedence () const FINAL OVERRIDE
1723   {
1724     return PRECEDENCE_POSTFIX;
1725   }
1726
1727 private:
1728   rvalue *m_rvalue;
1729   field *m_field;
1730 };
1731
1732 class dereference_rvalue : public lvalue
1733 {
1734 public:
1735   dereference_rvalue (context *ctxt,
1736                       location *loc,
1737                       rvalue *val)
1738   : lvalue (ctxt, loc, val->get_type ()->dereference ()),
1739     m_rvalue (val) {}
1740
1741   void replay_into (replayer *r) FINAL OVERRIDE;
1742
1743   void visit_children (rvalue_visitor *v) FINAL OVERRIDE;
1744
1745 private:
1746   string * make_debug_string () FINAL OVERRIDE;
1747   void write_reproducer (reproducer &r) FINAL OVERRIDE;
1748   enum precedence get_precedence () const FINAL OVERRIDE
1749   {
1750     return PRECEDENCE_UNARY;
1751   }
1752
1753 private:
1754   rvalue *m_rvalue;
1755 };
1756
1757 class get_address_of_lvalue : public rvalue
1758 {
1759 public:
1760   get_address_of_lvalue (context *ctxt,
1761                          location *loc,
1762                          lvalue *val)
1763   : rvalue (ctxt, loc, val->get_type ()->get_pointer ()),
1764     m_lvalue (val)
1765   {}
1766
1767   void replay_into (replayer *r) FINAL OVERRIDE;
1768
1769   void visit_children (rvalue_visitor *v) FINAL OVERRIDE;
1770
1771 private:
1772   string * make_debug_string () FINAL OVERRIDE;
1773   void write_reproducer (reproducer &r) FINAL OVERRIDE;
1774   enum precedence get_precedence () const FINAL OVERRIDE
1775   {
1776     return PRECEDENCE_UNARY;
1777   }
1778
1779 private:
1780   lvalue *m_lvalue;
1781 };
1782
1783 class function_pointer : public rvalue
1784 {
1785 public:
1786   function_pointer (context *ctxt,
1787                     location *loc,
1788                     function *fn,
1789                     type *type)
1790   : rvalue (ctxt, loc, type),
1791     m_fn (fn) {}
1792
1793   void replay_into (replayer *r) FINAL OVERRIDE;
1794
1795   void visit_children (rvalue_visitor *v) FINAL OVERRIDE;
1796
1797 private:
1798   string * make_debug_string () FINAL OVERRIDE;
1799   void write_reproducer (reproducer &r) FINAL OVERRIDE;
1800   enum precedence get_precedence () const FINAL OVERRIDE
1801   {
1802     return PRECEDENCE_UNARY;
1803   }
1804
1805 private:
1806   function *m_fn;
1807 };
1808
1809 class local : public lvalue
1810 {
1811 public:
1812   local (function *func, location *loc, type *type_, string *name)
1813     : lvalue (func->m_ctxt, loc, type_),
1814     m_func (func),
1815     m_name (name)
1816   {
1817     set_scope (func);
1818   }
1819
1820   void replay_into (replayer *r) FINAL OVERRIDE;
1821
1822   void visit_children (rvalue_visitor *) FINAL OVERRIDE {}
1823
1824   void write_to_dump (dump &d) FINAL OVERRIDE;
1825
1826 private:
1827   string * make_debug_string () FINAL OVERRIDE { return m_name; }
1828   void write_reproducer (reproducer &r) FINAL OVERRIDE;
1829   enum precedence get_precedence () const FINAL OVERRIDE
1830   {
1831     return PRECEDENCE_PRIMARY;
1832   }
1833
1834 private:
1835   function *m_func;
1836   string *m_name;
1837 };
1838
1839 class statement : public memento
1840 {
1841 public:
1842   virtual vec <block *> get_successor_blocks () const;
1843
1844   void write_to_dump (dump &d) FINAL OVERRIDE;
1845
1846   block *get_block () const { return m_block; }
1847   location *get_loc () const { return m_loc; }
1848
1849 protected:
1850   statement (block *b, location *loc)
1851   : memento (b->m_ctxt),
1852     m_block (b),
1853     m_loc (loc) {}
1854
1855   playback::location *
1856   playback_location (replayer *r) const
1857   {
1858     return ::gcc::jit::recording::playback_location (r, m_loc);
1859   }
1860
1861 private:
1862   block *m_block;
1863   location *m_loc;
1864 };
1865
1866 class eval : public statement
1867 {
1868 public:
1869   eval (block *b,
1870         location *loc,
1871         rvalue *rvalue)
1872   : statement (b, loc),
1873     m_rvalue (rvalue) {}
1874
1875   void replay_into (replayer *r) FINAL OVERRIDE;
1876
1877 private:
1878   string * make_debug_string () FINAL OVERRIDE;
1879   void write_reproducer (reproducer &r) FINAL OVERRIDE;
1880
1881 private:
1882   rvalue *m_rvalue;
1883 };
1884
1885 class assignment : public statement
1886 {
1887 public:
1888   assignment (block *b,
1889               location *loc,
1890               lvalue *lvalue,
1891               rvalue *rvalue)
1892   : statement (b, loc),
1893     m_lvalue (lvalue),
1894     m_rvalue (rvalue) {}
1895
1896   void replay_into (replayer *r) FINAL OVERRIDE;
1897
1898 private:
1899   string * make_debug_string () FINAL OVERRIDE;
1900   void write_reproducer (reproducer &r) FINAL OVERRIDE;
1901
1902 private:
1903   lvalue *m_lvalue;
1904   rvalue *m_rvalue;
1905 };
1906
1907 class assignment_op : public statement
1908 {
1909 public:
1910   assignment_op (block *b,
1911                  location *loc,
1912                  lvalue *lvalue,
1913                  enum gcc_jit_binary_op op,
1914                  rvalue *rvalue)
1915   : statement (b, loc),
1916     m_lvalue (lvalue),
1917     m_op (op),
1918     m_rvalue (rvalue) {}
1919
1920   void replay_into (replayer *r) FINAL OVERRIDE;
1921
1922 private:
1923   string * make_debug_string () FINAL OVERRIDE;
1924   void write_reproducer (reproducer &r) FINAL OVERRIDE;
1925
1926 private:
1927   lvalue *m_lvalue;
1928   enum gcc_jit_binary_op m_op;
1929   rvalue *m_rvalue;
1930 };
1931
1932 class comment : public statement
1933 {
1934 public:
1935   comment (block *b,
1936            location *loc,
1937            string *text)
1938   : statement (b, loc),
1939     m_text (text) {}
1940
1941   void replay_into (replayer *r) FINAL OVERRIDE;
1942
1943 private:
1944   string * make_debug_string () FINAL OVERRIDE;
1945   void write_reproducer (reproducer &r) FINAL OVERRIDE;
1946
1947 private:
1948   string *m_text;
1949 };
1950
1951 class conditional : public statement
1952 {
1953 public:
1954   conditional (block *b,
1955                location *loc,
1956                rvalue *boolval,
1957                block *on_true,
1958                block *on_false)
1959   : statement (b, loc),
1960     m_boolval (boolval),
1961     m_on_true (on_true),
1962     m_on_false (on_false) {}
1963
1964   void replay_into (replayer *r) FINAL OVERRIDE;
1965
1966   vec <block *> get_successor_blocks () const FINAL OVERRIDE;
1967
1968 private:
1969   string * make_debug_string () FINAL OVERRIDE;
1970   void write_reproducer (reproducer &r) FINAL OVERRIDE;
1971
1972 private:
1973   rvalue *m_boolval;
1974   block *m_on_true;
1975   block *m_on_false;
1976 };
1977
1978 class jump : public statement
1979 {
1980 public:
1981   jump (block *b,
1982         location *loc,
1983         block *target)
1984   : statement (b, loc),
1985     m_target (target) {}
1986
1987   void replay_into (replayer *r) FINAL OVERRIDE;
1988
1989   vec <block *> get_successor_blocks () const FINAL OVERRIDE;
1990
1991 private:
1992   string * make_debug_string () FINAL OVERRIDE;
1993   void write_reproducer (reproducer &r) FINAL OVERRIDE;
1994
1995 private:
1996   block *m_target;
1997 };
1998
1999 class return_ : public statement
2000 {
2001 public:
2002   return_ (block *b,
2003            location *loc,
2004            rvalue *rvalue)
2005   : statement (b, loc),
2006     m_rvalue (rvalue) {}
2007
2008   void replay_into (replayer *r) FINAL OVERRIDE;
2009
2010   vec <block *> get_successor_blocks () const FINAL OVERRIDE;
2011
2012 private:
2013   string * make_debug_string () FINAL OVERRIDE;
2014   void write_reproducer (reproducer &r) FINAL OVERRIDE;
2015
2016 private:
2017   rvalue *m_rvalue;
2018 };
2019
2020 class case_ : public memento
2021 {
2022  public:
2023   case_ (context *ctxt,
2024          rvalue *min_value,
2025          rvalue *max_value,
2026          block *dest_block)
2027   : memento (ctxt),
2028     m_min_value (min_value),
2029     m_max_value (max_value),
2030     m_dest_block (dest_block)
2031   {}
2032
2033   rvalue *get_min_value () const { return m_min_value; }
2034   rvalue *get_max_value () const { return m_max_value; }
2035   block *get_dest_block () const { return m_dest_block; }
2036
2037   void replay_into (replayer *) FINAL OVERRIDE { /* empty */ }
2038
2039   void write_reproducer (reproducer &r) FINAL OVERRIDE;
2040
2041 private:
2042   string * make_debug_string () FINAL OVERRIDE;
2043
2044  private:
2045   rvalue *m_min_value;
2046   rvalue *m_max_value;
2047   block *m_dest_block;
2048 };
2049
2050 class switch_ : public statement
2051 {
2052 public:
2053   switch_ (block *b,
2054            location *loc,
2055            rvalue *expr,
2056            block *default_block,
2057            int num_cases,
2058            case_ **cases);
2059
2060   void replay_into (replayer *r) FINAL OVERRIDE;
2061
2062   vec <block *> get_successor_blocks () const FINAL OVERRIDE;
2063
2064 private:
2065   string * make_debug_string () FINAL OVERRIDE;
2066   void write_reproducer (reproducer &r) FINAL OVERRIDE;
2067
2068 private:
2069   rvalue *m_expr;
2070   block *m_default_block;
2071   auto_vec <case_ *> m_cases;
2072 };
2073
2074 } // namespace gcc::jit::recording
2075
2076 /* Create a recording::memento_of_new_rvalue_from_const instance and add
2077    it to this context's list of mementos.
2078
2079    Implements the post-error-checking part of
2080    gcc_jit_context_new_rvalue_from_{int|long|double|ptr}.  */
2081
2082 template <typename HOST_TYPE>
2083 recording::rvalue *
2084 recording::context::new_rvalue_from_const (recording::type *type,
2085                                            HOST_TYPE value)
2086 {
2087   recording::rvalue *result =
2088     new memento_of_new_rvalue_from_const <HOST_TYPE> (this, NULL, type, value);
2089   record (result);
2090   return result;
2091 }
2092
2093 } // namespace gcc::jit
2094
2095 } // namespace gcc
2096
2097 #endif /* JIT_RECORDING_H */