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