gcc/jit/jit-playback.h

   1 /* Internals of libgccjit: classes for playing back recorded API calls.
   2    Copyright (C) 2013-2018 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_PLAYBACK_H
  22 #define JIT_PLAYBACK_H
  23
  24 #include <utility> // for std::pair
  25
  26 #include "timevar.h"
  27
  28 #include "jit-recording.h"
  29
  30 struct diagnostic_context;
  31 struct diagnostic_info;
  32
  33 namespace gcc {
  34
  35 namespace jit {
  36
  37 /**********************************************************************
  38  Playback.
  39  **********************************************************************/
  40
  41 namespace playback {
  42
  43 /* playback::context is an abstract base class.
  44
  45    The two concrete subclasses are:
  46    - playback::compile_to_memory
  47    - playback::compile_to_file.  */
  48
  49 class context : public log_user
  50 {
  51 public:
  52   context (::gcc::jit::recording::context *ctxt);
  53   ~context ();
  54
  55   void gt_ggc_mx ();
  56
  57   void replay ();
  58
  59   location *
  60   new_location (recording::location *rloc,
  61                 const char *filename,
  62                 int line,
  63                 int column);
  64
  65   type *
  66   get_type (enum gcc_jit_types type);
  67
  68   type *
  69   new_array_type (location *loc,
  70                   type *element_type,
  71                   int num_elements);
  72
  73   field *
  74   new_field (location *loc,
  75              type *type,
  76              const char *name);
  77
  78   compound_type *
  79   new_compound_type (location *loc,
  80                      const char *name,
  81                      bool is_struct); /* else is union */
  82
  83   type *
  84   new_function_type (type *return_type,
  85                      const auto_vec<type *> *param_types,
  86                      int is_variadic);
  87
  88   param *
  89   new_param (location *loc,
  90              type *type,
  91              const char *name);
  92
  93   function *
  94   new_function (location *loc,
  95                 enum gcc_jit_function_kind kind,
  96                 type *return_type,
  97                 const char *name,
  98                 const auto_vec<param *> *params,
  99                 int is_variadic,
 100                 enum built_in_function builtin_id);
 101
 102   lvalue *
 103   new_global (location *loc,
 104               enum gcc_jit_global_kind kind,
 105               type *type,
 106               const char *name);
 107
 108   template <typename HOST_TYPE>
 109   rvalue *
 110   new_rvalue_from_const (type *type,
 111                          HOST_TYPE value);
 112
 113   rvalue *
 114   new_string_literal (const char *value);
 115
 116   rvalue *
 117   new_rvalue_from_vector (location *loc,
 118                           type *type,
 119                           const auto_vec<rvalue *> &elements);
 120
 121   rvalue *
 122   new_unary_op (location *loc,
 123                 enum gcc_jit_unary_op op,
 124                 type *result_type,
 125                 rvalue *a);
 126
 127   rvalue *
 128   new_binary_op (location *loc,
 129                  enum gcc_jit_binary_op op,
 130                  type *result_type,
 131                  rvalue *a, rvalue *b);
 132
 133   rvalue *
 134   new_comparison (location *loc,
 135                   enum gcc_jit_comparison op,
 136                   rvalue *a, rvalue *b);
 137
 138   rvalue *
 139   new_call (location *loc,
 140             function *func,
 141             const auto_vec<rvalue *> *args,
 142             bool require_tail_call);
 143
 144   rvalue *
 145   new_call_through_ptr (location *loc,
 146                         rvalue *fn_ptr,
 147                         const auto_vec<rvalue *> *args,
 148                         bool require_tail_call);
 149
 150   rvalue *
 151   new_cast (location *loc,
 152             rvalue *expr,
 153             type *type_);
 154
 155   lvalue *
 156   new_array_access (location *loc,
 157                     rvalue *ptr,
 158                     rvalue *index);
 159
 160   void
 161   set_str_option (enum gcc_jit_str_option opt,
 162                   const char *value);
 163
 164   void
 165   set_int_option (enum gcc_jit_int_option opt,
 166                   int value);
 167
 168   void
 169   set_bool_option (enum gcc_jit_bool_option opt,
 170                    int value);
 171
 172   const char *
 173   get_str_option (enum gcc_jit_str_option opt) const
 174   {
 175     return m_recording_ctxt->get_str_option (opt);
 176   }
 177
 178   int
 179   get_int_option (enum gcc_jit_int_option opt) const
 180   {
 181     return m_recording_ctxt->get_int_option (opt);
 182   }
 183
 184   int
 185   get_bool_option (enum gcc_jit_bool_option opt) const
 186   {
 187     return m_recording_ctxt->get_bool_option (opt);
 188   }
 189
 190   int
 191   get_inner_bool_option (enum inner_bool_option opt) const
 192   {
 193     return m_recording_ctxt->get_inner_bool_option (opt);
 194   }
 195
 196   builtins_manager *get_builtins_manager () const
 197   {
 198     return m_recording_ctxt->get_builtins_manager ();
 199   }
 200
 201   void
 202   compile ();
 203
 204   void
 205   add_error (location *loc, const char *fmt, ...)
 206       GNU_PRINTF(3, 4);
 207
 208   void
 209   add_error_va (location *loc, const char *fmt, va_list ap)
 210       GNU_PRINTF(3, 0);
 211
 212   const char *
 213   get_first_error () const;
 214
 215   void
 216   add_diagnostic (struct diagnostic_context *context,
 217                   struct diagnostic_info *diagnostic);
 218
 219   void
 220   set_tree_location (tree t, location *loc);
 221
 222   tree
 223   new_field_access (location *loc,
 224                     tree datum,
 225                     field *field);
 226
 227   tree
 228   new_dereference (tree ptr, location *loc);
 229
 230   tree
 231   as_truth_value (tree expr, location *loc);
 232
 233   bool errors_occurred () const
 234   {
 235     return m_recording_ctxt->errors_occurred ();
 236   }
 237
 238   timer *get_timer () const { return m_recording_ctxt->get_timer (); }
 239
 240 private:
 241   void dump_generated_code ();
 242
 243   rvalue *
 244   build_call (location *loc,
 245               tree fn_ptr,
 246               const auto_vec<rvalue *> *args,
 247               bool require_tail_call);
 248
 249   tree
 250   build_cast (location *loc,
 251               rvalue *expr,
 252               type *type_);
 253
 254   source_file *
 255   get_source_file (const char *filename);
 256
 257   void handle_locations ();
 258
 259   const char * get_path_c_file () const;
 260   const char * get_path_s_file () const;
 261   const char * get_path_so_file () const;
 262
 263 private:
 264
 265   /* Functions for implementing "compile".  */
 266
 267   void acquire_mutex ();
 268   void release_mutex ();
 269
 270   void
 271   make_fake_args (vec <char *> *argvec,
 272                   const char *ctxt_progname,
 273                   vec <recording::requested_dump> *requested_dumps);
 274
 275   void
 276   extract_any_requested_dumps
 277     (vec <recording::requested_dump> *requested_dumps);
 278
 279   char *
 280   read_dump_file (const char *path);
 281
 282   virtual void postprocess (const char *ctxt_progname) = 0;
 283
 284 protected:
 285   tempdir *get_tempdir () { return m_tempdir; }
 286
 287   void
 288   convert_to_dso (const char *ctxt_progname);
 289
 290   void
 291   invoke_driver (const char *ctxt_progname,
 292                  const char *input_file,
 293                  const char *output_file,
 294                  timevar_id_t tv_id,
 295                  bool shared,
 296                  bool run_linker);
 297
 298   void
 299   add_multilib_driver_arguments (vec <char *> *argvec);
 300
 301   result *
 302   dlopen_built_dso ();
 303
 304  private:
 305   void
 306   invoke_embedded_driver (const vec <char *> *argvec);
 307
 308   void
 309   invoke_external_driver (const char *ctxt_progname,
 310                           vec <char *> *argvec);
 311
 312 private:
 313   ::gcc::jit::recording::context *m_recording_ctxt;
 314
 315   tempdir *m_tempdir;
 316
 317   auto_vec<function *> m_functions;
 318   auto_vec<tree> m_globals;
 319   tree m_char_array_type_node;
 320   tree m_const_char_ptr;
 321
 322   /* Source location handling.  */
 323   auto_vec<source_file *> m_source_files;
 324
 325   auto_vec<std::pair<tree, location *> > m_cached_locations;
 326 };
 327
 328 class compile_to_memory : public context
 329 {
 330  public:
 331   compile_to_memory (recording::context *ctxt);
 332   void postprocess (const char *ctxt_progname) FINAL OVERRIDE;
 333
 334   result *get_result_obj () const { return m_result; }
 335
 336  private:
 337   result *m_result;
 338 };
 339
 340 class compile_to_file : public context
 341 {
 342  public:
 343   compile_to_file (recording::context *ctxt,
 344                    enum gcc_jit_output_kind output_kind,
 345                    const char *output_path);
 346   void postprocess (const char *ctxt_progname) FINAL OVERRIDE;
 347
 348  private:
 349   void
 350   copy_file (const char *src_path,
 351              const char *dst_path);
 352
 353  private:
 354   enum gcc_jit_output_kind m_output_kind;
 355   const char *m_output_path;
 356 };
 357
 358
 359 /* A temporary wrapper object.
 360    These objects are (mostly) only valid during replay.
 361    We allocate them on the GC heap, so that they will be cleaned
 362    the next time the GC collects.
 363    The exception is the "function" class, which is tracked and marked by
 364    the jit::context, since it needs to stay alive during post-processing
 365    (when the GC could run). */
 366 class wrapper
 367 {
 368 public:
 369   /* Allocate in the GC heap.  */
 370   void *operator new (size_t sz);
 371
 372   /* Some wrapper subclasses contain vec<> and so need to
 373      release them when they are GC-ed.  */
 374   virtual void finalizer () { }
 375
 376 };
 377
 378 class type : public wrapper
 379 {
 380 public:
 381   type (tree inner)
 382     : m_inner(inner)
 383   {}
 384
 385   tree as_tree () const { return m_inner; }
 386
 387   type *get_pointer () const { return new type (build_pointer_type (m_inner)); }
 388
 389   type *get_const () const
 390   {
 391     return new type (build_qualified_type (m_inner, TYPE_QUAL_CONST));
 392   }
 393
 394   type *get_volatile () const
 395   {
 396     return new type (build_qualified_type (m_inner, TYPE_QUAL_VOLATILE));
 397   }
 398
 399   type *get_aligned (size_t alignment_in_bytes) const;
 400   type *get_vector (size_t num_units) const;
 401
 402 private:
 403   tree m_inner;
 404 };
 405
 406 class compound_type : public type
 407 {
 408 public:
 409   compound_type (tree inner)
 410     : type (inner)
 411   {}
 412
 413   void set_fields (const auto_vec<field *> *fields);
 414 };
 415
 416 class field : public wrapper
 417 {
 418 public:
 419   field (tree inner)
 420     : m_inner(inner)
 421   {}
 422
 423   tree as_tree () const { return m_inner; }
 424
 425 private:
 426   tree m_inner;
 427 };
 428
 429 class function : public wrapper
 430 {
 431 public:
 432   function(context *ctxt, tree fndecl, enum gcc_jit_function_kind kind);
 433
 434   void gt_ggc_mx ();
 435   void finalizer () FINAL OVERRIDE;
 436
 437   tree get_return_type_as_tree () const;
 438
 439   tree as_fndecl () const { return m_inner_fndecl; }
 440
 441   enum gcc_jit_function_kind get_kind () const { return m_kind; }
 442
 443   lvalue *
 444   new_local (location *loc,
 445              type *type,
 446              const char *name);
 447
 448   block*
 449   new_block (const char *name);
 450
 451   rvalue *
 452   get_address (location *loc);
 453
 454   void
 455   build_stmt_list ();
 456
 457   void
 458   postprocess ();
 459
 460 public:
 461   context *m_ctxt;
 462
 463 public:
 464   void
 465   set_tree_location (tree t, location *loc)
 466   {
 467     m_ctxt->set_tree_location (t, loc);
 468   }
 469
 470 private:
 471   tree m_inner_fndecl;
 472   tree m_inner_block;
 473   tree m_inner_bind_expr;
 474   enum gcc_jit_function_kind m_kind;
 475   tree m_stmt_list;
 476   tree_stmt_iterator m_stmt_iter;
 477   vec<block *> m_blocks;
 478 };
 479
 480 struct case_
 481 {
 482   case_ (rvalue *min_value, rvalue *max_value, block *dest_block)
 483   : m_min_value (min_value),
 484     m_max_value (max_value),
 485     m_dest_block (dest_block)
 486   {}
 487
 488   rvalue *m_min_value;
 489   rvalue *m_max_value;
 490   block *m_dest_block;
 491 };
 492
 493 class block : public wrapper
 494 {
 495 public:
 496   block (function *func,
 497          const char *name);
 498
 499   void finalizer () FINAL OVERRIDE;
 500
 501   tree as_label_decl () const { return m_label_decl; }
 502
 503   function *get_function () const { return m_func; }
 504
 505   void
 506   add_eval (location *loc,
 507             rvalue *rvalue);
 508
 509   void
 510   add_assignment (location *loc,
 511                   lvalue *lvalue,
 512                   rvalue *rvalue);
 513
 514   void
 515   add_comment (location *loc,
 516                const char *text);
 517
 518   void
 519   add_conditional (location *loc,
 520                    rvalue *boolval,
 521                    block *on_true,
 522                    block *on_false);
 523
 524   block *
 525   add_block (location *loc,
 526              const char *name);
 527
 528   void
 529   add_jump (location *loc,
 530             block *target);
 531
 532   void
 533   add_return (location *loc,
 534               rvalue *rvalue);
 535
 536   void
 537   add_switch (location *loc,
 538               rvalue *expr,
 539               block *default_block,
 540               const auto_vec <case_> *cases);
 541
 542 private:
 543   void
 544   set_tree_location (tree t, location *loc)
 545   {
 546     m_func->set_tree_location (t, loc);
 547   }
 548
 549   void add_stmt (tree stmt)
 550   {
 551     /* TODO: use one stmt_list per block.  */
 552     m_stmts.safe_push (stmt);
 553   }
 554
 555 private:
 556   function *m_func;
 557   tree m_label_decl;
 558   vec<tree> m_stmts;
 559
 560 public: // for now
 561   tree m_label_expr;
 562
 563   friend class function;
 564 };
 565
 566 class rvalue : public wrapper
 567 {
 568 public:
 569   rvalue (context *ctxt, tree inner)
 570     : m_ctxt (ctxt),
 571       m_inner (inner)
 572   {}
 573
 574   rvalue *
 575   as_rvalue () { return this; }
 576
 577   tree as_tree () const { return m_inner; }
 578
 579   context *get_context () const { return m_ctxt; }
 580
 581   type *
 582   get_type () { return new type (TREE_TYPE (m_inner)); }
 583
 584   rvalue *
 585   access_field (location *loc,
 586                 field *field);
 587
 588   lvalue *
 589   dereference_field (location *loc,
 590                      field *field);
 591
 592   lvalue *
 593   dereference (location *loc);
 594
 595 private:
 596   context *m_ctxt;
 597   tree m_inner;
 598 };
 599
 600 class lvalue : public rvalue
 601 {
 602 public:
 603   lvalue (context *ctxt, tree inner)
 604     : rvalue(ctxt, inner)
 605   {}
 606
 607   lvalue *
 608   as_lvalue () { return this; }
 609
 610   lvalue *
 611   access_field (location *loc,
 612                 field *field);
 613
 614   rvalue *
 615   get_address (location *loc);
 616
 617 };
 618
 619 class param : public lvalue
 620 {
 621 public:
 622   param (context *ctxt, tree inner)
 623     : lvalue(ctxt, inner)
 624   {}
 625 };
 626
 627 /* Dealing with the linemap API.
 628
 629    It appears that libcpp requires locations to be created as if by
 630    a tokenizer, creating them by filename, in ascending order of
 631    line/column, whereas our API doesn't impose any such constraints:
 632    we allow client code to create locations in arbitrary orders.
 633
 634    To square this circle, we need to cache all location creation,
 635    grouping things up by filename/line, and then creating the linemap
 636    entries in a post-processing phase.  */
 637
 638 /* A set of locations, all sharing a filename */
 639 class source_file : public wrapper
 640 {
 641 public:
 642   source_file (tree filename);
 643   void finalizer () FINAL OVERRIDE;
 644
 645   source_line *
 646   get_source_line (int line_num);
 647
 648   tree filename_as_tree () const { return m_filename; }
 649
 650   const char*
 651   get_filename () const { return IDENTIFIER_POINTER (m_filename); }
 652
 653   vec<source_line *> m_source_lines;
 654
 655 private:
 656   tree m_filename;
 657 };
 658
 659 /* A source line, with one or more locations of interest.  */
 660 class source_line : public wrapper
 661 {
 662 public:
 663   source_line (source_file *file, int line_num);
 664   void finalizer () FINAL OVERRIDE;
 665
 666   location *
 667   get_location (recording::location *rloc, int column_num);
 668
 669   int get_line_num () const { return m_line_num; }
 670
 671   vec<location *> m_locations;
 672
 673 private:
 674   source_file *m_source_file;
 675   int m_line_num;
 676 };
 677
 678 /* A specific location on a source line.  This is what we expose
 679    to the client API.  */
 680 class location : public wrapper
 681 {
 682 public:
 683   location (recording::location *loc, source_line *line, int column_num);
 684
 685   int get_column_num () const { return m_column_num; }
 686
 687   recording::location *get_recording_loc () const { return m_recording_loc; }
 688
 689   source_location m_srcloc;
 690
 691 private:
 692   recording::location *m_recording_loc;
 693   source_line *m_line;
 694   int m_column_num;
 695 };
 696
 697 } // namespace gcc::jit::playback
 698
 699 extern playback::context *active_playback_ctxt;
 700
 701 } // namespace gcc::jit
 702
 703 } // namespace gcc
 704
 705 #endif /* JIT_PLAYBACK_H */
 706