gdb/expop.h

   1 /* Definitions for expressions in GDB
   2
   3    Copyright (C) 2020-2023 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef EXPOP_H
  21 #define EXPOP_H
  22
  23 #include "c-lang.h"
  24 #include "cp-abi.h"
  25 #include "expression.h"
  26 #include "language.h"
  27 #include "objfiles.h"
  28 #include "gdbsupport/traits.h"
  29 #include "gdbsupport/enum-flags.h"
  30
  31 struct agent_expr;
  32 struct axs_value;
  33
  34 extern void gen_expr_binop (struct expression *exp,
  35                             enum exp_opcode op,
  36                             expr::operation *lhs, expr::operation *rhs,
  37                             struct agent_expr *ax, struct axs_value *value);
  38 extern void gen_expr_structop (struct expression *exp,
  39                                enum exp_opcode op,
  40                                expr::operation *lhs,
  41                                const char *name,
  42                                struct agent_expr *ax, struct axs_value *value);
  43 extern void gen_expr_unop (struct expression *exp,
  44                            enum exp_opcode op,
  45                            expr::operation *lhs,
  46                            struct agent_expr *ax, struct axs_value *value);
  47
  48 extern struct value *eval_op_scope (struct type *expect_type,
  49                                     struct expression *exp,
  50                                     enum noside noside,
  51                                     struct type *type, const char *string);
  52 extern struct value *eval_op_var_msym_value (struct type *expect_type,
  53                                              struct expression *exp,
  54                                              enum noside noside,
  55                                              bool outermost_p,
  56                                              bound_minimal_symbol msymbol);
  57 extern struct value *eval_op_var_entry_value (struct type *expect_type,
  58                                               struct expression *exp,
  59                                               enum noside noside, symbol *sym);
  60 extern struct value *eval_op_func_static_var (struct type *expect_type,
  61                                               struct expression *exp,
  62                                               enum noside noside,
  63                                               value *func, const char *var);
  64 extern struct value *eval_op_register (struct type *expect_type,
  65                                        struct expression *exp,
  66                                        enum noside noside, const char *name);
  67 extern struct value *eval_op_ternop (struct type *expect_type,
  68                                      struct expression *exp,
  69                                      enum noside noside,
  70                                      struct value *array, struct value *low,
  71                                      struct value *upper);
  72 extern struct value *eval_op_structop_struct (struct type *expect_type,
  73                                               struct expression *exp,
  74                                               enum noside noside,
  75                                               struct value *arg1,
  76                                               const char *string);
  77 extern struct value *eval_op_structop_ptr (struct type *expect_type,
  78                                            struct expression *exp,
  79                                            enum noside noside,
  80                                            struct value *arg1,
  81                                            const char *string);
  82 extern struct value *eval_op_member (struct type *expect_type,
  83                                      struct expression *exp,
  84                                      enum noside noside,
  85                                      struct value *arg1, struct value *arg2);
  86 extern struct value *eval_op_add (struct type *expect_type,
  87                                   struct expression *exp,
  88                                   enum noside noside,
  89                                   struct value *arg1, struct value *arg2);
  90 extern struct value *eval_op_sub (struct type *expect_type,
  91                                   struct expression *exp,
  92                                   enum noside noside,
  93                                   struct value *arg1, struct value *arg2);
  94 extern struct value *eval_op_binary (struct type *expect_type,
  95                                      struct expression *exp,
  96                                      enum noside noside, enum exp_opcode op,
  97                                      struct value *arg1, struct value *arg2);
  98 extern struct value *eval_op_subscript (struct type *expect_type,
  99                                         struct expression *exp,
 100                                         enum noside noside, enum exp_opcode op,
 101                                         struct value *arg1,
 102                                         struct value *arg2);
 103 extern struct value *eval_op_equal (struct type *expect_type,
 104                                     struct expression *exp,
 105                                     enum noside noside, enum exp_opcode op,
 106                                     struct value *arg1,
 107                                     struct value *arg2);
 108 extern struct value *eval_op_notequal (struct type *expect_type,
 109                                        struct expression *exp,
 110                                        enum noside noside, enum exp_opcode op,
 111                                        struct value *arg1,
 112                                        struct value *arg2);
 113 extern struct value *eval_op_less (struct type *expect_type,
 114                                    struct expression *exp,
 115                                    enum noside noside, enum exp_opcode op,
 116                                    struct value *arg1,
 117                                    struct value *arg2);
 118 extern struct value *eval_op_gtr (struct type *expect_type,
 119                                   struct expression *exp,
 120                                   enum noside noside, enum exp_opcode op,
 121                                   struct value *arg1,
 122                                   struct value *arg2);
 123 extern struct value *eval_op_geq (struct type *expect_type,
 124                                   struct expression *exp,
 125                                   enum noside noside, enum exp_opcode op,
 126                                   struct value *arg1,
 127                                   struct value *arg2);
 128 extern struct value *eval_op_leq (struct type *expect_type,
 129                                   struct expression *exp,
 130                                   enum noside noside, enum exp_opcode op,
 131                                   struct value *arg1,
 132                                   struct value *arg2);
 133 extern struct value *eval_op_repeat (struct type *expect_type,
 134                                      struct expression *exp,
 135                                      enum noside noside, enum exp_opcode op,
 136                                      struct value *arg1,
 137                                      struct value *arg2);
 138 extern struct value *eval_op_plus (struct type *expect_type,
 139                                    struct expression *exp,
 140                                    enum noside noside, enum exp_opcode op,
 141                                    struct value *arg1);
 142 extern struct value *eval_op_neg (struct type *expect_type,
 143                                   struct expression *exp,
 144                                   enum noside noside, enum exp_opcode op,
 145                                   struct value *arg1);
 146 extern struct value *eval_op_complement (struct type *expect_type,
 147                                          struct expression *exp,
 148                                          enum noside noside,
 149                                          enum exp_opcode op,
 150                                          struct value *arg1);
 151 extern struct value *eval_op_lognot (struct type *expect_type,
 152                                      struct expression *exp,
 153                                      enum noside noside,
 154                                      enum exp_opcode op,
 155                                      struct value *arg1);
 156 extern struct value *eval_op_preinc (struct type *expect_type,
 157                                      struct expression *exp,
 158                                      enum noside noside,
 159                                      enum exp_opcode op,
 160                                      struct value *arg1);
 161 extern struct value *eval_op_predec (struct type *expect_type,
 162                                      struct expression *exp,
 163                                      enum noside noside,
 164                                      enum exp_opcode op,
 165                                      struct value *arg1);
 166 extern struct value *eval_op_postinc (struct type *expect_type,
 167                                       struct expression *exp,
 168                                       enum noside noside,
 169                                       enum exp_opcode op,
 170                                       struct value *arg1);
 171 extern struct value *eval_op_postdec (struct type *expect_type,
 172                                       struct expression *exp,
 173                                       enum noside noside,
 174                                       enum exp_opcode op,
 175                                       struct value *arg1);
 176 extern struct value *eval_op_ind (struct type *expect_type,
 177                                   struct expression *exp,
 178                                   enum noside noside,
 179                                   struct value *arg1);
 180 extern struct value *eval_op_type (struct type *expect_type,
 181                                    struct expression *exp,
 182                                    enum noside noside, struct type *type);
 183 extern struct value *eval_op_alignof (struct type *expect_type,
 184                                       struct expression *exp,
 185                                       enum noside noside,
 186                                       struct value *arg1);
 187 extern struct value *eval_op_memval (struct type *expect_type,
 188                                      struct expression *exp,
 189                                      enum noside noside,
 190                                      struct value *arg1, struct type *type);
 191 extern struct value *eval_binop_assign_modify (struct type *expect_type,
 192                                                struct expression *exp,
 193                                                enum noside noside,
 194                                                enum exp_opcode op,
 195                                                struct value *arg1,
 196                                                struct value *arg2);
 197
 198 namespace expr
 199 {
 200
 201 class ada_component;
 202
 203 /* The check_objfile overloads are used to check whether a particular
 204    component of some operation references an objfile.  The passed-in
 205    objfile will never be a debug objfile.  */
 206
 207 /* See if EXP_OBJFILE matches OBJFILE.  */
 208 static inline bool
 209 check_objfile (struct objfile *exp_objfile, struct objfile *objfile)
 210 {
 211   if (exp_objfile->separate_debug_objfile_backlink)
 212     exp_objfile = exp_objfile->separate_debug_objfile_backlink;
 213   return exp_objfile == objfile;
 214 }
 215
 216 static inline bool
 217 check_objfile (struct type *type, struct objfile *objfile)
 218 {
 219   struct objfile *ty_objfile = type->objfile_owner ();
 220   if (ty_objfile != nullptr)
 221     return check_objfile (ty_objfile, objfile);
 222   return false;
 223 }
 224
 225 static inline bool
 226 check_objfile (struct symbol *sym, struct objfile *objfile)
 227 {
 228   return check_objfile (sym->objfile (), objfile);
 229 }
 230
 231 extern bool check_objfile (const struct block *block,
 232                            struct objfile *objfile);
 233
 234 static inline bool
 235 check_objfile (const block_symbol &sym, struct objfile *objfile)
 236 {
 237   return (check_objfile (sym.symbol, objfile)
 238           || check_objfile (sym.block, objfile));
 239 }
 240
 241 static inline bool
 242 check_objfile (bound_minimal_symbol minsym, struct objfile *objfile)
 243 {
 244   return check_objfile (minsym.objfile, objfile);
 245 }
 246
 247 static inline bool
 248 check_objfile (internalvar *ivar, struct objfile *objfile)
 249 {
 250   return false;
 251 }
 252
 253 static inline bool
 254 check_objfile (const std::string &str, struct objfile *objfile)
 255 {
 256   return false;
 257 }
 258
 259 static inline bool
 260 check_objfile (const operation_up &op, struct objfile *objfile)
 261 {
 262   return op->uses_objfile (objfile);
 263 }
 264
 265 static inline bool
 266 check_objfile (enum exp_opcode val, struct objfile *objfile)
 267 {
 268   return false;
 269 }
 270
 271 static inline bool
 272 check_objfile (ULONGEST val, struct objfile *objfile)
 273 {
 274   return false;
 275 }
 276
 277 static inline bool
 278 check_objfile (const gdb_mpz &val, struct objfile *objfile)
 279 {
 280   return false;
 281 }
 282
 283 template<typename T>
 284 static inline bool
 285 check_objfile (enum_flags<T> val, struct objfile *objfile)
 286 {
 287   return false;
 288 }
 289
 290 template<typename T>
 291 static inline bool
 292 check_objfile (const std::vector<T> &collection, struct objfile *objfile)
 293 {
 294   for (const auto &item : collection)
 295     {
 296       if (check_objfile (item, objfile))
 297         return true;
 298     }
 299   return false;
 300 }
 301
 302 template<typename S, typename T>
 303 static inline bool
 304 check_objfile (const std::pair<S, T> &item, struct objfile *objfile)
 305 {
 306   return (check_objfile (item.first, objfile)
 307           || check_objfile (item.second, objfile));
 308 }
 309
 310 extern bool check_objfile (const std::unique_ptr<ada_component> &comp,
 311                            struct objfile *objfile);
 312
 313 static inline void
 314 dump_for_expression (struct ui_file *stream, int depth,
 315                      const operation_up &op)
 316 {
 317   if (op == nullptr)
 318     gdb_printf (stream, _("%*snullptr\n"), depth, "");
 319   else
 320     op->dump (stream, depth);
 321 }
 322
 323 extern void dump_for_expression (struct ui_file *stream, int depth,
 324                                  enum exp_opcode op);
 325 extern void dump_for_expression (struct ui_file *stream, int depth,
 326                                  const std::string &str);
 327 extern void dump_for_expression (struct ui_file *stream, int depth,
 328                                  struct type *type);
 329 extern void dump_for_expression (struct ui_file *stream, int depth,
 330                                  CORE_ADDR addr);
 331 extern void dump_for_expression (struct ui_file *stream, int depth,
 332                                  const gdb_mpz &addr);
 333 extern void dump_for_expression (struct ui_file *stream, int depth,
 334                                  internalvar *ivar);
 335 extern void dump_for_expression (struct ui_file *stream, int depth,
 336                                  symbol *sym);
 337 extern void dump_for_expression (struct ui_file *stream, int depth,
 338                                  const block_symbol &sym);
 339 extern void dump_for_expression (struct ui_file *stream, int depth,
 340                                  bound_minimal_symbol msym);
 341 extern void dump_for_expression (struct ui_file *stream, int depth,
 342                                  const block *bl);
 343 extern void dump_for_expression (struct ui_file *stream, int depth,
 344                                  type_instance_flags flags);
 345 extern void dump_for_expression (struct ui_file *stream, int depth,
 346                                  enum c_string_type_values flags);
 347 extern void dump_for_expression (struct ui_file *stream, int depth,
 348                                  enum range_flag flags);
 349 extern void dump_for_expression (struct ui_file *stream, int depth,
 350                                  const std::unique_ptr<ada_component> &comp);
 351
 352 template<typename T>
 353 void
 354 dump_for_expression (struct ui_file *stream, int depth,
 355                      const std::vector<T> &vals)
 356 {
 357   gdb_printf (stream, _("%*sVector:\n"), depth, "");
 358   for (auto &item : vals)
 359     dump_for_expression (stream, depth + 1, item);
 360 }
 361
 362 template<typename X, typename Y>
 363 void
 364 dump_for_expression (struct ui_file *stream, int depth,
 365                      const std::pair<X, Y> &vals)
 366 {
 367   dump_for_expression (stream, depth, vals.first);
 368   dump_for_expression (stream, depth, vals.second);
 369 }
 370
 371 /* Base class for most concrete operations.  This class holds data,
 372    specified via template parameters, and supplies generic
 373    implementations of the 'dump' and 'uses_objfile' methods.  */
 374 template<typename... Arg>
 375 class tuple_holding_operation : public operation
 376 {
 377 public:
 378
 379   explicit tuple_holding_operation (Arg... args)
 380     : m_storage (std::forward<Arg> (args)...)
 381   {
 382   }
 383
 384   DISABLE_COPY_AND_ASSIGN (tuple_holding_operation);
 385
 386   bool uses_objfile (struct objfile *objfile) const override
 387   {
 388     return do_check_objfile<0, Arg...> (objfile, m_storage);
 389   }
 390
 391   void dump (struct ui_file *stream, int depth) const override
 392   {
 393     dump_for_expression (stream, depth, opcode ());
 394     do_dump<0, Arg...> (stream, depth + 1, m_storage);
 395   }
 396
 397 protected:
 398
 399   /* Storage for the data.  */
 400   std::tuple<Arg...> m_storage;
 401
 402 private:
 403
 404   /* do_dump does the work of dumping the data.  */
 405   template<int I, typename... T>
 406   typename std::enable_if<I == sizeof... (T), void>::type
 407   do_dump (struct ui_file *stream, int depth, const std::tuple<T...> &value)
 408     const
 409   {
 410   }
 411
 412   template<int I, typename... T>
 413   typename std::enable_if<I < sizeof... (T), void>::type
 414   do_dump (struct ui_file *stream, int depth, const std::tuple<T...> &value)
 415     const
 416   {
 417     dump_for_expression (stream, depth, std::get<I> (value));
 418     do_dump<I + 1, T...> (stream, depth, value);
 419   }
 420
 421   /* do_check_objfile does the work of checking whether this object
 422      refers to OBJFILE.  */
 423   template<int I, typename... T>
 424   typename std::enable_if<I == sizeof... (T), bool>::type
 425   do_check_objfile (struct objfile *objfile, const std::tuple<T...> &value)
 426     const
 427   {
 428     return false;
 429   }
 430
 431   template<int I, typename... T>
 432   typename std::enable_if<I < sizeof... (T), bool>::type
 433   do_check_objfile (struct objfile *objfile, const std::tuple<T...> &value)
 434     const
 435   {
 436     if (check_objfile (std::get<I> (value), objfile))
 437       return true;
 438     return do_check_objfile<I + 1, T...> (objfile, value);
 439   }
 440 };
 441
 442 /* The check_constant overloads are used to decide whether a given
 443    concrete operation is a constant.  This is done by checking the
 444    operands.  */
 445
 446 static inline bool
 447 check_constant (const operation_up &item)
 448 {
 449   return item->constant_p ();
 450 }
 451
 452 static inline bool
 453 check_constant (bound_minimal_symbol msym)
 454 {
 455   return false;
 456 }
 457
 458 static inline bool
 459 check_constant (struct type *type)
 460 {
 461   return true;
 462 }
 463
 464 static inline bool
 465 check_constant (const struct block *block)
 466 {
 467   return true;
 468 }
 469
 470 static inline bool
 471 check_constant (const std::string &str)
 472 {
 473   return true;
 474 }
 475
 476 static inline bool
 477 check_constant (ULONGEST cst)
 478 {
 479   return true;
 480 }
 481
 482 static inline bool
 483 check_constant (const gdb_mpz &cst)
 484 {
 485   return true;
 486 }
 487
 488 static inline bool
 489 check_constant (struct symbol *sym)
 490 {
 491   enum address_class sc = sym->aclass ();
 492   return (sc == LOC_BLOCK
 493           || sc == LOC_CONST
 494           || sc == LOC_CONST_BYTES
 495           || sc == LOC_LABEL);
 496 }
 497
 498 static inline bool
 499 check_constant (const block_symbol &sym)
 500 {
 501   /* We know the block is constant, so we only need to check the
 502      symbol.  */
 503   return check_constant (sym.symbol);
 504 }
 505
 506 template<typename T>
 507 static inline bool
 508 check_constant (const std::vector<T> &collection)
 509 {
 510   for (const auto &item : collection)
 511     if (!check_constant (item))
 512       return false;
 513   return true;
 514 }
 515
 516 template<typename S, typename T>
 517 static inline bool
 518 check_constant (const std::pair<S, T> &item)
 519 {
 520   return check_constant (item.first) && check_constant (item.second);
 521 }
 522
 523 /* Base class for concrete operations.  This class supplies an
 524    implementation of 'constant_p' that works by checking the
 525    operands.  */
 526 template<typename... Arg>
 527 class maybe_constant_operation
 528   : public tuple_holding_operation<Arg...>
 529 {
 530 public:
 531
 532   using tuple_holding_operation<Arg...>::tuple_holding_operation;
 533
 534   bool constant_p () const override
 535   {
 536     return do_check_constant<0, Arg...> (this->m_storage);
 537   }
 538
 539 private:
 540
 541   template<int I, typename... T>
 542   typename std::enable_if<I == sizeof... (T), bool>::type
 543   do_check_constant (const std::tuple<T...> &value) const
 544   {
 545     return true;
 546   }
 547
 548   template<int I, typename... T>
 549   typename std::enable_if<I < sizeof... (T), bool>::type
 550   do_check_constant (const std::tuple<T...> &value) const
 551   {
 552     if (!check_constant (std::get<I> (value)))
 553       return false;
 554     return do_check_constant<I + 1, T...> (value);
 555   }
 556 };
 557
 558 /* A floating-point constant.  The constant is encoded in the target
 559    format.  */
 560
 561 typedef std::array<gdb_byte, 16> float_data;
 562
 563 /* An operation that holds a floating-point constant of a given
 564    type.
 565
 566    This does not need the facilities provided by
 567    tuple_holding_operation, so it does not use it.  */
 568 class float_const_operation
 569   : public operation
 570 {
 571 public:
 572
 573   float_const_operation (struct type *type, float_data data)
 574     : m_type (type),
 575       m_data (data)
 576   {
 577   }
 578
 579   value *evaluate (struct type *expect_type,
 580                    struct expression *exp,
 581                    enum noside noside) override
 582   {
 583     return value_from_contents (m_type, m_data.data ());
 584   }
 585
 586   enum exp_opcode opcode () const override
 587   { return OP_FLOAT; }
 588
 589   bool constant_p () const override
 590   { return true; }
 591
 592   void dump (struct ui_file *stream, int depth) const override;
 593
 594 private:
 595
 596   struct type *m_type;
 597   float_data m_data;
 598 };
 599
 600 class scope_operation
 601   : public maybe_constant_operation<struct type *, std::string>
 602 {
 603 public:
 604
 605   using maybe_constant_operation::maybe_constant_operation;
 606
 607   value *evaluate (struct type *expect_type,
 608                    struct expression *exp,
 609                    enum noside noside) override
 610   {
 611     return eval_op_scope (expect_type, exp, noside,
 612                           std::get<0> (m_storage),
 613                           std::get<1> (m_storage).c_str ());
 614   }
 615
 616   value *evaluate_for_address (struct expression *exp,
 617                                enum noside noside) override;
 618
 619   value *evaluate_funcall (struct type *expect_type,
 620                            struct expression *exp,
 621                            enum noside noside,
 622                            const std::vector<operation_up> &args) override;
 623
 624   enum exp_opcode opcode () const override
 625   { return OP_SCOPE; }
 626
 627 protected:
 628
 629   void do_generate_ax (struct expression *exp,
 630                        struct agent_expr *ax,
 631                        struct axs_value *value,
 632                        struct type *cast_type)
 633     override;
 634 };
 635
 636 /* Compute the value of a variable.  */
 637 class var_value_operation
 638   : public maybe_constant_operation<block_symbol>
 639 {
 640 public:
 641
 642   using maybe_constant_operation::maybe_constant_operation;
 643
 644   value *evaluate (struct type *expect_type,
 645                    struct expression *exp,
 646                    enum noside noside) override;
 647
 648   value *evaluate_with_coercion (struct expression *exp,
 649                                  enum noside noside) override;
 650
 651   value *evaluate_for_sizeof (struct expression *exp, enum noside noside)
 652     override;
 653
 654   value *evaluate_for_cast (struct type *expect_type,
 655                             struct expression *exp,
 656                             enum noside noside) override;
 657
 658   value *evaluate_for_address (struct expression *exp, enum noside noside)
 659     override;
 660
 661   value *evaluate_funcall (struct type *expect_type,
 662                            struct expression *exp,
 663                            enum noside noside,
 664                            const std::vector<operation_up> &args) override;
 665
 666   enum exp_opcode opcode () const override
 667   { return OP_VAR_VALUE; }
 668
 669   /* Return the symbol referenced by this object.  */
 670   symbol *get_symbol () const
 671   {
 672     return std::get<0> (m_storage).symbol;
 673   }
 674
 675 protected:
 676
 677   void do_generate_ax (struct expression *exp,
 678                        struct agent_expr *ax,
 679                        struct axs_value *value,
 680                        struct type *cast_type)
 681     override;
 682 };
 683
 684 class long_const_operation
 685   : public tuple_holding_operation<struct type *, gdb_mpz>
 686 {
 687 public:
 688
 689   using tuple_holding_operation::tuple_holding_operation;
 690
 691   long_const_operation (struct type *type, LONGEST val)
 692     : long_const_operation (type, gdb_mpz (val))
 693   { }
 694
 695   value *evaluate (struct type *expect_type,
 696                    struct expression *exp,
 697                    enum noside noside) override
 698   {
 699     return value_from_mpz (std::get<0> (m_storage), std::get<1> (m_storage));
 700   }
 701
 702   enum exp_opcode opcode () const override
 703   { return OP_LONG; }
 704
 705   bool constant_p () const override
 706   { return true; }
 707
 708 protected:
 709
 710   LONGEST as_longest () const
 711   { return std::get<1> (m_storage).as_integer_truncate<LONGEST> (); }
 712
 713   void do_generate_ax (struct expression *exp,
 714                        struct agent_expr *ax,
 715                        struct axs_value *value,
 716                        struct type *cast_type)
 717     override;
 718 };
 719
 720 class var_msym_value_operation
 721   : public maybe_constant_operation<bound_minimal_symbol>
 722 {
 723 public:
 724
 725   using maybe_constant_operation::maybe_constant_operation;
 726
 727   value *evaluate (struct type *expect_type,
 728                    struct expression *exp,
 729                    enum noside noside) override
 730   {
 731     return eval_op_var_msym_value (expect_type, exp, noside, m_outermost,
 732                                    std::get<0> (m_storage));
 733   }
 734
 735   value *evaluate_for_sizeof (struct expression *exp, enum noside noside)
 736     override;
 737
 738   value *evaluate_for_address (struct expression *exp, enum noside noside)
 739     override;
 740
 741   value *evaluate_for_cast (struct type *expect_type,
 742                             struct expression *exp,
 743                             enum noside noside) override;
 744
 745   value *evaluate_funcall (struct type *expect_type,
 746                            struct expression *exp,
 747                            enum noside noside,
 748                            const std::vector<operation_up> &args) override
 749   {
 750     const char *name = std::get<0> (m_storage).minsym->print_name ();
 751     return operation::evaluate_funcall (expect_type, exp, noside, name, args);
 752   }
 753
 754   enum exp_opcode opcode () const override
 755   { return OP_VAR_MSYM_VALUE; }
 756
 757   void set_outermost () override
 758   {
 759     m_outermost = true;
 760   }
 761
 762 protected:
 763
 764   /* True if this is the outermost operation in the expression.  */
 765   bool m_outermost = false;
 766
 767   void do_generate_ax (struct expression *exp,
 768                        struct agent_expr *ax,
 769                        struct axs_value *value,
 770                        struct type *cast_type)
 771     override;
 772 };
 773
 774 class var_entry_value_operation
 775   : public tuple_holding_operation<symbol *>
 776 {
 777 public:
 778
 779   using tuple_holding_operation::tuple_holding_operation;
 780
 781   value *evaluate (struct type *expect_type,
 782                    struct expression *exp,
 783                    enum noside noside) override
 784   {
 785     return eval_op_var_entry_value (expect_type, exp, noside,
 786                                     std::get<0> (m_storage));
 787   }
 788
 789   enum exp_opcode opcode () const override
 790   { return OP_VAR_ENTRY_VALUE; }
 791 };
 792
 793 class func_static_var_operation
 794   : public maybe_constant_operation<operation_up, std::string>
 795 {
 796 public:
 797
 798   using maybe_constant_operation::maybe_constant_operation;
 799
 800   value *evaluate (struct type *expect_type,
 801                    struct expression *exp,
 802                    enum noside noside) override
 803   {
 804     value *func = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
 805     return eval_op_func_static_var (expect_type, exp, noside, func,
 806                                     std::get<1> (m_storage).c_str ());
 807   }
 808
 809   enum exp_opcode opcode () const override
 810   { return OP_FUNC_STATIC_VAR; }
 811 };
 812
 813 class last_operation
 814   : public tuple_holding_operation<int>
 815 {
 816 public:
 817
 818   using tuple_holding_operation::tuple_holding_operation;
 819
 820   value *evaluate (struct type *expect_type,
 821                    struct expression *exp,
 822                    enum noside noside) override
 823   {
 824     return access_value_history (std::get<0> (m_storage));
 825   }
 826
 827   enum exp_opcode opcode () const override
 828   { return OP_LAST; }
 829 };
 830
 831 class register_operation
 832   : public tuple_holding_operation<std::string>
 833 {
 834 public:
 835
 836   using tuple_holding_operation::tuple_holding_operation;
 837
 838   value *evaluate (struct type *expect_type,
 839                    struct expression *exp,
 840                    enum noside noside) override
 841   {
 842     return eval_op_register (expect_type, exp, noside,
 843                              std::get<0> (m_storage).c_str ());
 844   }
 845
 846   enum exp_opcode opcode () const override
 847   { return OP_REGISTER; }
 848
 849   /* Return the name of the register.  */
 850   const char *get_name () const
 851   {
 852     return std::get<0> (m_storage).c_str ();
 853   }
 854
 855 protected:
 856
 857   void do_generate_ax (struct expression *exp,
 858                        struct agent_expr *ax,
 859                        struct axs_value *value,
 860                        struct type *cast_type)
 861     override;
 862 };
 863
 864 class bool_operation
 865   : public tuple_holding_operation<bool>
 866 {
 867 public:
 868
 869   using tuple_holding_operation::tuple_holding_operation;
 870
 871   value *evaluate (struct type *expect_type,
 872                    struct expression *exp,
 873                    enum noside noside) override
 874   {
 875     struct type *type = language_bool_type (exp->language_defn, exp->gdbarch);
 876     return value_from_longest (type, std::get<0> (m_storage));
 877   }
 878
 879   enum exp_opcode opcode () const override
 880   { return OP_BOOL; }
 881
 882   bool constant_p () const override
 883   { return true; }
 884 };
 885
 886 class internalvar_operation
 887   : public tuple_holding_operation<internalvar *>
 888 {
 889 public:
 890
 891   using tuple_holding_operation::tuple_holding_operation;
 892
 893   value *evaluate (struct type *expect_type,
 894                    struct expression *exp,
 895                    enum noside noside) override
 896   {
 897     return value_of_internalvar (exp->gdbarch,
 898                                  std::get<0> (m_storage));
 899   }
 900
 901   internalvar *get_internalvar () const
 902   {
 903     return std::get<0> (m_storage);
 904   }
 905
 906   enum exp_opcode opcode () const override
 907   { return OP_INTERNALVAR; }
 908
 909 protected:
 910
 911   void do_generate_ax (struct expression *exp,
 912                        struct agent_expr *ax,
 913                        struct axs_value *value,
 914                        struct type *cast_type)
 915     override;
 916 };
 917
 918 class string_operation
 919   : public tuple_holding_operation<std::string>
 920 {
 921 public:
 922
 923   using tuple_holding_operation::tuple_holding_operation;
 924
 925   value *evaluate (struct type *expect_type,
 926                    struct expression *exp,
 927                    enum noside noside) override;
 928
 929   enum exp_opcode opcode () const override
 930   { return OP_STRING; }
 931 };
 932
 933 class ternop_slice_operation
 934   : public maybe_constant_operation<operation_up, operation_up, operation_up>
 935 {
 936 public:
 937
 938   using maybe_constant_operation::maybe_constant_operation;
 939
 940   value *evaluate (struct type *expect_type,
 941                    struct expression *exp,
 942                    enum noside noside) override
 943   {
 944     struct value *array
 945       = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
 946     struct value *low
 947       = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
 948     struct value *upper
 949       = std::get<2> (m_storage)->evaluate (nullptr, exp, noside);
 950     return eval_op_ternop (expect_type, exp, noside, array, low, upper);
 951   }
 952
 953   enum exp_opcode opcode () const override
 954   { return TERNOP_SLICE; }
 955 };
 956
 957 class ternop_cond_operation
 958   : public maybe_constant_operation<operation_up, operation_up, operation_up>
 959 {
 960 public:
 961
 962   using maybe_constant_operation::maybe_constant_operation;
 963
 964   value *evaluate (struct type *expect_type,
 965                    struct expression *exp,
 966                    enum noside noside) override
 967   {
 968     struct value *val
 969       = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
 970
 971     if (value_logical_not (val))
 972       return std::get<2> (m_storage)->evaluate (nullptr, exp, noside);
 973     return std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
 974   }
 975
 976   enum exp_opcode opcode () const override
 977   { return TERNOP_COND; }
 978
 979 protected:
 980
 981   void do_generate_ax (struct expression *exp,
 982                        struct agent_expr *ax,
 983                        struct axs_value *value,
 984                        struct type *cast_type)
 985     override;
 986 };
 987
 988 class complex_operation
 989   : public maybe_constant_operation<operation_up, operation_up, struct type *>
 990 {
 991 public:
 992
 993   using maybe_constant_operation::maybe_constant_operation;
 994
 995   value *evaluate (struct type *expect_type,
 996                    struct expression *exp,
 997                    enum noside noside) override
 998   {
 999     value *real = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
1000     value *imag = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
1001     return value_literal_complex (real, imag,
1002                                   std::get<2> (m_storage));
1003   }
1004
1005   enum exp_opcode opcode () const override
1006   { return OP_COMPLEX; }
1007 };
1008
1009 class structop_base_operation
1010   : public tuple_holding_operation<operation_up, std::string>
1011 {
1012 public:
1013
1014   /* Used for completion.  Return the field name.  */
1015   const std::string &get_string () const
1016   {
1017     return std::get<1> (m_storage);
1018   }
1019
1020   value *evaluate_funcall (struct type *expect_type,
1021                            struct expression *exp,
1022                            enum noside noside,
1023                            const std::vector<operation_up> &args) override;
1024
1025   /* Try to complete this operation in the context of EXP.  TRACKER is
1026      the completion tracker to update.  Return true if completion was
1027      possible, false otherwise.  */
1028   virtual bool complete (struct expression *exp, completion_tracker &tracker)
1029   {
1030     return complete (exp, tracker, "");
1031   }
1032
1033 protected:
1034
1035   /* Do the work of the public 'complete' method.  PREFIX is prepended
1036      to each result.  */
1037   bool complete (struct expression *exp, completion_tracker &tracker,
1038                  const char *prefix);
1039
1040   using tuple_holding_operation::tuple_holding_operation;
1041 };
1042
1043 class structop_operation
1044   : public structop_base_operation
1045 {
1046 public:
1047
1048   using structop_base_operation::structop_base_operation;
1049
1050   value *evaluate (struct type *expect_type,
1051                    struct expression *exp,
1052                    enum noside noside) override
1053   {
1054     value *val =std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
1055     return eval_op_structop_struct (expect_type, exp, noside, val,
1056                                     std::get<1> (m_storage).c_str ());
1057   }
1058
1059   enum exp_opcode opcode () const override
1060   { return STRUCTOP_STRUCT; }
1061
1062 protected:
1063
1064   void do_generate_ax (struct expression *exp,
1065                        struct agent_expr *ax,
1066                        struct axs_value *value,
1067                        struct type *cast_type)
1068     override
1069   {
1070     gen_expr_structop (exp, STRUCTOP_STRUCT,
1071                        std::get<0> (this->m_storage).get (),
1072                        std::get<1> (this->m_storage).c_str (),
1073                        ax, value);
1074   }
1075 };
1076
1077 class structop_ptr_operation
1078   : public structop_base_operation
1079 {
1080 public:
1081
1082   using structop_base_operation::structop_base_operation;
1083
1084   value *evaluate (struct type *expect_type,
1085                    struct expression *exp,
1086                    enum noside noside) override
1087   {
1088     value *val = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
1089     return eval_op_structop_ptr (expect_type, exp, noside, val,
1090                                  std::get<1> (m_storage).c_str ());
1091   }
1092
1093   enum exp_opcode opcode () const override
1094   { return STRUCTOP_PTR; }
1095
1096 protected:
1097
1098   void do_generate_ax (struct expression *exp,
1099                        struct agent_expr *ax,
1100                        struct axs_value *value,
1101                        struct type *cast_type)
1102     override
1103   {
1104     gen_expr_structop (exp, STRUCTOP_PTR,
1105                        std::get<0> (this->m_storage).get (),
1106                        std::get<1> (this->m_storage).c_str (),
1107                        ax, value);
1108   }
1109 };
1110
1111 class structop_member_base
1112   : public tuple_holding_operation<operation_up, operation_up>
1113 {
1114 public:
1115
1116   using tuple_holding_operation::tuple_holding_operation;
1117
1118   value *evaluate_funcall (struct type *expect_type,
1119                            struct expression *exp,
1120                            enum noside noside,
1121                            const std::vector<operation_up> &args) override;
1122 };
1123
1124 class structop_member_operation
1125   : public structop_member_base
1126 {
1127 public:
1128
1129   using structop_member_base::structop_member_base;
1130
1131   value *evaluate (struct type *expect_type,
1132                    struct expression *exp,
1133                    enum noside noside) override
1134   {
1135     value *lhs
1136       = std::get<0> (m_storage)->evaluate_for_address (exp, noside);
1137     value *rhs
1138       = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
1139     return eval_op_member (expect_type, exp, noside, lhs, rhs);
1140   }
1141
1142   enum exp_opcode opcode () const override
1143   { return STRUCTOP_MEMBER; }
1144 };
1145
1146 class structop_mptr_operation
1147   : public structop_member_base
1148 {
1149 public:
1150
1151   using structop_member_base::structop_member_base;
1152
1153   value *evaluate (struct type *expect_type,
1154                    struct expression *exp,
1155                    enum noside noside) override
1156   {
1157     value *lhs
1158       = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
1159     value *rhs
1160       = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
1161     return eval_op_member (expect_type, exp, noside, lhs, rhs);
1162   }
1163
1164   enum exp_opcode opcode () const override
1165   { return STRUCTOP_MPTR; }
1166 };
1167
1168 class concat_operation
1169   : public maybe_constant_operation<operation_up, operation_up>
1170 {
1171 public:
1172
1173   using maybe_constant_operation::maybe_constant_operation;
1174
1175   value *evaluate (struct type *expect_type,
1176                    struct expression *exp,
1177                    enum noside noside) override
1178   {
1179     value *lhs
1180       = std::get<0> (m_storage)->evaluate_with_coercion (exp, noside);
1181     value *rhs
1182       = std::get<1> (m_storage)->evaluate_with_coercion (exp, noside);
1183     return value_concat (lhs, rhs);
1184   }
1185
1186   enum exp_opcode opcode () const override
1187   { return BINOP_CONCAT; }
1188 };
1189
1190 class add_operation
1191   : public maybe_constant_operation<operation_up, operation_up>
1192 {
1193 public:
1194
1195   using maybe_constant_operation::maybe_constant_operation;
1196
1197   value *evaluate (struct type *expect_type,
1198                    struct expression *exp,
1199                    enum noside noside) override
1200   {
1201     value *lhs
1202       = std::get<0> (m_storage)->evaluate_with_coercion (exp, noside);
1203     value *rhs
1204       = std::get<1> (m_storage)->evaluate_with_coercion (exp, noside);
1205     return eval_op_add (expect_type, exp, noside, lhs, rhs);
1206   }
1207
1208   enum exp_opcode opcode () const override
1209   { return BINOP_ADD; }
1210
1211 protected:
1212
1213   void do_generate_ax (struct expression *exp,
1214                        struct agent_expr *ax,
1215                        struct axs_value *value,
1216                        struct type *cast_type)
1217     override
1218   {
1219     gen_expr_binop (exp, BINOP_ADD,
1220                     std::get<0> (this->m_storage).get (),
1221                     std::get<1> (this->m_storage).get (),
1222                     ax, value);
1223   }
1224 };
1225
1226 class sub_operation
1227   : public maybe_constant_operation<operation_up, operation_up>
1228 {
1229 public:
1230
1231   using maybe_constant_operation::maybe_constant_operation;
1232
1233   value *evaluate (struct type *expect_type,
1234                    struct expression *exp,
1235                    enum noside noside) override
1236   {
1237     value *lhs
1238       = std::get<0> (m_storage)->evaluate_with_coercion (exp, noside);
1239     value *rhs
1240       = std::get<1> (m_storage)->evaluate_with_coercion (exp, noside);
1241     return eval_op_sub (expect_type, exp, noside, lhs, rhs);
1242   }
1243
1244   enum exp_opcode opcode () const override
1245   { return BINOP_SUB; }
1246
1247 protected:
1248
1249   void do_generate_ax (struct expression *exp,
1250                        struct agent_expr *ax,
1251                        struct axs_value *value,
1252                        struct type *cast_type)
1253     override
1254   {
1255     gen_expr_binop (exp, BINOP_SUB,
1256                     std::get<0> (this->m_storage).get (),
1257                     std::get<1> (this->m_storage).get (),
1258                     ax, value);
1259   }
1260 };
1261
1262 typedef struct value *binary_ftype (struct type *expect_type,
1263                                     struct expression *exp,
1264                                     enum noside noside, enum exp_opcode op,
1265                                     struct value *arg1, struct value *arg2);
1266
1267 template<enum exp_opcode OP, binary_ftype FUNC>
1268 class binop_operation
1269   : public maybe_constant_operation<operation_up, operation_up>
1270 {
1271 public:
1272
1273   using maybe_constant_operation::maybe_constant_operation;
1274
1275   value *evaluate (struct type *expect_type,
1276                    struct expression *exp,
1277                    enum noside noside) override
1278   {
1279     value *lhs
1280       = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
1281     value *rhs
1282       = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
1283     return FUNC (expect_type, exp, noside, OP, lhs, rhs);
1284   }
1285
1286   enum exp_opcode opcode () const override
1287   { return OP; }
1288 };
1289
1290 template<enum exp_opcode OP, binary_ftype FUNC>
1291 class usual_ax_binop_operation
1292   : public binop_operation<OP, FUNC>
1293 {
1294 public:
1295
1296   using binop_operation<OP, FUNC>::binop_operation;
1297
1298 protected:
1299
1300   void do_generate_ax (struct expression *exp,
1301                        struct agent_expr *ax,
1302                        struct axs_value *value,
1303                        struct type *cast_type)
1304     override
1305   {
1306     gen_expr_binop (exp, OP,
1307                     std::get<0> (this->m_storage).get (),
1308                     std::get<1> (this->m_storage).get (),
1309                     ax, value);
1310   }
1311 };
1312
1313 using exp_operation = binop_operation<BINOP_EXP, eval_op_binary>;
1314 using intdiv_operation = binop_operation<BINOP_INTDIV, eval_op_binary>;
1315 using mod_operation = binop_operation<BINOP_MOD, eval_op_binary>;
1316
1317 using mul_operation = usual_ax_binop_operation<BINOP_MUL, eval_op_binary>;
1318 using div_operation = usual_ax_binop_operation<BINOP_DIV, eval_op_binary>;
1319 using rem_operation = usual_ax_binop_operation<BINOP_REM, eval_op_binary>;
1320 using lsh_operation = usual_ax_binop_operation<BINOP_LSH, eval_op_binary>;
1321 using rsh_operation = usual_ax_binop_operation<BINOP_RSH, eval_op_binary>;
1322 using bitwise_and_operation
1323      = usual_ax_binop_operation<BINOP_BITWISE_AND, eval_op_binary>;
1324 using bitwise_ior_operation
1325      = usual_ax_binop_operation<BINOP_BITWISE_IOR, eval_op_binary>;
1326 using bitwise_xor_operation
1327      = usual_ax_binop_operation<BINOP_BITWISE_XOR, eval_op_binary>;
1328
1329 class subscript_operation
1330   : public usual_ax_binop_operation<BINOP_SUBSCRIPT, eval_op_subscript>
1331 {
1332 public:
1333   using usual_ax_binop_operation<BINOP_SUBSCRIPT,
1334                                  eval_op_subscript>::usual_ax_binop_operation;
1335
1336   value *evaluate_for_sizeof (struct expression *exp,
1337                               enum noside noside) override;
1338 };
1339
1340 /* Implementation of comparison operations.  */
1341 template<enum exp_opcode OP, binary_ftype FUNC>
1342 class comparison_operation
1343   : public usual_ax_binop_operation<OP, FUNC>
1344 {
1345 public:
1346
1347   using usual_ax_binop_operation<OP, FUNC>::usual_ax_binop_operation;
1348
1349   value *evaluate (struct type *expect_type,
1350                    struct expression *exp,
1351                    enum noside noside) override
1352   {
1353     value *lhs
1354       = std::get<0> (this->m_storage)->evaluate (nullptr, exp, noside);
1355     value *rhs
1356       = std::get<1> (this->m_storage)->evaluate (lhs->type (), exp,
1357                                                  noside);
1358     return FUNC (expect_type, exp, noside, OP, lhs, rhs);
1359   }
1360 };
1361
1362 class equal_operation
1363   : public comparison_operation<BINOP_EQUAL, eval_op_equal>
1364 {
1365 public:
1366
1367   using comparison_operation::comparison_operation;
1368
1369   operation *get_lhs () const
1370   {
1371     return std::get<0> (m_storage).get ();
1372   }
1373
1374   operation *get_rhs () const
1375   {
1376     return std::get<1> (m_storage).get ();
1377   }
1378 };
1379
1380 using notequal_operation
1381      = comparison_operation<BINOP_NOTEQUAL, eval_op_notequal>;
1382 using less_operation = comparison_operation<BINOP_LESS, eval_op_less>;
1383 using gtr_operation = comparison_operation<BINOP_GTR, eval_op_gtr>;
1384 using geq_operation = comparison_operation<BINOP_GEQ, eval_op_geq>;
1385 using leq_operation = comparison_operation<BINOP_LEQ, eval_op_leq>;
1386
1387 /* Implement the GDB '@' repeat operator.  */
1388 class repeat_operation
1389   : public binop_operation<BINOP_REPEAT, eval_op_repeat>
1390 {
1391   using binop_operation<BINOP_REPEAT, eval_op_repeat>::binop_operation;
1392
1393 protected:
1394
1395   void do_generate_ax (struct expression *exp,
1396                        struct agent_expr *ax,
1397                        struct axs_value *value,
1398                        struct type *cast_type)
1399     override;
1400 };
1401
1402 /* C-style comma operator.  */
1403 class comma_operation
1404   : public maybe_constant_operation<operation_up, operation_up>
1405 {
1406 public:
1407
1408   using maybe_constant_operation::maybe_constant_operation;
1409
1410   value *evaluate (struct type *expect_type,
1411                    struct expression *exp,
1412                    enum noside noside) override
1413   {
1414     /* The left-hand-side is only evaluated for side effects, so don't
1415        bother in other modes.  */
1416     if (noside == EVAL_NORMAL)
1417       std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
1418     return std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
1419   }
1420
1421   enum exp_opcode opcode () const override
1422   { return BINOP_COMMA; }
1423
1424 protected:
1425
1426   void do_generate_ax (struct expression *exp,
1427                        struct agent_expr *ax,
1428                        struct axs_value *value,
1429                        struct type *cast_type)
1430     override;
1431 };
1432
1433 typedef struct value *unary_ftype (struct type *expect_type,
1434                                    struct expression *exp,
1435                                    enum noside noside, enum exp_opcode op,
1436                                    struct value *arg1);
1437
1438 /* Base class for unary operations.  */
1439 template<enum exp_opcode OP, unary_ftype FUNC>
1440 class unop_operation
1441   : public maybe_constant_operation<operation_up>
1442 {
1443 public:
1444
1445   using maybe_constant_operation::maybe_constant_operation;
1446
1447   value *evaluate (struct type *expect_type,
1448                    struct expression *exp,
1449                    enum noside noside) override
1450   {
1451     value *val = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
1452     return FUNC (expect_type, exp, noside, OP, val);
1453   }
1454
1455   enum exp_opcode opcode () const override
1456   { return OP; }
1457 };
1458
1459 /* Unary operations that can also be turned into agent expressions in
1460    the "usual" way.  */
1461 template<enum exp_opcode OP, unary_ftype FUNC>
1462 class usual_ax_unop_operation
1463   : public unop_operation<OP, FUNC>
1464 {
1465   using unop_operation<OP, FUNC>::unop_operation;
1466
1467 protected:
1468
1469   void do_generate_ax (struct expression *exp,
1470                        struct agent_expr *ax,
1471                        struct axs_value *value,
1472                        struct type *cast_type)
1473     override
1474   {
1475     gen_expr_unop (exp, OP,
1476                    std::get<0> (this->m_storage).get (),
1477                    ax, value);
1478   }
1479 };
1480
1481 using unary_plus_operation = usual_ax_unop_operation<UNOP_PLUS, eval_op_plus>;
1482 using unary_neg_operation = usual_ax_unop_operation<UNOP_NEG, eval_op_neg>;
1483 using unary_complement_operation
1484      = usual_ax_unop_operation<UNOP_COMPLEMENT, eval_op_complement>;
1485 using unary_logical_not_operation
1486      = usual_ax_unop_operation<UNOP_LOGICAL_NOT, eval_op_lognot>;
1487
1488 /* Handle pre- and post- increment and -decrement.  */
1489 template<enum exp_opcode OP, unary_ftype FUNC>
1490 class unop_incr_operation
1491   : public tuple_holding_operation<operation_up>
1492 {
1493 public:
1494
1495   using tuple_holding_operation::tuple_holding_operation;
1496
1497   value *evaluate (struct type *expect_type,
1498                    struct expression *exp,
1499                    enum noside noside) override
1500   {
1501     value *val = std::get<0> (m_storage)->evaluate (expect_type, exp, noside);
1502     return FUNC (expect_type, exp, noside, OP, val);
1503   }
1504
1505   enum exp_opcode opcode () const override
1506   { return OP; }
1507 };
1508
1509 using preinc_operation
1510      = unop_incr_operation<UNOP_PREINCREMENT, eval_op_preinc>;
1511 using predec_operation
1512      = unop_incr_operation<UNOP_PREDECREMENT, eval_op_predec>;
1513 using postinc_operation
1514      = unop_incr_operation<UNOP_POSTINCREMENT, eval_op_postinc>;
1515 using postdec_operation
1516      = unop_incr_operation<UNOP_POSTDECREMENT, eval_op_postdec>;
1517
1518 /* Base class for implementations of UNOP_IND.  */
1519 class unop_ind_base_operation
1520   : public tuple_holding_operation<operation_up>
1521 {
1522 public:
1523
1524   using tuple_holding_operation::tuple_holding_operation;
1525
1526   value *evaluate (struct type *expect_type,
1527                    struct expression *exp,
1528                    enum noside noside) override
1529   {
1530     if (expect_type != nullptr && expect_type->code () == TYPE_CODE_PTR)
1531       expect_type = check_typedef (expect_type)->target_type ();
1532     value *val = std::get<0> (m_storage)->evaluate (expect_type, exp, noside);
1533     return eval_op_ind (expect_type, exp, noside, val);
1534   }
1535
1536   value *evaluate_for_address (struct expression *exp,
1537                                enum noside noside) override;
1538
1539   value *evaluate_for_sizeof (struct expression *exp,
1540                               enum noside noside) override;
1541
1542   enum exp_opcode opcode () const override
1543   { return UNOP_IND; }
1544 };
1545
1546 /* Ordinary UNOP_IND implementation.  */
1547 class unop_ind_operation
1548   : public unop_ind_base_operation
1549 {
1550 public:
1551
1552   using unop_ind_base_operation::unop_ind_base_operation;
1553
1554 protected:
1555
1556   void do_generate_ax (struct expression *exp,
1557                        struct agent_expr *ax,
1558                        struct axs_value *value,
1559                        struct type *cast_type)
1560     override
1561   {
1562     gen_expr_unop (exp, UNOP_IND,
1563                    std::get<0> (this->m_storage).get (),
1564                    ax, value);
1565   }
1566 };
1567
1568 /* Implement OP_TYPE.  */
1569 class type_operation
1570   : public tuple_holding_operation<struct type *>
1571 {
1572 public:
1573
1574   using tuple_holding_operation::tuple_holding_operation;
1575
1576   value *evaluate (struct type *expect_type,
1577                    struct expression *exp,
1578                    enum noside noside) override
1579   {
1580     return eval_op_type (expect_type, exp, noside, std::get<0> (m_storage));
1581   }
1582
1583   enum exp_opcode opcode () const override
1584   { return OP_TYPE; }
1585
1586   bool constant_p () const override
1587   { return true; }
1588 };
1589
1590 /* Implement the "typeof" operation.  */
1591 class typeof_operation
1592   : public maybe_constant_operation<operation_up>
1593 {
1594 public:
1595
1596   using maybe_constant_operation::maybe_constant_operation;
1597
1598   value *evaluate (struct type *expect_type,
1599                    struct expression *exp,
1600                    enum noside noside) override
1601   {
1602     if (noside == EVAL_AVOID_SIDE_EFFECTS)
1603       return std::get<0> (m_storage)->evaluate (nullptr, exp,
1604                                                 EVAL_AVOID_SIDE_EFFECTS);
1605     else
1606       error (_("Attempt to use a type as an expression"));
1607   }
1608
1609   enum exp_opcode opcode () const override
1610   { return OP_TYPEOF; }
1611 };
1612
1613 /* Implement 'decltype'.  */
1614 class decltype_operation
1615   : public maybe_constant_operation<operation_up>
1616 {
1617 public:
1618
1619   using maybe_constant_operation::maybe_constant_operation;
1620
1621   value *evaluate (struct type *expect_type,
1622                    struct expression *exp,
1623                    enum noside noside) override
1624   {
1625     if (noside == EVAL_AVOID_SIDE_EFFECTS)
1626       {
1627         value *result
1628           = std::get<0> (m_storage)->evaluate (nullptr, exp,
1629                                                EVAL_AVOID_SIDE_EFFECTS);
1630         enum exp_opcode sub_op = std::get<0> (m_storage)->opcode ();
1631         if (sub_op == BINOP_SUBSCRIPT
1632             || sub_op == STRUCTOP_MEMBER
1633             || sub_op == STRUCTOP_MPTR
1634             || sub_op == UNOP_IND
1635             || sub_op == STRUCTOP_STRUCT
1636             || sub_op == STRUCTOP_PTR
1637             || sub_op == OP_SCOPE)
1638           {
1639             struct type *type = result->type ();
1640
1641             if (!TYPE_IS_REFERENCE (type))
1642               {
1643                 type = lookup_lvalue_reference_type (type);
1644                 result = value::allocate (type);
1645               }
1646           }
1647
1648         return result;
1649       }
1650     else
1651       error (_("Attempt to use a type as an expression"));
1652   }
1653
1654   enum exp_opcode opcode () const override
1655   { return OP_DECLTYPE; }
1656 };
1657
1658 /* Implement 'typeid'.  */
1659 class typeid_operation
1660   : public tuple_holding_operation<operation_up>
1661 {
1662 public:
1663
1664   using tuple_holding_operation::tuple_holding_operation;
1665
1666   value *evaluate (struct type *expect_type,
1667                    struct expression *exp,
1668                    enum noside noside) override
1669   {
1670     enum exp_opcode sub_op = std::get<0> (m_storage)->opcode ();
1671     enum noside sub_noside
1672       = ((sub_op == OP_TYPE || sub_op == OP_DECLTYPE || sub_op == OP_TYPEOF)
1673          ? EVAL_AVOID_SIDE_EFFECTS
1674          : noside);
1675
1676     value *result = std::get<0> (m_storage)->evaluate (nullptr, exp,
1677                                                        sub_noside);
1678     if (noside != EVAL_NORMAL)
1679       return value::allocate (cplus_typeid_type (exp->gdbarch));
1680     return cplus_typeid (result);
1681   }
1682
1683   enum exp_opcode opcode () const override
1684   { return OP_TYPEID; }
1685 };
1686
1687 /* Implement the address-of operation.  */
1688 class unop_addr_operation
1689   : public maybe_constant_operation<operation_up>
1690 {
1691 public:
1692
1693   using maybe_constant_operation::maybe_constant_operation;
1694
1695   value *evaluate (struct type *expect_type,
1696                    struct expression *exp,
1697                    enum noside noside) override
1698   {
1699     /* C++: check for and handle pointer to members.  */
1700     return std::get<0> (m_storage)->evaluate_for_address (exp, noside);
1701   }
1702
1703   enum exp_opcode opcode () const override
1704   { return UNOP_ADDR; }
1705
1706   /* Return the subexpression.  */
1707   const operation_up &get_expression () const
1708   {
1709     return std::get<0> (m_storage);
1710   }
1711
1712 protected:
1713
1714   void do_generate_ax (struct expression *exp,
1715                        struct agent_expr *ax,
1716                        struct axs_value *value,
1717                        struct type *cast_type)
1718     override
1719   {
1720     gen_expr_unop (exp, UNOP_ADDR,
1721                    std::get<0> (this->m_storage).get (),
1722                    ax, value);
1723   }
1724 };
1725
1726 /* Implement 'sizeof'.  */
1727 class unop_sizeof_operation
1728   : public maybe_constant_operation<operation_up>
1729 {
1730 public:
1731
1732   using maybe_constant_operation::maybe_constant_operation;
1733
1734   value *evaluate (struct type *expect_type,
1735                    struct expression *exp,
1736                    enum noside noside) override
1737   {
1738     return std::get<0> (m_storage)->evaluate_for_sizeof (exp, noside);
1739   }
1740
1741   enum exp_opcode opcode () const override
1742   { return UNOP_SIZEOF; }
1743
1744 protected:
1745
1746   void do_generate_ax (struct expression *exp,
1747                        struct agent_expr *ax,
1748                        struct axs_value *value,
1749                        struct type *cast_type)
1750     override;
1751 };
1752
1753 /* Implement 'alignof'.  */
1754 class unop_alignof_operation
1755   : public maybe_constant_operation<operation_up>
1756 {
1757 public:
1758
1759   using maybe_constant_operation::maybe_constant_operation;
1760
1761   value *evaluate (struct type *expect_type,
1762                    struct expression *exp,
1763                    enum noside noside) override
1764   {
1765     value *val = std::get<0> (m_storage)->evaluate (nullptr, exp,
1766                                                     EVAL_AVOID_SIDE_EFFECTS);
1767     return eval_op_alignof (expect_type, exp, noside, val);
1768   }
1769
1770   enum exp_opcode opcode () const override
1771   { return UNOP_ALIGNOF; }
1772 };
1773
1774 /* Implement UNOP_MEMVAL.  */
1775 class unop_memval_operation
1776   : public tuple_holding_operation<operation_up, struct type *>
1777 {
1778 public:
1779
1780   using tuple_holding_operation::tuple_holding_operation;
1781
1782   value *evaluate (struct type *expect_type,
1783                    struct expression *exp,
1784                    enum noside noside) override
1785   {
1786     value *val = std::get<0> (m_storage)->evaluate (expect_type, exp, noside);
1787     return eval_op_memval (expect_type, exp, noside, val,
1788                            std::get<1> (m_storage));
1789   }
1790
1791   value *evaluate_for_sizeof (struct expression *exp,
1792                               enum noside noside) override;
1793
1794   value *evaluate_for_address (struct expression *exp,
1795                                enum noside noside) override;
1796
1797   enum exp_opcode opcode () const override
1798   { return UNOP_MEMVAL; }
1799
1800   /* Return the type referenced by this object.  */
1801   struct type *get_type () const
1802   {
1803     return std::get<1> (m_storage);
1804   }
1805
1806 protected:
1807
1808   void do_generate_ax (struct expression *exp,
1809                        struct agent_expr *ax,
1810                        struct axs_value *value,
1811                        struct type *cast_type)
1812     override;
1813 };
1814
1815 /* Implement UNOP_MEMVAL_TYPE.  */
1816 class unop_memval_type_operation
1817   : public tuple_holding_operation<operation_up, operation_up>
1818 {
1819 public:
1820
1821   using tuple_holding_operation::tuple_holding_operation;
1822
1823   value *evaluate (struct type *expect_type,
1824                    struct expression *exp,
1825                    enum noside noside) override
1826   {
1827     value *typeval
1828       = std::get<0> (m_storage)->evaluate (expect_type, exp,
1829                                            EVAL_AVOID_SIDE_EFFECTS);
1830     struct type *type = typeval->type ();
1831     value *val = std::get<1> (m_storage)->evaluate (expect_type, exp, noside);
1832     return eval_op_memval (expect_type, exp, noside, val, type);
1833   }
1834
1835   value *evaluate_for_sizeof (struct expression *exp,
1836                               enum noside noside) override;
1837
1838   value *evaluate_for_address (struct expression *exp,
1839                                enum noside noside) override;
1840
1841   enum exp_opcode opcode () const override
1842   { return UNOP_MEMVAL_TYPE; }
1843
1844 protected:
1845
1846   void do_generate_ax (struct expression *exp,
1847                        struct agent_expr *ax,
1848                        struct axs_value *value,
1849                        struct type *cast_type)
1850     override;
1851 };
1852
1853 /* Implement the 'this' expression.  */
1854 class op_this_operation
1855   : public tuple_holding_operation<>
1856 {
1857 public:
1858
1859   using tuple_holding_operation::tuple_holding_operation;
1860
1861   value *evaluate (struct type *expect_type,
1862                    struct expression *exp,
1863                    enum noside noside) override
1864   {
1865     return value_of_this (exp->language_defn);
1866   }
1867
1868   enum exp_opcode opcode () const override
1869   { return OP_THIS; }
1870
1871 protected:
1872
1873   void do_generate_ax (struct expression *exp,
1874                        struct agent_expr *ax,
1875                        struct axs_value *value,
1876                        struct type *cast_type)
1877     override;
1878 };
1879
1880 /* Implement the "type instance" operation.  */
1881 class type_instance_operation
1882   : public tuple_holding_operation<type_instance_flags, std::vector<type *>,
1883                                    operation_up>
1884 {
1885 public:
1886
1887   using tuple_holding_operation::tuple_holding_operation;
1888
1889   value *evaluate (struct type *expect_type,
1890                    struct expression *exp,
1891                    enum noside noside) override;
1892
1893   enum exp_opcode opcode () const override
1894   { return TYPE_INSTANCE; }
1895 };
1896
1897 /* The assignment operator.  */
1898 class assign_operation
1899   : public tuple_holding_operation<operation_up, operation_up>
1900 {
1901 public:
1902
1903   using tuple_holding_operation::tuple_holding_operation;
1904
1905   value *evaluate (struct type *expect_type,
1906                    struct expression *exp,
1907                    enum noside noside) override
1908   {
1909     value *lhs = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
1910     /* Special-case assignments where the left-hand-side is a
1911        convenience variable -- in these, don't bother setting an
1912        expected type.  This avoids a weird case where re-assigning a
1913        string or array to an internal variable could error with "Too
1914        many array elements".  */
1915     struct type *xtype = (lhs->lval () == lval_internalvar
1916                           ? nullptr
1917                           : lhs->type ());
1918     value *rhs = std::get<1> (m_storage)->evaluate (xtype, exp, noside);
1919
1920     if (noside == EVAL_AVOID_SIDE_EFFECTS)
1921       return lhs;
1922     if (binop_user_defined_p (BINOP_ASSIGN, lhs, rhs))
1923       return value_x_binop (lhs, rhs, BINOP_ASSIGN, OP_NULL, noside);
1924     else
1925       return value_assign (lhs, rhs);
1926   }
1927
1928   enum exp_opcode opcode () const override
1929   { return BINOP_ASSIGN; }
1930
1931   /* Return the left-hand-side of the assignment.  */
1932   operation *get_lhs () const
1933   {
1934     return std::get<0> (m_storage).get ();
1935   }
1936
1937 protected:
1938
1939   void do_generate_ax (struct expression *exp,
1940                        struct agent_expr *ax,
1941                        struct axs_value *value,
1942                        struct type *cast_type)
1943     override;
1944 };
1945
1946 /* Assignment with modification, like "+=".  */
1947 class assign_modify_operation
1948   : public tuple_holding_operation<exp_opcode, operation_up, operation_up>
1949 {
1950 public:
1951
1952   using tuple_holding_operation::tuple_holding_operation;
1953
1954   value *evaluate (struct type *expect_type,
1955                    struct expression *exp,
1956                    enum noside noside) override
1957   {
1958     value *lhs = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
1959     value *rhs = std::get<2> (m_storage)->evaluate (expect_type, exp, noside);
1960     return eval_binop_assign_modify (expect_type, exp, noside,
1961                                      std::get<0> (m_storage), lhs, rhs);
1962   }
1963
1964   enum exp_opcode opcode () const override
1965   { return BINOP_ASSIGN_MODIFY; }
1966
1967 protected:
1968
1969   void do_generate_ax (struct expression *exp,
1970                        struct agent_expr *ax,
1971                        struct axs_value *value,
1972                        struct type *cast_type)
1973     override;
1974 };
1975
1976 /* Not a cast!  Extract a value of a given type from the contents of a
1977    value.  The new value is extracted from the least significant bytes
1978    of the old value.  The new value's type must be no bigger than the
1979    old values type.  */
1980 class unop_extract_operation
1981   : public maybe_constant_operation<operation_up, struct type *>
1982 {
1983 public:
1984
1985   using maybe_constant_operation::maybe_constant_operation;
1986
1987   value *evaluate (struct type *expect_type, struct expression *exp,
1988                    enum noside noside) override;
1989
1990   enum exp_opcode opcode () const override
1991   { return UNOP_EXTRACT; }
1992
1993   /* Return the type referenced by this object.  */
1994   struct type *get_type () const
1995   {
1996     return std::get<1> (m_storage);
1997   }
1998
1999 protected:
2000
2001   void do_generate_ax (struct expression *exp,
2002                        struct agent_expr *ax,
2003                        struct axs_value *value,
2004                        struct type *cast_type) override;
2005 };
2006
2007 /* A type cast.  */
2008 class unop_cast_operation
2009   : public maybe_constant_operation<operation_up, struct type *>
2010 {
2011 public:
2012
2013   using maybe_constant_operation::maybe_constant_operation;
2014
2015   value *evaluate (struct type *expect_type,
2016                    struct expression *exp,
2017                    enum noside noside) override
2018   {
2019     return std::get<0> (m_storage)->evaluate_for_cast (std::get<1> (m_storage),
2020                                                        exp, noside);
2021   }
2022
2023   enum exp_opcode opcode () const override
2024   { return UNOP_CAST; }
2025
2026   /* Return the type referenced by this object.  */
2027   struct type *get_type () const
2028   {
2029     return std::get<1> (m_storage);
2030   }
2031
2032 protected:
2033
2034   void do_generate_ax (struct expression *exp,
2035                        struct agent_expr *ax,
2036                        struct axs_value *value,
2037                        struct type *cast_type)
2038     override;
2039 };
2040
2041 /* A cast, but the type comes from an expression, not a "struct
2042    type".  */
2043 class unop_cast_type_operation
2044   : public maybe_constant_operation<operation_up, operation_up>
2045 {
2046 public:
2047
2048   using maybe_constant_operation::maybe_constant_operation;
2049
2050   value *evaluate (struct type *expect_type,
2051                    struct expression *exp,
2052                    enum noside noside) override
2053   {
2054     value *val = std::get<0> (m_storage)->evaluate (nullptr, exp,
2055                                                     EVAL_AVOID_SIDE_EFFECTS);
2056     return std::get<1> (m_storage)->evaluate_for_cast (val->type (),
2057                                                        exp, noside);
2058   }
2059
2060   enum exp_opcode opcode () const override
2061   { return UNOP_CAST_TYPE; }
2062
2063 protected:
2064
2065   void do_generate_ax (struct expression *exp,
2066                        struct agent_expr *ax,
2067                        struct axs_value *value,
2068                        struct type *cast_type)
2069     override;
2070 };
2071
2072 typedef value *cxx_cast_ftype (struct type *, value *);
2073
2074 /* This implements dynamic_cast and reinterpret_cast.  static_cast and
2075    const_cast are handled by the ordinary case operations.  */
2076 template<exp_opcode OP, cxx_cast_ftype FUNC>
2077 class cxx_cast_operation
2078   : public maybe_constant_operation<operation_up, operation_up>
2079 {
2080 public:
2081
2082   using maybe_constant_operation::maybe_constant_operation;
2083
2084   value *evaluate (struct type *expect_type,
2085                    struct expression *exp,
2086                    enum noside noside) override
2087   {
2088     value *val = std::get<0> (m_storage)->evaluate (nullptr, exp,
2089                                                     EVAL_AVOID_SIDE_EFFECTS);
2090     struct type *type = val->type ();
2091     value *rhs = std::get<1> (m_storage)->evaluate (type, exp, noside);
2092     return FUNC (type, rhs);
2093   }
2094
2095   enum exp_opcode opcode () const override
2096   { return OP; }
2097 };
2098
2099 using dynamic_cast_operation = cxx_cast_operation<UNOP_DYNAMIC_CAST,
2100                                                   value_dynamic_cast>;
2101 using reinterpret_cast_operation = cxx_cast_operation<UNOP_REINTERPRET_CAST,
2102                                                       value_reinterpret_cast>;
2103
2104 /* Multi-dimensional subscripting.  */
2105 class multi_subscript_operation
2106   : public tuple_holding_operation<operation_up, std::vector<operation_up>>
2107 {
2108 public:
2109
2110   using tuple_holding_operation::tuple_holding_operation;
2111
2112   value *evaluate (struct type *expect_type,
2113                    struct expression *exp,
2114                    enum noside noside) override;
2115
2116   enum exp_opcode opcode () const override
2117   { return MULTI_SUBSCRIPT; }
2118 };
2119
2120 /* The "&&" operator.  */
2121 class logical_and_operation
2122   : public maybe_constant_operation<operation_up, operation_up>
2123 {
2124 public:
2125
2126   using maybe_constant_operation::maybe_constant_operation;
2127
2128   value *evaluate (struct type *expect_type,
2129                    struct expression *exp,
2130                    enum noside noside) override;
2131
2132   enum exp_opcode opcode () const override
2133   { return BINOP_LOGICAL_AND; }
2134
2135 protected:
2136
2137   void do_generate_ax (struct expression *exp,
2138                        struct agent_expr *ax,
2139                        struct axs_value *value,
2140                        struct type *cast_type)
2141     override;
2142 };
2143
2144 /* The "||" operator.  */
2145 class logical_or_operation
2146   : public maybe_constant_operation<operation_up, operation_up>
2147 {
2148 public:
2149
2150   using maybe_constant_operation::maybe_constant_operation;
2151
2152   value *evaluate (struct type *expect_type,
2153                    struct expression *exp,
2154                    enum noside noside) override;
2155
2156   enum exp_opcode opcode () const override
2157   { return BINOP_LOGICAL_OR; }
2158
2159 protected:
2160
2161   void do_generate_ax (struct expression *exp,
2162                        struct agent_expr *ax,
2163                        struct axs_value *value,
2164                        struct type *cast_type)
2165     override;
2166 };
2167
2168 /* This class implements ADL (aka Koenig) function calls for C++.  It
2169    holds the name of the function to call, the block in which the
2170    lookup should be done, and a vector of arguments.  */
2171 class adl_func_operation
2172   : public tuple_holding_operation<std::string, const block *,
2173                                    std::vector<operation_up>>
2174 {
2175 public:
2176
2177   using tuple_holding_operation::tuple_holding_operation;
2178
2179   value *evaluate (struct type *expect_type,
2180                    struct expression *exp,
2181                    enum noside noside) override;
2182
2183   enum exp_opcode opcode () const override
2184   { return OP_ADL_FUNC; }
2185 };
2186
2187 /* The OP_ARRAY operation.  */
2188 class array_operation
2189   : public tuple_holding_operation<int, int, std::vector<operation_up>>
2190 {
2191 public:
2192
2193   using tuple_holding_operation::tuple_holding_operation;
2194
2195   value *evaluate (struct type *expect_type,
2196                    struct expression *exp,
2197                    enum noside noside) override;
2198
2199   enum exp_opcode opcode () const override
2200   { return OP_ARRAY; }
2201
2202 private:
2203
2204   struct value *evaluate_struct_tuple (struct value *struct_val,
2205                                        struct expression *exp,
2206                                        enum noside noside, int nargs);
2207 };
2208
2209 /* A function call.  This holds the callee operation and the
2210    arguments.  */
2211 class funcall_operation
2212   : public tuple_holding_operation<operation_up, std::vector<operation_up>>
2213 {
2214 public:
2215
2216   using tuple_holding_operation::tuple_holding_operation;
2217
2218   value *evaluate (struct type *expect_type,
2219                    struct expression *exp,
2220                    enum noside noside) override
2221   {
2222     return std::get<0> (m_storage)->evaluate_funcall (expect_type, exp, noside,
2223                                                       std::get<1> (m_storage));
2224   }
2225
2226   enum exp_opcode opcode () const override
2227   { return OP_FUNCALL; }
2228 };
2229
2230 } /* namespace expr */
2231
2232 #endif /* EXPOP_H */