gcc/jit/jit-playback.h

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