gcc/jit/jit-recording.h

   1 /* Internals of libgccjit: classes for recording calls made to the JIT API.
   2    Copyright (C) 2013-2015 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 namespace gcc {
  28
  29 namespace jit {
  30
  31 class result;
  32 class dump;
  33
  34 /**********************************************************************
  35  Recording.
  36  **********************************************************************/
  37
  38 namespace recording {
  39
  40 playback::location *
  41 playback_location (replayer *r, location *loc);
  42
  43 const char *
  44 playback_string (string *str);
  45
  46 playback::block *
  47 playback_block (block *b);
  48
  49 /* A recording of a call to gcc_jit_context_enable_dump.  */
  50 struct requested_dump
  51 {
  52   const char *m_dumpname;
  53   char **m_out_ptr;
  54 };
  55
  56 /* A JIT-compilation context.  */
  57 class context : public log_user
  58 {
  59 public:
  60   context (context *parent_ctxt);
  61   ~context ();
  62
  63   builtins_manager *
  64   get_builtins_manager ();
  65
  66   void record (memento *m);
  67   void replay_into (replayer *r);
  68   void disassociate_from_playback ();
  69
  70   string *
  71   new_string (const char *text);
  72
  73   location *
  74   new_location (const char *filename,
  75                 int line,
  76                 int column);
  77
  78   type *
  79   get_type (enum gcc_jit_types type);
  80
  81   type *
  82   get_int_type (int num_bytes, int is_signed);
  83
  84   type *
  85   new_array_type (location *loc,
  86                   type *element_type,
  87                   int num_elements);
  88
  89   field *
  90   new_field (location *loc,
  91              type *type,
  92              const char *name);
  93
  94   struct_ *
  95   new_struct_type (location *loc,
  96                    const char *name);
  97
  98   union_ *
  99   new_union_type (location *loc,
 100                   const char *name);
 101
 102   function_type *
 103   new_function_type (type *return_type,
 104                      int num_params,
 105                      type **param_types,
 106                      int is_variadic);
 107
 108   type *
 109   new_function_ptr_type (location *loc,
 110                          type *return_type,
 111                          int num_params,
 112                          type **param_types,
 113                          int is_variadic);
 114
 115   param *
 116   new_param (location *loc,
 117              type *type,
 118              const char *name);
 119
 120   function *
 121   new_function (location *loc,
 122                 enum gcc_jit_function_kind kind,
 123                 type *return_type,
 124                 const char *name,
 125                 int num_params,
 126                 param **params,
 127                 int is_variadic,
 128                 enum built_in_function builtin_id);
 129
 130   function *
 131   get_builtin_function (const char *name);
 132
 133   lvalue *
 134   new_global (location *loc,
 135               type *type,
 136               const char *name);
 137
 138   rvalue *
 139   new_rvalue_from_int (type *numeric_type,
 140                        int value);
 141
 142   rvalue *
 143   new_rvalue_from_double (type *numeric_type,
 144                           double value);
 145
 146   rvalue *
 147   new_rvalue_from_ptr (type *pointer_type,
 148                        void *value);
 149
 150   rvalue *
 151   new_string_literal (const char *value);
 152
 153   rvalue *
 154   new_unary_op (location *loc,
 155                 enum gcc_jit_unary_op op,
 156                 type *result_type,
 157                 rvalue *a);
 158
 159   rvalue *
 160   new_binary_op (location *loc,
 161                  enum gcc_jit_binary_op op,
 162                  type *result_type,
 163                  rvalue *a, rvalue *b);
 164
 165   rvalue *
 166   new_comparison (location *loc,
 167                   enum gcc_jit_comparison op,
 168                   rvalue *a, rvalue *b);
 169
 170   rvalue *
 171   new_call (location *loc,
 172             function *func,
 173             int numargs, rvalue **args);
 174
 175   rvalue *
 176   new_call_through_ptr (location *loc,
 177                         rvalue *fn_ptr,
 178                         int numargs, rvalue **args);
 179
 180   rvalue *
 181   new_cast (location *loc,
 182             rvalue *expr,
 183             type *type_);
 184
 185   lvalue *
 186   new_array_access (location *loc,
 187                     rvalue *ptr,
 188                     rvalue *index);
 189
 190   void
 191   set_str_option (enum gcc_jit_str_option opt,
 192                   const char *value);
 193
 194   void
 195   set_int_option (enum gcc_jit_int_option opt,
 196                   int value);
 197
 198   void
 199   set_bool_option (enum gcc_jit_bool_option opt,
 200                    int value);
 201
 202   void
 203   enable_dump (const char *dumpname,
 204                char **out_ptr);
 205
 206   const char *
 207   get_str_option (enum gcc_jit_str_option opt) const
 208   {
 209     return m_str_options[opt];
 210   }
 211
 212   int
 213   get_int_option (enum gcc_jit_int_option opt) const
 214   {
 215     return m_int_options[opt];
 216   }
 217
 218   int
 219   get_bool_option (enum gcc_jit_bool_option opt) const
 220   {
 221     return m_bool_options[opt];
 222   }
 223
 224   result *
 225   compile ();
 226
 227   void
 228   add_error (location *loc, const char *fmt, ...)
 229       GNU_PRINTF(3, 4);
 230
 231   void
 232   add_error_va (location *loc, const char *fmt, va_list ap)
 233       GNU_PRINTF(3, 0);
 234
 235   const char *
 236   get_first_error () const;
 237
 238   const char *
 239   get_last_error () const;
 240
 241   bool errors_occurred () const
 242   {
 243     if (m_parent_ctxt)
 244       if (m_parent_ctxt->errors_occurred ())
 245         return true;
 246     return m_error_count;
 247   }
 248
 249   type *get_opaque_FILE_type ();
 250
 251   void dump_to_file (const char *path, bool update_locations);
 252
 253   void
 254   get_all_requested_dumps (vec <recording::requested_dump> *out);
 255
 256 private:
 257   void validate ();
 258
 259 private:
 260   context *m_parent_ctxt;
 261
 262   int m_error_count;
 263
 264   char *m_first_error_str;
 265   bool m_owns_first_error_str;
 266
 267   char *m_last_error_str;
 268   bool m_owns_last_error_str;
 269
 270   char *m_str_options[GCC_JIT_NUM_STR_OPTIONS];
 271   int m_int_options[GCC_JIT_NUM_INT_OPTIONS];
 272   bool m_bool_options[GCC_JIT_NUM_BOOL_OPTIONS];
 273
 274   /* Dumpfiles that were requested via gcc_jit_context_enable_dump.  */
 275   auto_vec<requested_dump> m_requested_dumps;
 276
 277   /* Recorded API usage.  */
 278   auto_vec<memento *> m_mementos;
 279
 280   /* Specific recordings, for use by dump_to_file.  */
 281   auto_vec<compound_type *> m_compound_types;
 282   auto_vec<function *> m_functions;
 283
 284   type *m_basic_types[NUM_GCC_JIT_TYPES];
 285   type *m_FILE_type;
 286
 287   builtins_manager *m_builtins_manager; // lazily created
 288 };
 289
 290
 291 /* An object with lifetime managed by the context i.e.
 292    it lives until the context is released, at which
 293    point it itself is cleaned up.  */
 294
 295 class memento
 296 {
 297 public:
 298   virtual ~memento () {}
 299
 300   /* Hook for replaying this.  */
 301   virtual void replay_into (replayer *r) = 0;
 302
 303   void set_playback_obj (void *obj) { m_playback_obj = obj; }
 304
 305
 306   /* Get the context that owns this object.
 307
 308      Implements the post-error-checking part of
 309      gcc_jit_object_get_context.  */
 310   context *get_context () { return m_ctxt; }
 311
 312   memento *
 313   as_object () { return this; }
 314
 315   /* Debugging hook, for use in generating error messages etc.
 316      Implements the post-error-checking part of
 317      gcc_jit_object_get_debug_string.  */
 318   const char *
 319   get_debug_string ();
 320
 321   virtual void write_to_dump (dump &d);
 322
 323 protected:
 324   memento (context *ctxt)
 325   : m_ctxt (ctxt),
 326     m_playback_obj (NULL),
 327     m_debug_string (NULL)
 328   {
 329     gcc_assert (ctxt);
 330   }
 331
 332   string *new_string (const char *text) { return m_ctxt->new_string (text); }
 333
 334 private:
 335   virtual string * make_debug_string () = 0;
 336
 337 public:
 338   context *m_ctxt;
 339
 340 protected:
 341   void *m_playback_obj;
 342
 343 private:
 344   string *m_debug_string;
 345 };
 346
 347 /* or just use std::string? */
 348 class string : public memento
 349 {
 350 public:
 351   string (context *ctxt, const char *text);
 352   ~string ();
 353
 354   const char *c_str () { return m_buffer; }
 355
 356   static string * from_printf (context *ctxt, const char *fmt, ...)
 357     GNU_PRINTF(2, 3);
 358
 359   void replay_into (replayer *) {}
 360
 361 private:
 362   string * make_debug_string ();
 363
 364 private:
 365   size_t m_len;
 366   char *m_buffer;
 367 };
 368
 369 class location : public memento
 370 {
 371 public:
 372   location (context *ctxt, string *filename, int line, int column)
 373   : memento (ctxt),
 374     m_filename (filename),
 375     m_line (line),
 376     m_column (column)
 377  {}
 378
 379   void replay_into (replayer *r);
 380
 381   playback::location *
 382   playback_location (replayer *r)
 383   {
 384     /* Normally during playback, we can walk forwards through the list of
 385        recording objects, playing them back.  The ordering of recording
 386        ensures that everything that a recording object refers to has
 387        already been played back, so we can simply look up the relevant
 388        m_playback_obj.
 389
 390        Locations are an exception, due to the "write_to_dump" method of
 391        recording::statement.  This method can set a new location on a
 392        statement after the statement is created, and thus the location
 393        appears in the context's memento list *after* the statement that
 394        refers to it.
 395
 396        In such circumstances, the statement is replayed *before* the location,
 397        when the latter doesn't yet have a playback object.
 398
 399        Hence we need to ensure that locations have playback objects.  */
 400     if (!m_playback_obj)
 401       {
 402         replay_into (r);
 403       }
 404     gcc_assert (m_playback_obj);
 405     return static_cast <playback::location *> (m_playback_obj);
 406   }
 407
 408 private:
 409   string * make_debug_string ();
 410
 411 private:
 412   string *m_filename;
 413   int m_line;
 414   int m_column;
 415 };
 416
 417 class type : public memento
 418 {
 419 public:
 420   type *get_pointer ();
 421   type *get_const ();
 422   type *get_volatile ();
 423
 424   /* Get the type obtained when dereferencing this type.
 425
 426      This will return NULL if it's not valid to dereference this type.
 427      The caller is responsible for setting an error.  */
 428   virtual type *dereference () = 0;
 429
 430   /* Dynamic casts.  */
 431   virtual function_type *dyn_cast_function_type () { return NULL; }
 432   virtual function_type *as_a_function_type() { gcc_unreachable (); return NULL; }
 433   virtual struct_ *dyn_cast_struct () { return NULL; }
 434
 435   /* Is it typesafe to copy to this type from rtype?  */
 436   virtual bool accepts_writes_from (type *rtype)
 437   {
 438     gcc_assert (rtype);
 439     return this == rtype->unqualified ();
 440   }
 441
 442   /* Strip off "const" etc */
 443   virtual type *unqualified ()
 444   {
 445     return this;
 446   }
 447
 448   virtual bool is_int () const = 0;
 449   virtual bool is_float () const = 0;
 450   virtual bool is_bool () const = 0;
 451   virtual type *is_pointer () = 0;
 452   virtual type *is_array () = 0;
 453   virtual bool is_void () const { return false; }
 454
 455   bool is_numeric () const
 456   {
 457     return is_int () || is_float () || is_bool ();
 458   }
 459
 460   playback::type *
 461   playback_type ()
 462   {
 463     return static_cast <playback::type *> (m_playback_obj);
 464   }
 465
 466 protected:
 467   type (context *ctxt)
 468     : memento (ctxt),
 469     m_pointer_to_this_type (NULL)
 470   {}
 471
 472 private:
 473   type *m_pointer_to_this_type;
 474 };
 475
 476 /* Result of "gcc_jit_context_get_type".  */
 477 class memento_of_get_type : public type
 478 {
 479 public:
 480   memento_of_get_type (context *ctxt,
 481                        enum gcc_jit_types kind)
 482   : type (ctxt),
 483     m_kind (kind) {}
 484
 485   type *dereference ();
 486
 487   bool accepts_writes_from (type *rtype)
 488   {
 489     if (m_kind == GCC_JIT_TYPE_VOID_PTR)
 490       if (rtype->is_pointer ())
 491         {
 492           /* LHS (this) is type (void *), and the RHS is a pointer:
 493              accept it:  */
 494           return true;
 495         }
 496
 497     return type::accepts_writes_from (rtype);
 498   }
 499
 500   bool is_int () const;
 501   bool is_float () const;
 502   bool is_bool () const;
 503   type *is_pointer () { return dereference (); }
 504   type *is_array () { return NULL; }
 505   bool is_void () const { return m_kind == GCC_JIT_TYPE_VOID; }
 506
 507 public:
 508   void replay_into (replayer *r);
 509
 510 private:
 511   string * make_debug_string ();
 512
 513 private:
 514   enum gcc_jit_types m_kind;
 515 };
 516
 517 /* Result of "gcc_jit_type_get_pointer".  */
 518 class memento_of_get_pointer : public type
 519 {
 520 public:
 521   memento_of_get_pointer (type *other_type)
 522   : type (other_type->m_ctxt),
 523     m_other_type (other_type) {}
 524
 525   type *dereference () { return m_other_type; }
 526
 527   bool accepts_writes_from (type *rtype);
 528
 529   void replay_into (replayer *r);
 530
 531   bool is_int () const { return false; }
 532   bool is_float () const { return false; }
 533   bool is_bool () const { return false; }
 534   type *is_pointer () { return m_other_type; }
 535   type *is_array () { return NULL; }
 536
 537 private:
 538   string * make_debug_string ();
 539
 540 private:
 541   type *m_other_type;
 542 };
 543
 544 /* Result of "gcc_jit_type_get_const".  */
 545 class memento_of_get_const : public type
 546 {
 547 public:
 548   memento_of_get_const (type *other_type)
 549   : type (other_type->m_ctxt),
 550     m_other_type (other_type) {}
 551
 552   type *dereference () { return m_other_type->dereference (); }
 553
 554   bool accepts_writes_from (type */*rtype*/)
 555   {
 556     /* Can't write to a "const".  */
 557     return false;
 558   }
 559
 560   /* Strip off the "const", giving the underlying type.  */
 561   type *unqualified () { return m_other_type; }
 562
 563   bool is_int () const { return m_other_type->is_int (); }
 564   bool is_float () const { return m_other_type->is_float (); }
 565   bool is_bool () const { return m_other_type->is_bool (); }
 566   type *is_pointer () { return m_other_type->is_pointer (); }
 567   type *is_array () { return m_other_type->is_array (); }
 568
 569   void replay_into (replayer *);
 570
 571 private:
 572   string * make_debug_string ();
 573
 574 private:
 575   type *m_other_type;
 576 };
 577
 578 /* Result of "gcc_jit_type_get_volatile".  */
 579 class memento_of_get_volatile : public type
 580 {
 581 public:
 582   memento_of_get_volatile (type *other_type)
 583   : type (other_type->m_ctxt),
 584     m_other_type (other_type) {}
 585
 586   type *dereference () { return m_other_type->dereference (); }
 587
 588   /* Strip off the "volatile", giving the underlying type.  */
 589   type *unqualified () { return m_other_type; }
 590
 591   bool is_int () const { return m_other_type->is_int (); }
 592   bool is_float () const { return m_other_type->is_float (); }
 593   bool is_bool () const { return m_other_type->is_bool (); }
 594   type *is_pointer () { return m_other_type->is_pointer (); }
 595   type *is_array () { return m_other_type->is_array (); }
 596
 597   void replay_into (replayer *);
 598
 599 private:
 600   string * make_debug_string ();
 601
 602 private:
 603   type *m_other_type;
 604 };
 605
 606 class array_type : public type
 607 {
 608  public:
 609   array_type (context *ctxt,
 610               location *loc,
 611               type *element_type,
 612               int num_elements)
 613   : type (ctxt),
 614     m_loc (loc),
 615     m_element_type (element_type),
 616     m_num_elements (num_elements)
 617   {}
 618
 619   type *dereference ();
 620
 621   bool is_int () const { return false; }
 622   bool is_float () const { return false; }
 623   bool is_bool () const { return false; }
 624   type *is_pointer () { return NULL; }
 625   type *is_array () { return m_element_type; }
 626
 627   void replay_into (replayer *);
 628
 629  private:
 630   string * make_debug_string ();
 631
 632  private:
 633   location *m_loc;
 634   type *m_element_type;
 635   int m_num_elements;
 636 };
 637
 638 class function_type : public type
 639 {
 640 public:
 641   function_type (context *ctxt,
 642                  type *return_type,
 643                  int num_params,
 644                  type **param_types,
 645                  int is_variadic);
 646
 647   type *dereference ();
 648   function_type *dyn_cast_function_type () { return this; }
 649   function_type *as_a_function_type () { return this; }
 650
 651   bool is_int () const { return false; }
 652   bool is_float () const { return false; }
 653   bool is_bool () const { return false; }
 654   type *is_pointer () { return NULL; }
 655   type *is_array () { return NULL; }
 656
 657   void replay_into (replayer *);
 658
 659   type * get_return_type () const { return m_return_type; }
 660   const vec<type *> &get_param_types () const { return m_param_types; }
 661   int is_variadic () const { return m_is_variadic; }
 662
 663   string * make_debug_string_with_ptr ();
 664
 665  private:
 666   string * make_debug_string ();
 667   string * make_debug_string_with (const char *);
 668
 669 private:
 670   type *m_return_type;
 671   auto_vec<type *> m_param_types;
 672   int m_is_variadic;
 673 };
 674
 675 class field : public memento
 676 {
 677 public:
 678   field (context *ctxt,
 679          location *loc,
 680          type *type,
 681          string *name)
 682   : memento (ctxt),
 683     m_loc (loc),
 684     m_type (type),
 685     m_name (name),
 686     m_container (NULL)
 687   {}
 688
 689   type * get_type () const { return m_type; }
 690
 691   compound_type * get_container () const { return m_container; }
 692   void set_container (compound_type *c) { m_container = c; }
 693
 694   void replay_into (replayer *);
 695
 696   void write_to_dump (dump &d);
 697
 698   playback::field *
 699   playback_field () const
 700   {
 701     return static_cast <playback::field *> (m_playback_obj);
 702   }
 703
 704 private:
 705   string * make_debug_string ();
 706
 707 private:
 708   location *m_loc;
 709   type *m_type;
 710   string *m_name;
 711   compound_type *m_container;
 712 };
 713
 714 /* Base class for struct_ and union_ */
 715 class compound_type : public type
 716 {
 717 public:
 718   compound_type (context *ctxt,
 719                  location *loc,
 720                  string *name);
 721
 722   string *get_name () const { return m_name; }
 723   location *get_loc () const { return m_loc; }
 724   fields * get_fields () { return m_fields; }
 725
 726   void
 727   set_fields (location *loc,
 728               int num_fields,
 729               field **fields);
 730
 731   type *dereference ();
 732
 733   bool is_int () const { return false; }
 734   bool is_float () const { return false; }
 735   bool is_bool () const { return false; }
 736   type *is_pointer () { return NULL; }
 737   type *is_array () { return NULL; }
 738
 739   playback::compound_type *
 740   playback_compound_type ()
 741   {
 742     return static_cast <playback::compound_type *> (m_playback_obj);
 743   }
 744
 745 private:
 746   location *m_loc;
 747   string *m_name;
 748   fields *m_fields;
 749 };
 750
 751 class struct_ : public compound_type
 752 {
 753 public:
 754   struct_ (context *ctxt,
 755            location *loc,
 756            string *name);
 757
 758   struct_ *dyn_cast_struct () { return this; }
 759
 760   type *
 761   as_type () { return this; }
 762
 763   void replay_into (replayer *r);
 764
 765 private:
 766   string * make_debug_string ();
 767
 768 };
 769
 770 // memento of struct_::set_fields
 771 class fields : public memento
 772 {
 773 public:
 774   fields (compound_type *struct_or_union,
 775           int num_fields,
 776           field **fields);
 777
 778   void replay_into (replayer *r);
 779
 780   void write_to_dump (dump &d);
 781
 782 private:
 783   string * make_debug_string ();
 784
 785 private:
 786   compound_type *m_struct_or_union;
 787   auto_vec<field *> m_fields;
 788 };
 789
 790 class union_ : public compound_type
 791 {
 792 public:
 793   union_ (context *ctxt,
 794           location *loc,
 795           string *name);
 796
 797   void replay_into (replayer *r);
 798
 799 private:
 800   string * make_debug_string ();
 801
 802 private:
 803   location *m_loc;
 804   string *m_name;
 805   fields *m_fields;
 806 };
 807
 808 class rvalue : public memento
 809 {
 810 public:
 811   rvalue (context *ctxt,
 812           location *loc,
 813           type *type_)
 814   : memento (ctxt),
 815     m_loc (loc),
 816     m_type (type_)
 817   {
 818     gcc_assert (type_);
 819   }
 820
 821   /* Get the recording::type of this rvalue.
 822
 823      Implements the post-error-checking part of
 824      gcc_jit_rvalue_get_type.  */
 825   type * get_type () const { return m_type; }
 826
 827   playback::rvalue *
 828   playback_rvalue () const
 829   {
 830     return static_cast <playback::rvalue *> (m_playback_obj);
 831   }
 832   rvalue *
 833   access_field (location *loc,
 834                 field *field);
 835
 836   lvalue *
 837   dereference_field (location *loc,
 838                      field *field);
 839
 840   lvalue *
 841   dereference (location *loc);
 842
 843 protected:
 844   location *m_loc;
 845   type *m_type;
 846 };
 847
 848 class lvalue : public rvalue
 849 {
 850 public:
 851   lvalue (context *ctxt,
 852           location *loc,
 853           type *type_)
 854     : rvalue (ctxt, loc, type_)
 855     {}
 856
 857   playback::lvalue *
 858   playback_lvalue () const
 859   {
 860     return static_cast <playback::lvalue *> (m_playback_obj);
 861   }
 862
 863   lvalue *
 864   access_field (location *loc,
 865                 field *field);
 866
 867   rvalue *
 868   get_address (location *loc);
 869
 870   rvalue *
 871   as_rvalue () { return this; }
 872 };
 873
 874 class param : public lvalue
 875 {
 876 public:
 877   param (context *ctxt,
 878          location *loc,
 879          type *type,
 880          string *name)
 881     : lvalue (ctxt, loc, type),
 882     m_name (name) {}
 883
 884   lvalue *
 885   as_lvalue () { return this; }
 886
 887   void replay_into (replayer *r);
 888
 889   playback::param *
 890   playback_param () const
 891   {
 892     return static_cast <playback::param *> (m_playback_obj);
 893   }
 894
 895 private:
 896   string * make_debug_string () { return m_name; }
 897
 898 private:
 899   string *m_name;
 900 };
 901
 902 class function : public memento
 903 {
 904 public:
 905   function (context *ctxt,
 906             location *loc,
 907             enum gcc_jit_function_kind kind,
 908             type *return_type,
 909             string *name,
 910             int num_params,
 911             param **params,
 912             int is_variadic,
 913             enum built_in_function builtin_id);
 914
 915   void replay_into (replayer *r);
 916
 917   playback::function *
 918   playback_function () const
 919   {
 920     return static_cast <playback::function *> (m_playback_obj);
 921   }
 922
 923   enum gcc_jit_function_kind get_kind () const { return m_kind; }
 924
 925   lvalue *
 926   new_local (location *loc,
 927              type *type,
 928              const char *name);
 929
 930   block*
 931   new_block (const char *name);
 932
 933   type *get_return_type () const { return m_return_type; }
 934   string * get_name () const { return m_name; }
 935   const vec<param *> &get_params () const { return m_params; }
 936
 937   /* Get the given param by index.
 938      Implements the post-error-checking part of
 939      gcc_jit_function_get_param.  */
 940   param *get_param (int i) const { return m_params[i]; }
 941
 942   bool is_variadic () const { return m_is_variadic; }
 943
 944   void write_to_dump (dump &d);
 945
 946   void validate ();
 947
 948   void dump_to_dot (const char *path);
 949
 950 private:
 951   string * make_debug_string ();
 952
 953 private:
 954   location *m_loc;
 955   enum gcc_jit_function_kind m_kind;
 956   type *m_return_type;
 957   string *m_name;
 958   auto_vec<param *> m_params;
 959   int m_is_variadic;
 960   enum built_in_function m_builtin_id;
 961   auto_vec<local *> m_locals;
 962   auto_vec<block *> m_blocks;
 963 };
 964
 965 class block : public memento
 966 {
 967 public:
 968   block (function *func, int index, string *name)
 969   : memento (func->m_ctxt),
 970     m_func (func),
 971     m_index (index),
 972     m_name (name),
 973     m_statements (),
 974     m_has_been_terminated (false),
 975     m_is_reachable (false)
 976   {
 977   }
 978
 979   /* Get the recording::function containing this block.
 980      Implements the post-error-checking part of
 981      gcc_jit_block_get_function.  */
 982   function *get_function () { return m_func; }
 983
 984   bool has_been_terminated () { return m_has_been_terminated; }
 985   bool is_reachable () { return m_is_reachable; }
 986
 987   void
 988   add_eval (location *loc,
 989             rvalue *rvalue);
 990
 991   void
 992   add_assignment (location *loc,
 993                   lvalue *lvalue,
 994                   rvalue *rvalue);
 995
 996   void
 997   add_assignment_op (location *loc,
 998                      lvalue *lvalue,
 999                      enum gcc_jit_binary_op op,
1000                      rvalue *rvalue);
1001
1002   void
1003   add_comment (location *loc,
1004                const char *text);
1005
1006   void
1007   end_with_conditional (location *loc,
1008                         rvalue *boolval,
1009                         block *on_true,
1010                         block *on_false);
1011
1012   void
1013   end_with_jump (location *loc,
1014                  block *target);
1015
1016   void
1017   end_with_return (location *loc,
1018                    rvalue *rvalue);
1019
1020   playback::block *
1021   playback_block () const
1022   {
1023     return static_cast <playback::block *> (m_playback_obj);
1024   }
1025
1026   void write_to_dump (dump &d);
1027
1028   bool validate ();
1029
1030   location *get_loc () const;
1031
1032   statement *get_first_statement () const;
1033   statement *get_last_statement () const;
1034
1035   int get_successor_blocks (block **next1, block **next2) const;
1036
1037 private:
1038   string * make_debug_string ();
1039
1040   void replay_into (replayer *r);
1041
1042   void dump_to_dot (pretty_printer *pp);
1043   void dump_edges_to_dot (pretty_printer *pp);
1044
1045 private:
1046   function *m_func;
1047   int m_index;
1048   string *m_name;
1049   auto_vec<statement *> m_statements;
1050   bool m_has_been_terminated;
1051   bool m_is_reachable;
1052
1053   friend class function;
1054 };
1055
1056 class global : public lvalue
1057 {
1058 public:
1059   global (context *ctxt,
1060           location *loc,
1061           type *type,
1062           string *name)
1063   : lvalue (ctxt, loc, type),
1064     m_name (name)
1065   {}
1066
1067   void replay_into (replayer *);
1068
1069 private:
1070   string * make_debug_string () { return m_name; }
1071
1072 private:
1073   string *m_name;
1074 };
1075
1076 class memento_of_new_rvalue_from_int : public rvalue
1077 {
1078 public:
1079   memento_of_new_rvalue_from_int (context *ctxt,
1080                                   location *loc,
1081                                   type *numeric_type,
1082                                   int value)
1083   : rvalue (ctxt, loc, numeric_type),
1084     m_value (value) {}
1085
1086   void replay_into (replayer *r);
1087
1088 private:
1089   string * make_debug_string ();
1090
1091 private:
1092   int m_value;
1093 };
1094
1095 class memento_of_new_rvalue_from_double : public rvalue
1096 {
1097 public:
1098   memento_of_new_rvalue_from_double (context *ctxt,
1099                                      location *loc,
1100                                      type *numeric_type,
1101                                      double value)
1102   : rvalue (ctxt, loc, numeric_type),
1103     m_value (value)
1104   {}
1105
1106   void replay_into (replayer *);
1107
1108 private:
1109   string * make_debug_string ();
1110
1111 private:
1112   double m_value;
1113 };
1114
1115 class memento_of_new_rvalue_from_ptr : public rvalue
1116 {
1117 public:
1118   memento_of_new_rvalue_from_ptr (context *ctxt,
1119                                   location *loc,
1120                                   type *pointer_type,
1121                                   void *value)
1122   : rvalue (ctxt, loc, pointer_type),
1123     m_value (value)
1124   {}
1125
1126   void replay_into (replayer *);
1127
1128 private:
1129   string * make_debug_string ();
1130
1131 private:
1132   void *m_value;
1133 };
1134
1135 class memento_of_new_string_literal : public rvalue
1136 {
1137 public:
1138   memento_of_new_string_literal (context *ctxt,
1139                                  location *loc,
1140                                  string *value)
1141   : rvalue (ctxt, loc, ctxt->get_type (GCC_JIT_TYPE_CONST_CHAR_PTR)),
1142     m_value (value) {}
1143
1144   void replay_into (replayer *r);
1145
1146 private:
1147   string * make_debug_string ();
1148
1149 private:
1150   string *m_value;
1151 };
1152
1153 class unary_op : public rvalue
1154 {
1155 public:
1156   unary_op (context *ctxt,
1157             location *loc,
1158             enum gcc_jit_unary_op op,
1159             type *result_type,
1160             rvalue *a)
1161   : rvalue (ctxt, loc, result_type),
1162     m_op (op),
1163     m_a (a)
1164   {}
1165
1166   void replay_into (replayer *r);
1167
1168 private:
1169   string * make_debug_string ();
1170
1171 private:
1172   enum gcc_jit_unary_op m_op;
1173   rvalue *m_a;
1174 };
1175
1176 class binary_op : public rvalue
1177 {
1178 public:
1179   binary_op (context *ctxt,
1180              location *loc,
1181              enum gcc_jit_binary_op op,
1182              type *result_type,
1183              rvalue *a, rvalue *b)
1184   : rvalue (ctxt, loc, result_type),
1185     m_op (op),
1186     m_a (a),
1187     m_b (b) {}
1188
1189   void replay_into (replayer *r);
1190
1191 private:
1192   string * make_debug_string ();
1193
1194 private:
1195   enum gcc_jit_binary_op m_op;
1196   rvalue *m_a;
1197   rvalue *m_b;
1198 };
1199
1200 class comparison : public rvalue
1201 {
1202 public:
1203   comparison (context *ctxt,
1204               location *loc,
1205               enum gcc_jit_comparison op,
1206               rvalue *a, rvalue *b)
1207   : rvalue (ctxt, loc, ctxt->get_type (GCC_JIT_TYPE_BOOL)),
1208     m_op (op),
1209     m_a (a),
1210     m_b (b)
1211   {}
1212
1213   void replay_into (replayer *r);
1214
1215 private:
1216   string * make_debug_string ();
1217
1218 private:
1219   enum gcc_jit_comparison m_op;
1220   rvalue *m_a;
1221   rvalue *m_b;
1222 };
1223
1224 class cast : public rvalue
1225 {
1226 public:
1227   cast (context *ctxt,
1228         location *loc,
1229         rvalue *a,
1230         type *type_)
1231   : rvalue (ctxt, loc, type_),
1232     m_rvalue (a)
1233   {}
1234
1235   void replay_into (replayer *r);
1236
1237 private:
1238   string * make_debug_string ();
1239
1240 private:
1241   rvalue *m_rvalue;
1242 };
1243
1244 class call : public rvalue
1245 {
1246 public:
1247   call (context *ctxt,
1248         location *loc,
1249         function *func,
1250         int numargs,
1251         rvalue **args);
1252
1253   void replay_into (replayer *r);
1254
1255 private:
1256   string * make_debug_string ();
1257
1258 private:
1259   function *m_func;
1260   auto_vec<rvalue *> m_args;
1261 };
1262
1263 class call_through_ptr : public rvalue
1264 {
1265 public:
1266   call_through_ptr (context *ctxt,
1267                     location *loc,
1268                     rvalue *fn_ptr,
1269                     int numargs,
1270                     rvalue **args);
1271
1272   void replay_into (replayer *r);
1273
1274 private:
1275   string * make_debug_string ();
1276
1277 private:
1278   rvalue *m_fn_ptr;
1279   auto_vec<rvalue *> m_args;
1280 };
1281
1282 class array_access : public lvalue
1283 {
1284 public:
1285   array_access (context *ctxt,
1286                 location *loc,
1287                 rvalue *ptr,
1288                 rvalue *index)
1289   : lvalue (ctxt, loc, ptr->get_type ()->dereference ()),
1290     m_ptr (ptr),
1291     m_index (index)
1292   {}
1293
1294   void replay_into (replayer *r);
1295
1296 private:
1297   string * make_debug_string ();
1298
1299 private:
1300   rvalue *m_ptr;
1301   rvalue *m_index;
1302 };
1303
1304 class access_field_of_lvalue : public lvalue
1305 {
1306 public:
1307   access_field_of_lvalue (context *ctxt,
1308                           location *loc,
1309                           lvalue *val,
1310                           field *field)
1311   : lvalue (ctxt, loc, field->get_type ()),
1312     m_lvalue (val),
1313     m_field (field)
1314   {}
1315
1316   void replay_into (replayer *r);
1317
1318 private:
1319   string * make_debug_string ();
1320
1321 private:
1322   lvalue *m_lvalue;
1323   field *m_field;
1324 };
1325
1326 class access_field_rvalue : public rvalue
1327 {
1328 public:
1329   access_field_rvalue (context *ctxt,
1330                        location *loc,
1331                        rvalue *val,
1332                        field *field)
1333   : rvalue (ctxt, loc, field->get_type ()),
1334     m_rvalue (val),
1335     m_field (field)
1336   {}
1337
1338   void replay_into (replayer *r);
1339
1340 private:
1341   string * make_debug_string ();
1342
1343 private:
1344   rvalue *m_rvalue;
1345   field *m_field;
1346 };
1347
1348 class dereference_field_rvalue : public lvalue
1349 {
1350 public:
1351   dereference_field_rvalue (context *ctxt,
1352                             location *loc,
1353                             rvalue *val,
1354                             field *field)
1355   : lvalue (ctxt, loc, field->get_type ()),
1356     m_rvalue (val),
1357     m_field (field)
1358   {}
1359
1360   void replay_into (replayer *r);
1361
1362 private:
1363   string * make_debug_string ();
1364
1365 private:
1366   rvalue *m_rvalue;
1367   field *m_field;
1368 };
1369
1370 class dereference_rvalue : public lvalue
1371 {
1372 public:
1373   dereference_rvalue (context *ctxt,
1374                       location *loc,
1375                       rvalue *val)
1376   : lvalue (ctxt, loc, val->get_type ()->dereference ()),
1377     m_rvalue (val) {}
1378
1379   void replay_into (replayer *r);
1380
1381 private:
1382   string * make_debug_string ();
1383
1384 private:
1385   rvalue *m_rvalue;
1386 };
1387
1388 class get_address_of_lvalue : public rvalue
1389 {
1390 public:
1391   get_address_of_lvalue (context *ctxt,
1392                          location *loc,
1393                          lvalue *val)
1394   : rvalue (ctxt, loc, val->get_type ()->get_pointer ()),
1395     m_lvalue (val)
1396   {}
1397
1398   void replay_into (replayer *r);
1399
1400 private:
1401   string * make_debug_string ();
1402
1403 private:
1404   lvalue *m_lvalue;
1405 };
1406
1407 class local : public lvalue
1408 {
1409 public:
1410   local (function *func, location *loc, type *type_, string *name)
1411     : lvalue (func->m_ctxt, loc, type_),
1412     m_func (func),
1413     m_name (name) {}
1414
1415   void replay_into (replayer *r);
1416
1417   void write_to_dump (dump &d);
1418
1419 private:
1420   string * make_debug_string () { return m_name; }
1421
1422 private:
1423   function *m_func;
1424   string *m_name;
1425 };
1426
1427 class statement : public memento
1428 {
1429 public:
1430   virtual int get_successor_blocks (block **out_next1,
1431                                     block **out_next2) const;
1432
1433   void write_to_dump (dump &d);
1434
1435   location *get_loc () const { return m_loc; }
1436
1437 protected:
1438   statement (block *b, location *loc)
1439   : memento (b->m_ctxt),
1440     m_block (b),
1441     m_loc (loc) {}
1442
1443   block *get_block () const { return m_block; }
1444
1445   playback::location *
1446   playback_location (replayer *r) const
1447   {
1448     return ::gcc::jit::recording::playback_location (r, m_loc);
1449   }
1450
1451 private:
1452   block *m_block;
1453   location *m_loc;
1454 };
1455
1456 class eval : public statement
1457 {
1458 public:
1459   eval (block *b,
1460         location *loc,
1461         rvalue *rvalue)
1462   : statement (b, loc),
1463     m_rvalue (rvalue) {}
1464
1465   void replay_into (replayer *r);
1466
1467 private:
1468   string * make_debug_string ();
1469
1470 private:
1471   rvalue *m_rvalue;
1472 };
1473
1474 class assignment : public statement
1475 {
1476 public:
1477   assignment (block *b,
1478               location *loc,
1479               lvalue *lvalue,
1480               rvalue *rvalue)
1481   : statement (b, loc),
1482     m_lvalue (lvalue),
1483     m_rvalue (rvalue) {}
1484
1485   void replay_into (replayer *r);
1486
1487 private:
1488   string * make_debug_string ();
1489
1490 private:
1491   lvalue *m_lvalue;
1492   rvalue *m_rvalue;
1493 };
1494
1495 class assignment_op : public statement
1496 {
1497 public:
1498   assignment_op (block *b,
1499                  location *loc,
1500                  lvalue *lvalue,
1501                  enum gcc_jit_binary_op op,
1502                  rvalue *rvalue)
1503   : statement (b, loc),
1504     m_lvalue (lvalue),
1505     m_op (op),
1506     m_rvalue (rvalue) {}
1507
1508   void replay_into (replayer *r);
1509
1510 private:
1511   string * make_debug_string ();
1512
1513 private:
1514   lvalue *m_lvalue;
1515   enum gcc_jit_binary_op m_op;
1516   rvalue *m_rvalue;
1517 };
1518
1519 class comment : public statement
1520 {
1521 public:
1522   comment (block *b,
1523            location *loc,
1524            string *text)
1525   : statement (b, loc),
1526     m_text (text) {}
1527
1528   void replay_into (replayer *r);
1529
1530 private:
1531   string * make_debug_string ();
1532
1533 private:
1534   string *m_text;
1535 };
1536
1537 class conditional : public statement
1538 {
1539 public:
1540   conditional (block *b,
1541                location *loc,
1542                rvalue *boolval,
1543                block *on_true,
1544                block *on_false)
1545   : statement (b, loc),
1546     m_boolval (boolval),
1547     m_on_true (on_true),
1548     m_on_false (on_false) {}
1549
1550   void replay_into (replayer *r);
1551
1552   int get_successor_blocks (block **out_next1,
1553                             block **out_next2) const;
1554
1555 private:
1556   string * make_debug_string ();
1557
1558 private:
1559   rvalue *m_boolval;
1560   block *m_on_true;
1561   block *m_on_false;
1562 };
1563
1564 class jump : public statement
1565 {
1566 public:
1567   jump (block *b,
1568         location *loc,
1569         block *target)
1570   : statement (b, loc),
1571     m_target (target) {}
1572
1573   void replay_into (replayer *r);
1574
1575   int get_successor_blocks (block **out_next1,
1576                             block **out_next2) const;
1577
1578 private:
1579   string * make_debug_string ();
1580
1581 private:
1582   block *m_target;
1583 };
1584
1585 class return_ : public statement
1586 {
1587 public:
1588   return_ (block *b,
1589            location *loc,
1590            rvalue *rvalue)
1591   : statement (b, loc),
1592     m_rvalue (rvalue) {}
1593
1594   void replay_into (replayer *r);
1595
1596   int get_successor_blocks (block **out_next1,
1597                             block **out_next2) const;
1598
1599 private:
1600   string * make_debug_string ();
1601
1602 private:
1603   rvalue *m_rvalue;
1604 };
1605
1606 } // namespace gcc::jit::recording
1607
1608 } // namespace gcc::jit
1609
1610 } // namespace gcc
1611
1612 #endif /* JIT_RECORDING_H */