gcc/jit/jit-playback.h

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