gdb/eval.c - gdb

Functions defined

Source code

  1. /* Evaluate expressions for GDB.

  3.    Copyright (C) 1986-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  20. #include "defs.h"
  21. #include "symtab.h"
  22. #include "gdbtypes.h"
  23. #include "value.h"
  24. #include "expression.h"
  25. #include "target.h"
  26. #include "frame.h"
  27. #include "gdbthread.h"
  28. #include "language.h"                /* For CAST_IS_CONVERSION.  */
  29. #include "f-lang.h"                /* For array bound stuff.  */
  30. #include "cp-abi.h"
  31. #include "infcall.h"
  32. #include "objc-lang.h"
  33. #include "block.h"
  34. #include "parser-defs.h"
  35. #include "cp-support.h"
  36. #include "ui-out.h"
  37. #include "regcache.h"
  38. #include "user-regs.h"
  39. #include "valprint.h"
  40. #include "gdb_obstack.h"
  41. #include "objfiles.h"
  42. #include <ctype.h>

  44. /* This is defined in valops.c */
  45. extern int overload_resolution;

  47. /* Prototypes for local functions.  */

  49. static struct value *evaluate_subexp_for_sizeof (struct expression *, int *,
  50.                                                  enum noside);

  52. static struct value *evaluate_subexp_for_address (struct expression *,
  53.                                                   int *, enum noside);

  55. static struct value *evaluate_struct_tuple (struct value *,
  56.                                             struct expression *, int *,
  57.                                             enum noside, int);

  59. static LONGEST init_array_element (struct value *, struct value *,
  60.                                    struct expression *, int *, enum noside,
  61.                                    LONGEST, LONGEST);

  63. struct value *
  64. ‌evaluate_subexp (struct type *expect_type, struct expression *exp,
  65.                  int *pos, enum noside noside)
  66. {
  67.   struct cleanup *cleanups;
  68.   struct value *retval;
  69.   int cleanup_temps = 0;

  71.   if (*pos == 0 && target_has_execution
  72.       && exp->language_defn->la_language == language_cplus
  73.       && !thread_stack_temporaries_enabled_p (inferior_ptid))
  74.     {
  75.       cleanups = enable_thread_stack_temporaries (inferior_ptid);
  76.       cleanup_temps = 1;
  77.     }

  79.   retval = (*exp->language_defn->la_exp_desc->evaluate_exp)
  80.     (expect_type, exp, pos, noside);

  82.   if (cleanup_temps)
  83.     {
  84.       if (value_in_thread_stack_temporaries (retval, inferior_ptid))
  85.         retval = value_non_lval (retval);
  86.       do_cleanups (cleanups);
  87.     }

  89.   return retval;
  90. }

  92. /* Parse the string EXP as a C expression, evaluate it,
  93.    and return the result as a number.  */

  95. CORE_ADDR
  96. ‌parse_and_eval_address (const char *exp)
  97. {
  98.   struct expression *expr = parse_expression (exp);
  99.   CORE_ADDR addr;
  100.   struct cleanup *old_chain =
  101.     make_cleanup (free_current_contents, &expr);

  103.   addr = value_as_address (evaluate_expression (expr));
  104.   do_cleanups (old_chain);
  105.   return addr;
  106. }

  108. /* Like parse_and_eval_address, but treats the value of the expression
  109.    as an integer, not an address, returns a LONGEST, not a CORE_ADDR.  */
  110. LONGEST
  111. ‌parse_and_eval_long (const char *exp)
  112. {
  113.   struct expression *expr = parse_expression (exp);
  114.   LONGEST retval;
  115.   struct cleanup *old_chain =
  116.     make_cleanup (free_current_contents, &expr);

  118.   retval = value_as_long (evaluate_expression (expr));
  119.   do_cleanups (old_chain);
  120.   return (retval);
  121. }

  123. struct value *
  124. ‌parse_and_eval (const char *exp)
  125. {
  126.   struct expression *expr = parse_expression (exp);
  127.   struct value *val;
  128.   struct cleanup *old_chain =
  129.     make_cleanup (free_current_contents, &expr);

  131.   val = evaluate_expression (expr);
  132.   do_cleanups (old_chain);
  133.   return val;
  134. }

  136. /* Parse up to a comma (or to a closeparen)
  137.    in the string EXPP as an expression, evaluate it, and return the value.
  138.    EXPP is advanced to point to the comma.  */

  140. struct value *
  141. ‌parse_to_comma_and_eval (const char **expp)
  142. {
  143.   struct expression *expr = parse_exp_1 (expp, 0, (struct block *) 0, 1);
  144.   struct value *val;
  145.   struct cleanup *old_chain =
  146.     make_cleanup (free_current_contents, &expr);

  148.   val = evaluate_expression (expr);
  149.   do_cleanups (old_chain);
  150.   return val;
  151. }

  153. /* Evaluate an expression in internal prefix form
  154.    such as is constructed by parse.y.

  156.    See expression.h for info on the format of an expression.  */

  158. struct value *
  159. ‌evaluate_expression (struct expression *exp)
  160. {
  161.   int pc = 0;

  163.   return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_NORMAL);
  164. }

  166. /* Evaluate an expression, avoiding all memory references
  167.    and getting a value whose type alone is correct.  */

  169. struct value *
  170. ‌evaluate_type (struct expression *exp)
  171. {
  172.   int pc = 0;

  174.   return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
  175. }

  177. /* Evaluate a subexpression, avoiding all memory references and
  178.    getting a value whose type alone is correct.  */

  180. struct value *
  181. ‌evaluate_subexpression_type (struct expression *exp, int subexp)
  182. {
  183.   return evaluate_subexp (NULL_TYPE, exp, &subexp, EVAL_AVOID_SIDE_EFFECTS);
  184. }

  186. /* Find the current value of a watchpoint on EXP.  Return the value in
  187.    *VALP and *RESULTP and the chain of intermediate and final values
  188.    in *VAL_CHAIN.  RESULTP and VAL_CHAIN may be NULL if the caller does
  189.    not need them.

  191.    If PRESERVE_ERRORS is true, then exceptions are passed through.
  192.    Otherwise, if PRESERVE_ERRORS is false, then if a memory error
  193.    occurs while evaluating the expression, *RESULTP will be set to
  194.    NULL.  *RESULTP may be a lazy value, if the result could not be
  195.    read from memory.  It is used to determine whether a value is
  196.    user-specified (we should watch the whole value) or intermediate
  197.    (we should watch only the bit used to locate the final value).

  199.    If the final value, or any intermediate value, could not be read
  200.    from memory, *VALP will be set to NULL.  *VAL_CHAIN will still be
  201.    set to any referenced values.  *VALP will never be a lazy value.
  202.    This is the value which we store in struct breakpoint.

  204.    If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
  205.    value chain.  The caller must free the values individually.  If
  206.    VAL_CHAIN is NULL, all generated values will be left on the value
  207.    chain.  */

  209. void
  210. ‌fetch_subexp_value (struct expression *exp, int *pc, struct value **valp,
  211.                     struct value **resultp, struct value **val_chain,
  212.                     int preserve_errors)
  213. {
  214.   struct value *mark, *new_mark, *result;
  215.   volatile struct gdb_exception ex;

  217.   *valp = NULL;
  218.   if (resultp)
  219.     *resultp = NULL;
  220.   if (val_chain)
  221.     *val_chain = NULL;

  223.   /* Evaluate the expression.  */
  224.   mark = value_mark ();
  225.   result = NULL;

  227.   TRY_CATCH (ex, RETURN_MASK_ALL)
  228.     {
  229.       result = evaluate_subexp (NULL_TYPE, exp, pc, EVAL_NORMAL);
  230.     }
  231.   if (ex.reason < 0)
  232.     {
  233.       /* Ignore memory errors if we want watchpoints pointing at
  234.          inaccessible memory to still be created; otherwise, throw the
  235.          error to some higher catcher.  */
  236.       switch (ex.error)
  237.         {
  238.         case MEMORY_ERROR:
  239.           if (!preserve_errors)
  240.             break;
  241.         default:
  242.           throw_exception (ex);
  243.           break;
  244.         }
  245.     }

  247.   new_mark = value_mark ();
  248.   if (mark == new_mark)
  249.     return;
  250.   if (resultp)
  251.     *resultp = result;

  253.   /* Make sure it's not lazy, so that after the target stops again we
  254.      have a non-lazy previous value to compare with.  */
  255.   if (result != NULL)
  256.     {
  257.       if (!value_lazy (result))
  258.         *valp = result;
  259.       else
  260.         {
  261.           volatile struct gdb_exception except;

  263.           TRY_CATCH (except, RETURN_MASK_ERROR)
  264.             {
  265.               value_fetch_lazy (result);
  266.               *valp = result;
  267.             }
  268.         }
  269.     }

  271.   if (val_chain)
  272.     {
  273.       /* Return the chain of intermediate values.  We use this to
  274.          decide which addresses to watch.  */
  275.       *val_chain = new_mark;
  276.       value_release_to_mark (mark);
  277.     }
  278. }

  280. /* Extract a field operation from an expression.  If the subexpression
  281.    of EXP starting at *SUBEXP is not a structure dereference
  282.    operation, return NULL.  Otherwise, return the name of the
  283.    dereferenced field, and advance *SUBEXP to point to the
  284.    subexpression of the left-hand-side of the dereference.  This is
  285.    used when completing field names.  */

  287. char *
  288. ‌extract_field_op (struct expression *exp, int *subexp)
  289. {
  290.   int tem;
  291.   char *result;

  293.   if (exp->elts[*subexp].opcode != STRUCTOP_STRUCT
  294.       && exp->elts[*subexp].opcode != STRUCTOP_PTR)
  295.     return NULL;
  296.   tem = longest_to_int (exp->elts[*subexp + 1].longconst);
  297.   result = &exp->elts[*subexp + 2].string;
  298.   (*subexp) += 1 + 3 + BYTES_TO_EXP_ELEM (tem + 1);
  299.   return result;
  300. }

  302. /* This function evaluates brace-initializers (in C/C++) for
  303.    structure types.  */

  305. static struct value *
  306. ‌evaluate_struct_tuple (struct value *struct_val,
  307.                        struct expression *exp,
  308.                        int *pos, enum noside noside, int nargs)
  309. {
  310.   struct type *struct_type = check_typedef (value_type (struct_val));
  311.   struct type *field_type;
  312.   int fieldno = -1;

  314.   while (--nargs >= 0)
  315.     {
  316.       struct value *val = NULL;
  317.       int bitpos, bitsize;
  318.       bfd_byte *addr;

  320.       fieldno++;
  321.       /* Skip static fields.  */
  322.       while (fieldno < TYPE_NFIELDS (struct_type)
  323.              && field_is_static (&TYPE_FIELD (struct_type,
  324.                                               fieldno)))
  325.         fieldno++;
  326.       if (fieldno >= TYPE_NFIELDS (struct_type))
  327.         error (_("too many initializers"));
  328.       field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
  329.       if (TYPE_CODE (field_type) == TYPE_CODE_UNION
  330.           && TYPE_FIELD_NAME (struct_type, fieldno)[0] == '0')
  331.         error (_("don't know which variant you want to set"));

  333.       /* Here, struct_type is the type of the inner struct,
  334.          while substruct_type is the type of the inner struct.
  335.          These are the same for normal structures, but a variant struct
  336.          contains anonymous union fields that contain substruct fields.
  337.          The value fieldno is the index of the top-level (normal or
  338.          anonymous union) field in struct_field, while the value
  339.          subfieldno is the index of the actual real (named inner) field
  340.          in substruct_type.  */

  342.       field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
  343.       if (val == 0)
  344.         val = evaluate_subexp (field_type, exp, pos, noside);

  346.       /* Now actually set the field in struct_val.  */

  348.       /* Assign val to field fieldno.  */
  349.       if (value_type (val) != field_type)
  350.         val = value_cast (field_type, val);

  352.       bitsize = TYPE_FIELD_BITSIZE (struct_type, fieldno);
  353.       bitpos = TYPE_FIELD_BITPOS (struct_type, fieldno);
  354.       addr = value_contents_writeable (struct_val) + bitpos / 8;
  355.       if (bitsize)
  356.         modify_field (struct_type, addr,
  357.                       value_as_long (val), bitpos % 8, bitsize);
  358.       else
  359.         memcpy (addr, value_contents (val),
  360.                 TYPE_LENGTH (value_type (val)));

  362.     }
  363.   return struct_val;
  364. }

  366. /* Recursive helper function for setting elements of array tuples.
  367.    The target is ARRAY (which has bounds LOW_BOUND to HIGH_BOUND); the
  368.    element value is ELEMENT; EXP, POS and NOSIDE are as usual.
  369.    Evaluates index expresions and sets the specified element(s) of
  370.    ARRAY to ELEMENT.  Returns last index value.  */

  372. static LONGEST
  373. ‌init_array_element (struct value *array, struct value *element,
  374.                     struct expression *exp, int *pos,
  375.                     enum noside noside, LONGEST low_bound, LONGEST high_bound)
  376. {
  377.   LONGEST index;
  378.   int element_size = TYPE_LENGTH (value_type (element));

  380.   if (exp->elts[*pos].opcode == BINOP_COMMA)
  381.     {
  382.       (*pos)++;
  383.       init_array_element (array, element, exp, pos, noside,
  384.                           low_bound, high_bound);
  385.       return init_array_element (array, element,
  386.                                  exp, pos, noside, low_bound, high_bound);
  387.     }
  388.   else
  389.     {
  390.       index = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
  391.       if (index < low_bound || index > high_bound)
  392.         error (_("tuple index out of range"));
  393.       memcpy (value_contents_raw (array) + (index - low_bound) * element_size,
  394.               value_contents (element), element_size);
  395.     }
  396.   return index;
  397. }

  399. static struct value *
  400. ‌value_f90_subarray (struct value *array,
  401.                     struct expression *exp, int *pos, enum noside noside)
  402. {
  403.   int pc = (*pos) + 1;
  404.   LONGEST low_bound, high_bound;
  405.   struct type *range = check_typedef (TYPE_INDEX_TYPE (value_type (array)));
  406.   enum f90_range_type range_type = longest_to_int (exp->elts[pc].longconst);

  408.   *pos += 3;

  410.   if (range_type == LOW_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
  411.     low_bound = TYPE_LOW_BOUND (range);
  412.   else
  413.     low_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));

  415.   if (range_type == HIGH_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
  416.     high_bound = TYPE_HIGH_BOUND (range);
  417.   else
  418.     high_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));

  420.   return value_slice (array, low_bound, high_bound - low_bound + 1);
  421. }


  424. /* Promote value ARG1 as appropriate before performing a unary operation
  425.    on this argument.
  426.    If the result is not appropriate for any particular language then it
  427.    needs to patch this function.  */

  429. void
  430. ‌unop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
  431.               struct value **arg1)
  432. {
  433.   struct type *type1;

  435.   *arg1 = coerce_ref (*arg1);
  436.   type1 = check_typedef (value_type (*arg1));

  438.   if (is_integral_type (type1))
  439.     {
  440.       switch (language->la_language)
  441.         {
  442.         default:
  443.           /* Perform integral promotion for ANSI C/C++.
  444.              If not appropropriate for any particular language
  445.              it needs to modify this function.  */
  446.           {
  447.             struct type *builtin_int = builtin_type (gdbarch)->builtin_int;

  449.             if (TYPE_LENGTH (type1) < TYPE_LENGTH (builtin_int))
  450.               *arg1 = value_cast (builtin_int, *arg1);
  451.           }
  452.           break;
  453.         }
  454.     }
  455. }

  457. /* Promote values ARG1 and ARG2 as appropriate before performing a binary
  458.    operation on those two operands.
  459.    If the result is not appropriate for any particular language then it
  460.    needs to patch this function.  */

  462. void
  463. ‌binop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
  464.                struct value **arg1, struct value **arg2)
  465. {
  466.   struct type *promoted_type = NULL;
  467.   struct type *type1;
  468.   struct type *type2;

  470.   *arg1 = coerce_ref (*arg1);
  471.   *arg2 = coerce_ref (*arg2);

  473.   type1 = check_typedef (value_type (*arg1));
  474.   type2 = check_typedef (value_type (*arg2));

  476.   if ((TYPE_CODE (type1) != TYPE_CODE_FLT
  477.        && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT
  478.        && !is_integral_type (type1))
  479.       || (TYPE_CODE (type2) != TYPE_CODE_FLT
  480.           && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT
  481.           && !is_integral_type (type2)))
  482.     return;

  484.   if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
  485.       || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
  486.     {
  487.       /* No promotion required.  */
  488.     }
  489.   else if (TYPE_CODE (type1) == TYPE_CODE_FLT
  490.            || TYPE_CODE (type2) == TYPE_CODE_FLT)
  491.     {
  492.       switch (language->la_language)
  493.         {
  494.         case language_c:
  495.         case language_cplus:
  496.         case language_asm:
  497.         case language_objc:
  498.         case language_opencl:
  499.           /* No promotion required.  */
  500.           break;

  502.         default:
  503.           /* For other languages the result type is unchanged from gdb
  504.              version 6.7 for backward compatibility.
  505.              If either arg was long double, make sure that value is also long
  506.              double.  Otherwise use double.  */
  507.           if (TYPE_LENGTH (type1) * 8 > gdbarch_double_bit (gdbarch)
  508.               || TYPE_LENGTH (type2) * 8 > gdbarch_double_bit (gdbarch))
  509.             promoted_type = builtin_type (gdbarch)->builtin_long_double;
  510.           else
  511.             promoted_type = builtin_type (gdbarch)->builtin_double;
  512.           break;
  513.         }
  514.     }
  515.   else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
  516.            && TYPE_CODE (type2) == TYPE_CODE_BOOL)
  517.     {
  518.       /* No promotion required.  */
  519.     }
  520.   else
  521.     /* Integral operations here.  */
  522.     /* FIXME: Also mixed integral/booleans, with result an integer.  */
  523.     {
  524.       const struct builtin_type *builtin = builtin_type (gdbarch);
  525.       unsigned int promoted_len1 = TYPE_LENGTH (type1);
  526.       unsigned int promoted_len2 = TYPE_LENGTH (type2);
  527.       int is_unsigned1 = TYPE_UNSIGNED (type1);
  528.       int is_unsigned2 = TYPE_UNSIGNED (type2);
  529.       unsigned int result_len;
  530.       int unsigned_operation;

  532.       /* Determine type length and signedness after promotion for
  533.          both operands.  */
  534.       if (promoted_len1 < TYPE_LENGTH (builtin->builtin_int))
  535.         {
  536.           is_unsigned1 = 0;
  537.           promoted_len1 = TYPE_LENGTH (builtin->builtin_int);
  538.         }
  539.       if (promoted_len2 < TYPE_LENGTH (builtin->builtin_int))
  540.         {
  541.           is_unsigned2 = 0;
  542.           promoted_len2 = TYPE_LENGTH (builtin->builtin_int);
  543.         }

  545.       if (promoted_len1 > promoted_len2)
  546.         {
  547.           unsigned_operation = is_unsigned1;
  548.           result_len = promoted_len1;
  549.         }
  550.       else if (promoted_len2 > promoted_len1)
  551.         {
  552.           unsigned_operation = is_unsigned2;
  553.           result_len = promoted_len2;
  554.         }
  555.       else
  556.         {
  557.           unsigned_operation = is_unsigned1 || is_unsigned2;
  558.           result_len = promoted_len1;
  559.         }

  561.       switch (language->la_language)
  562.         {
  563.         case language_c:
  564.         case language_cplus:
  565.         case language_asm:
  566.         case language_objc:
  567.           if (result_len <= TYPE_LENGTH (builtin->builtin_int))
  568.             {
  569.               promoted_type = (unsigned_operation
  570.                                ? builtin->builtin_unsigned_int
  571.                                : builtin->builtin_int);
  572.             }
  573.           else if (result_len <= TYPE_LENGTH (builtin->builtin_long))
  574.             {
  575.               promoted_type = (unsigned_operation
  576.                                ? builtin->builtin_unsigned_long
  577.                                : builtin->builtin_long);
  578.             }
  579.           else
  580.             {
  581.               promoted_type = (unsigned_operation
  582.                                ? builtin->builtin_unsigned_long_long
  583.                                : builtin->builtin_long_long);
  584.             }
  585.           break;
  586.         case language_opencl:
  587.           if (result_len <= TYPE_LENGTH (lookup_signed_typename
  588.                                          (language, gdbarch, "int")))
  589.             {
  590.               promoted_type =
  591.                 (unsigned_operation
  592.                  ? lookup_unsigned_typename (language, gdbarch, "int")
  593.                  : lookup_signed_typename (language, gdbarch, "int"));
  594.             }
  595.           else if (result_len <= TYPE_LENGTH (lookup_signed_typename
  596.                                               (language, gdbarch, "long")))
  597.             {
  598.               promoted_type =
  599.                 (unsigned_operation
  600.                  ? lookup_unsigned_typename (language, gdbarch, "long")
  601.                  : lookup_signed_typename (language, gdbarch,"long"));
  602.             }
  603.           break;
  604.         default:
  605.           /* For other languages the result type is unchanged from gdb
  606.              version 6.7 for backward compatibility.
  607.              If either arg was long long, make sure that value is also long
  608.              long.  Otherwise use long.  */
  609.           if (unsigned_operation)
  610.             {
  611.               if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
  612.                 promoted_type = builtin->builtin_unsigned_long_long;
  613.               else
  614.                 promoted_type = builtin->builtin_unsigned_long;
  615.             }
  616.           else
  617.             {
  618.               if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
  619.                 promoted_type = builtin->builtin_long_long;
  620.               else
  621.                 promoted_type = builtin->builtin_long;
  622.             }
  623.           break;
  624.         }
  625.     }

  627.   if (promoted_type)
  628.     {
  629.       /* Promote both operands to common type.  */
  630.       *arg1 = value_cast (promoted_type, *arg1);
  631.       *arg2 = value_cast (promoted_type, *arg2);
  632.     }
  633. }

  635. static int
  636. ‌ptrmath_type_p (const struct language_defn *lang, struct type *type)
  637. {
  638.   type = check_typedef (type);
  639.   if (TYPE_CODE (type) == TYPE_CODE_REF)
  640.     type = TYPE_TARGET_TYPE (type);

  642.   switch (TYPE_CODE (type))
  643.     {
  644.     case TYPE_CODE_PTR:
  645.     case TYPE_CODE_FUNC:
  646.       return 1;

  648.     case TYPE_CODE_ARRAY:
  649.       return TYPE_VECTOR (type) ? 0 : lang->c_style_arrays;

  651.     default:
  652.       return 0;
  653.     }
  654. }

  656. /* Constructs a fake method with the given parameter types.
  657.    This function is used by the parser to construct an "expected"
  658.    type for method overload resolution.  */

  660. static struct type *
  661. ‌make_params (int num_types, struct type **param_types)
  662. {
  663.   struct type *type = XCNEW (struct type);
  664.   TYPE_MAIN_TYPE (type) = XCNEW (struct main_type);
  665.   TYPE_LENGTH (type) = 1;
  666.   TYPE_CODE (type) = TYPE_CODE_METHOD;
  667.   TYPE_VPTR_FIELDNO (type) = -1;
  668.   TYPE_CHAIN (type) = type;
  669.   if (num_types > 0)
  670.     {
  671.       if (param_types[num_types - 1] == NULL)
  672.         {
  673.           --num_types;
  674.           TYPE_VARARGS (type) = 1;
  675.         }
  676.       else if (TYPE_CODE (check_typedef (param_types[num_types - 1]))
  677.                == TYPE_CODE_VOID)
  678.         {
  679.           --num_types;
  680.           /* Caller should have ensured this.  */
  681.           gdb_assert (num_types == 0);
  682.           TYPE_PROTOTYPED (type) = 1;
  683.         }
  684.     }

  686.   TYPE_NFIELDS (type) = num_types;
  687.   TYPE_FIELDS (type) = (struct field *)
  688.     TYPE_ZALLOC (type, sizeof (struct field) * num_types);

  690.   while (num_types-- > 0)
  691.     TYPE_FIELD_TYPE (type, num_types) = param_types[num_types];

  693.   return type;
  694. }

  696. struct value *
  697. ‌evaluate_subexp_standard (struct type *expect_type,
  698.                           struct expression *exp, int *pos,
  699.                           enum noside noside)
  700. {
  701.   enum exp_opcode op;
  702.   int tem, tem2, tem3;
  703.   int pc, pc2 = 0, oldpos;
  704.   struct value *arg1 = NULL;
  705.   struct value *arg2 = NULL;
  706.   struct value *arg3;
  707.   struct type *type;
  708.   int nargs;
  709.   struct value **argvec;
  710.   int code;
  711.   int ix;
  712.   long mem_offset;
  713.   struct type **arg_types;
  714.   int save_pos1;
  715.   struct symbol *function = NULL;
  716.   char *function_name = NULL;

  718.   pc = (*pos)++;
  719.   op = exp->elts[pc].opcode;

  721.   switch (op)
  722.     {
  723.     case OP_SCOPE:
  724.       tem = longest_to_int (exp->elts[pc + 2].longconst);
  725.       (*pos) += 4 + BYTES_TO_EXP_ELEM (tem + 1);
  726.       if (noside == EVAL_SKIP)
  727.         goto nosideret;
  728.       arg1 = value_aggregate_elt (exp->elts[pc + 1].type,
  729.                                   &exp->elts[pc + 3].string,
  730.                                   expect_type, 0, noside);
  731.       if (arg1 == NULL)
  732.         error (_("There is no field named %s"), &exp->elts[pc + 3].string);
  733.       return arg1;

  735.     case OP_LONG:
  736.       (*pos) += 3;
  737.       return value_from_longest (exp->elts[pc + 1].type,
  738.                                  exp->elts[pc + 2].longconst);

  740.     case OP_DOUBLE:
  741.       (*pos) += 3;
  742.       return value_from_double (exp->elts[pc + 1].type,
  743.                                 exp->elts[pc + 2].doubleconst);

  745.     case OP_DECFLOAT:
  746.       (*pos) += 3;
  747.       return value_from_decfloat (exp->elts[pc + 1].type,
  748.                                   exp->elts[pc + 2].decfloatconst);

  750.     case OP_ADL_FUNC:
  751.     case OP_VAR_VALUE:
  752.       (*pos) += 3;
  753.       if (noside == EVAL_SKIP)
  754.         goto nosideret;

  756.       /* JYG: We used to just return value_zero of the symbol type
  757.          if we're asked to avoid side effects.  Otherwise we return
  758.          value_of_variable (...).  However I'm not sure if
  759.          value_of_variable () has any side effect.
  760.          We need a full value object returned here for whatis_exp ()
  761.          to call evaluate_type () and then pass the full value to
  762.          value_rtti_target_type () if we are dealing with a pointer
  763.          or reference to a base class and print object is on.  */

  765.       {
  766.         volatile struct gdb_exception except;
  767.         struct value *ret = NULL;

  769.         TRY_CATCH (except, RETURN_MASK_ERROR)
  770.           {
  771.             ret = value_of_variable (exp->elts[pc + 2].symbol,
  772.                                      exp->elts[pc + 1].block);
  773.           }

  775.         if (except.reason < 0)
  776.           {
  777.             if (noside == EVAL_AVOID_SIDE_EFFECTS)
  778.               ret = value_zero (SYMBOL_TYPE (exp->elts[pc + 2].symbol),
  779.                                 not_lval);
  780.             else
  781.               throw_exception (except);
  782.           }

  784.         return ret;
  785.       }

  787.     case OP_VAR_ENTRY_VALUE:
  788.       (*pos) += 2;
  789.       if (noside == EVAL_SKIP)
  790.         goto nosideret;

  792.       {
  793.         struct symbol *sym = exp->elts[pc + 1].symbol;
  794.         struct frame_info *frame;

  796.         if (noside == EVAL_AVOID_SIDE_EFFECTS)
  797.           return value_zero (SYMBOL_TYPE (sym), not_lval);

  799.         if (SYMBOL_COMPUTED_OPS (sym) == NULL
  800.             || SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry == NULL)
  801.           error (_("Symbol \"%s\" does not have any specific entry value"),
  802.                  SYMBOL_PRINT_NAME (sym));

  804.         frame = get_selected_frame (NULL);
  805.         return SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry (sym, frame);
  806.       }

  808.     case OP_LAST:
  809.       (*pos) += 2;
  810.       return
  811.         access_value_history (longest_to_int (exp->elts[pc + 1].longconst));

  813.     case OP_REGISTER:
  814.       {
  815.         const char *name = &exp->elts[pc + 2].string;
  816.         int regno;
  817.         struct value *val;

  819.         (*pos) += 3 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1);
  820.         regno = user_reg_map_name_to_regnum (exp->gdbarch,
  821.                                              name, strlen (name));
  822.         if (regno == -1)
  823.           error (_("Register $%s not available."), name);

  825.         /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
  826.            a value with the appropriate register type.  Unfortunately,
  827.            we don't have easy access to the type of user registers.
  828.            So for these registers, we fetch the register value regardless
  829.            of the evaluation mode.  */
  830.         if (noside == EVAL_AVOID_SIDE_EFFECTS
  831.             && regno < gdbarch_num_regs (exp->gdbarch)
  832.                         + gdbarch_num_pseudo_regs (exp->gdbarch))
  833.           val = value_zero (register_type (exp->gdbarch, regno), not_lval);
  834.         else
  835.           val = value_of_register (regno, get_selected_frame (NULL));
  836.         if (val == NULL)
  837.           error (_("Value of register %s not available."), name);
  838.         else
  839.           return val;
  840.       }
  841.     case OP_BOOL:
  842.       (*pos) += 2;
  843.       type = language_bool_type (exp->language_defn, exp->gdbarch);
  844.       return value_from_longest (type, exp->elts[pc + 1].longconst);

  846.     case OP_INTERNALVAR:
  847.       (*pos) += 2;
  848.       return value_of_internalvar (exp->gdbarch,
  849.                                    exp->elts[pc + 1].internalvar);

  851.     case OP_STRING:
  852.       tem = longest_to_int (exp->elts[pc + 1].longconst);
  853.       (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
  854.       if (noside == EVAL_SKIP)
  855.         goto nosideret;
  856.       type = language_string_char_type (exp->language_defn, exp->gdbarch);
  857.       return value_string (&exp->elts[pc + 2].string, tem, type);

  859.     case OP_OBJC_NSSTRING:                /* Objective C Foundation Class
  860.                                            NSString constant.  */
  861.       tem = longest_to_int (exp->elts[pc + 1].longconst);
  862.       (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
  863.       if (noside == EVAL_SKIP)
  864.         {
  865.           goto nosideret;
  866.         }
  867.       return value_nsstring (exp->gdbarch, &exp->elts[pc + 2].string, tem + 1);

  869.     case OP_ARRAY:
  870.       (*pos) += 3;
  871.       tem2 = longest_to_int (exp->elts[pc + 1].longconst);
  872.       tem3 = longest_to_int (exp->elts[pc + 2].longconst);
  873.       nargs = tem3 - tem2 + 1;
  874.       type = expect_type ? check_typedef (expect_type) : NULL_TYPE;

  876.       if (expect_type != NULL_TYPE && noside != EVAL_SKIP
  877.           && TYPE_CODE (type) == TYPE_CODE_STRUCT)
  878.         {
  879.           struct value *rec = allocate_value (expect_type);

  881.           memset (value_contents_raw (rec), '\0', TYPE_LENGTH (type));
  882.           return evaluate_struct_tuple (rec, exp, pos, noside, nargs);
  883.         }

  885.       if (expect_type != NULL_TYPE && noside != EVAL_SKIP
  886.           && TYPE_CODE (type) == TYPE_CODE_ARRAY)
  887.         {
  888.           struct type *range_type = TYPE_INDEX_TYPE (type);
  889.           struct type *element_type = TYPE_TARGET_TYPE (type);
  890.           struct value *array = allocate_value (expect_type);
  891.           int element_size = TYPE_LENGTH (check_typedef (element_type));
  892.           LONGEST low_bound, high_bound, index;

  894.           if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
  895.             {
  896.               low_bound = 0;
  897.               high_bound = (TYPE_LENGTH (type) / element_size) - 1;
  898.             }
  899.           index = low_bound;
  900.           memset (value_contents_raw (array), 0, TYPE_LENGTH (expect_type));
  901.           for (tem = nargs; --nargs >= 0;)
  902.             {
  903.               struct value *element;
  904.               int index_pc = 0;

  906.               element = evaluate_subexp (element_type, exp, pos, noside);
  907.               if (value_type (element) != element_type)
  908.                 element = value_cast (element_type, element);
  909.               if (index_pc)
  910.                 {
  911.                   int continue_pc = *pos;

  913.                   *pos = index_pc;
  914.                   index = init_array_element (array, element, exp, pos, noside,
  915.                                               low_bound, high_bound);
  916.                   *pos = continue_pc;
  917.                 }
  918.               else
  919.                 {
  920.                   if (index > high_bound)
  921.                     /* To avoid memory corruption.  */
  922.                     error (_("Too many array elements"));
  923.                   memcpy (value_contents_raw (array)
  924.                           + (index - low_bound) * element_size,
  925.                           value_contents (element),
  926.                           element_size);
  927.                 }
  928.               index++;
  929.             }
  930.           return array;
  931.         }

  933.       if (expect_type != NULL_TYPE && noside != EVAL_SKIP
  934.           && TYPE_CODE (type) == TYPE_CODE_SET)
  935.         {
  936.           struct value *set = allocate_value (expect_type);
  937.           gdb_byte *valaddr = value_contents_raw (set);
  938.           struct type *element_type = TYPE_INDEX_TYPE (type);
  939.           struct type *check_type = element_type;
  940.           LONGEST low_bound, high_bound;

  942.           /* Get targettype of elementtype.  */
  943.           while (TYPE_CODE (check_type) == TYPE_CODE_RANGE
  944.                  || TYPE_CODE (check_type) == TYPE_CODE_TYPEDEF)
  945.             check_type = TYPE_TARGET_TYPE (check_type);

  947.           if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0)
  948.             error (_("(power)set type with unknown size"));
  949.           memset (valaddr, '\0', TYPE_LENGTH (type));
  950.           for (tem = 0; tem < nargs; tem++)
  951.             {
  952.               LONGEST range_low, range_high;
  953.               struct type *range_low_type, *range_high_type;
  954.               struct value *elem_val;

  956.               elem_val = evaluate_subexp (element_type, exp, pos, noside);
  957.               range_low_type = range_high_type = value_type (elem_val);
  958.               range_low = range_high = value_as_long (elem_val);

  960.               /* Check types of elements to avoid mixture of elements from
  961.                  different types. Also check if type of element is "compatible"
  962.                  with element type of powerset.  */
  963.               if (TYPE_CODE (range_low_type) == TYPE_CODE_RANGE)
  964.                 range_low_type = TYPE_TARGET_TYPE (range_low_type);
  965.               if (TYPE_CODE (range_high_type) == TYPE_CODE_RANGE)
  966.                 range_high_type = TYPE_TARGET_TYPE (range_high_type);
  967.               if ((TYPE_CODE (range_low_type) != TYPE_CODE (range_high_type))
  968.                   || (TYPE_CODE (range_low_type) == TYPE_CODE_ENUM
  969.                       && (range_low_type != range_high_type)))
  970.                 /* different element modes.  */
  971.                 error (_("POWERSET tuple elements of different mode"));
  972.               if ((TYPE_CODE (check_type) != TYPE_CODE (range_low_type))
  973.                   || (TYPE_CODE (check_type) == TYPE_CODE_ENUM
  974.                       && range_low_type != check_type))
  975.                 error (_("incompatible POWERSET tuple elements"));
  976.               if (range_low > range_high)
  977.                 {
  978.                   warning (_("empty POWERSET tuple range"));
  979.                   continue;
  980.                 }
  981.               if (range_low < low_bound || range_high > high_bound)
  982.                 error (_("POWERSET tuple element out of range"));
  983.               range_low -= low_bound;
  984.               range_high -= low_bound;
  985.               for (; range_low <= range_high; range_low++)
  986.                 {
  987.                   int bit_index = (unsigned) range_low % TARGET_CHAR_BIT;

  989.                   if (gdbarch_bits_big_endian (exp->gdbarch))
  990.                     bit_index = TARGET_CHAR_BIT - 1 - bit_index;
  991.                   valaddr[(unsigned) range_low / TARGET_CHAR_BIT]
  992.                     |= 1 << bit_index;
  993.                 }
  994.             }
  995.           return set;
  996.         }

  998.       argvec = (struct value **) alloca (sizeof (struct value *) * nargs);
  999.       for (tem = 0; tem < nargs; tem++)
  1000.         {
  1001.           /* Ensure that array expressions are coerced into pointer
  1002.              objects.  */
  1003.           argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
  1004.         }
  1005.       if (noside == EVAL_SKIP)
  1006.         goto nosideret;
  1007.       return value_array (tem2, tem3, argvec);

  1009.     case TERNOP_SLICE:
  1010.       {
  1011.         struct value *array = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  1012.         int lowbound
  1013.           = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
  1014.         int upper
  1015.           = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));

  1017.         if (noside == EVAL_SKIP)
  1018.           goto nosideret;
  1019.         return value_slice (array, lowbound, upper - lowbound + 1);
  1020.       }

  1022.     case TERNOP_COND:
  1023.       /* Skip third and second args to evaluate the first one.  */
  1024.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  1025.       if (value_logical_not (arg1))
  1026.         {
  1027.           evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
  1028.           return evaluate_subexp (NULL_TYPE, exp, pos, noside);
  1029.         }
  1030.       else
  1031.         {
  1032.           arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  1033.           evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
  1034.           return arg2;
  1035.         }

  1037.     case OP_OBJC_SELECTOR:
  1038.       {                                /* Objective C @selector operator.  */
  1039.         char *sel = &exp->elts[pc + 2].string;
  1040.         int len = longest_to_int (exp->elts[pc + 1].longconst);
  1041.         struct type *selector_type;

  1043.         (*pos) += 3 + BYTES_TO_EXP_ELEM (len + 1);
  1044.         if (noside == EVAL_SKIP)
  1045.           goto nosideret;

  1047.         if (sel[len] != 0)
  1048.           sel[len] = 0;                /* Make sure it's terminated.  */

  1050.         selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
  1051.         return value_from_longest (selector_type,
  1052.                                    lookup_child_selector (exp->gdbarch, sel));
  1053.       }

  1055.     case OP_OBJC_MSGCALL:
  1056.       {                                /* Objective C message (method) call.  */

  1058.         CORE_ADDR responds_selector = 0;
  1059.         CORE_ADDR method_selector = 0;

  1061.         CORE_ADDR selector = 0;

  1063.         int struct_return = 0;
  1064.         int sub_no_side = 0;

  1066.         struct value *msg_send = NULL;
  1067.         struct value *msg_send_stret = NULL;
  1068.         int gnu_runtime = 0;

  1070.         struct value *target = NULL;
  1071.         struct value *method = NULL;
  1072.         struct value *called_method = NULL;

  1074.         struct type *selector_type = NULL;
  1075.         struct type *long_type;

  1077.         struct value *ret = NULL;
  1078.         CORE_ADDR addr = 0;

  1080.         selector = exp->elts[pc + 1].longconst;
  1081.         nargs = exp->elts[pc + 2].longconst;
  1082.         argvec = (struct value **) alloca (sizeof (struct value *)
  1083.                                            * (nargs + 5));

  1085.         (*pos) += 3;

  1087.         long_type = builtin_type (exp->gdbarch)->builtin_long;
  1088.         selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;

  1090.         if (noside == EVAL_AVOID_SIDE_EFFECTS)
  1091.           sub_no_side = EVAL_NORMAL;
  1092.         else
  1093.           sub_no_side = noside;

  1095.         target = evaluate_subexp (selector_type, exp, pos, sub_no_side);

  1097.         if (value_as_long (target) == 0)
  1098.            return value_from_longest (long_type, 0);

  1100.         if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym)
  1101.           gnu_runtime = 1;

  1103.         /* Find the method dispatch (Apple runtime) or method lookup
  1104.            (GNU runtime) function for Objective-C.  These will be used
  1105.            to lookup the symbol information for the method.  If we
  1106.            can't find any symbol information, then we'll use these to
  1107.            call the method, otherwise we can call the method
  1108.            directly.  The msg_send_stret function is used in the special
  1109.            case of a method that returns a structure (Apple runtime
  1110.            only).  */
  1111.         if (gnu_runtime)
  1112.           {
  1113.             struct type *type = selector_type;

  1115.             type = lookup_function_type (type);
  1116.             type = lookup_pointer_type (type);
  1117.             type = lookup_function_type (type);
  1118.             type = lookup_pointer_type (type);

  1120.             msg_send = find_function_in_inferior ("objc_msg_lookup", NULL);
  1121.             msg_send_stret
  1122.               = find_function_in_inferior ("objc_msg_lookup", NULL);

  1124.             msg_send = value_from_pointer (type, value_as_address (msg_send));
  1125.             msg_send_stret = value_from_pointer (type,
  1126.                                         value_as_address (msg_send_stret));
  1127.           }
  1128.         else
  1129.           {
  1130.             msg_send = find_function_in_inferior ("objc_msgSend", NULL);
  1131.             /* Special dispatcher for methods returning structs.  */
  1132.             msg_send_stret
  1133.               = find_function_in_inferior ("objc_msgSend_stret", NULL);
  1134.           }

  1136.         /* Verify the target object responds to this method.  The
  1137.            standard top-level 'Object' class uses a different name for
  1138.            the verification method than the non-standard, but more
  1139.            often used, 'NSObject' class.  Make sure we check for both.  */

  1141.         responds_selector
  1142.           = lookup_child_selector (exp->gdbarch, "respondsToSelector:");
  1143.         if (responds_selector == 0)
  1144.           responds_selector
  1145.             = lookup_child_selector (exp->gdbarch, "respondsTo:");

  1147.         if (responds_selector == 0)
  1148.           error (_("no 'respondsTo:' or 'respondsToSelector:' method"));

  1150.         method_selector
  1151.           = lookup_child_selector (exp->gdbarch, "methodForSelector:");
  1152.         if (method_selector == 0)
  1153.           method_selector
  1154.             = lookup_child_selector (exp->gdbarch, "methodFor:");

  1156.         if (method_selector == 0)
  1157.           error (_("no 'methodFor:' or 'methodForSelector:' method"));

  1159.         /* Call the verification method, to make sure that the target
  1160.          class implements the desired method.  */

  1162.         argvec[0] = msg_send;
  1163.         argvec[1] = target;
  1164.         argvec[2] = value_from_longest (long_type, responds_selector);
  1165.         argvec[3] = value_from_longest (long_type, selector);
  1166.         argvec[4] = 0;

  1168.         ret = call_function_by_hand (argvec[0], 3, argvec + 1);
  1169.         if (gnu_runtime)
  1170.           {
  1171.             /* Function objc_msg_lookup returns a pointer.  */
  1172.             argvec[0] = ret;
  1173.             ret = call_function_by_hand (argvec[0], 3, argvec + 1);
  1174.           }
  1175.         if (value_as_long (ret) == 0)
  1176.           error (_("Target does not respond to this message selector."));

  1178.         /* Call "methodForSelector:" method, to get the address of a
  1179.            function method that implements this selector for this
  1180.            class.  If we can find a symbol at that address, then we
  1181.            know the return type, parameter types etc.  (that's a good
  1182.            thing).  */

  1184.         argvec[0] = msg_send;
  1185.         argvec[1] = target;
  1186.         argvec[2] = value_from_longest (long_type, method_selector);
  1187.         argvec[3] = value_from_longest (long_type, selector);
  1188.         argvec[4] = 0;

  1190.         ret = call_function_by_hand (argvec[0], 3, argvec + 1);
  1191.         if (gnu_runtime)
  1192.           {
  1193.             argvec[0] = ret;
  1194.             ret = call_function_by_hand (argvec[0], 3, argvec + 1);
  1195.           }

  1197.         /* ret should now be the selector.  */

  1199.         addr = value_as_long (ret);
  1200.         if (addr)
  1201.           {
  1202.             struct symbol *sym = NULL;

  1204.             /* The address might point to a function descriptor;
  1205.                resolve it to the actual code address instead.  */
  1206.             addr = gdbarch_convert_from_func_ptr_addr (exp->gdbarch, addr,
  1207.                                                        &current_target);

  1209.             /* Is it a high_level symbol?  */
  1210.             sym = find_pc_function (addr);
  1211.             if (sym != NULL)
  1212.               method = value_of_variable (sym, 0);
  1213.           }

  1215.         /* If we found a method with symbol information, check to see
  1216.            if it returns a struct.  Otherwise assume it doesn't.  */

  1218.         if (method)
  1219.           {
  1220.             CORE_ADDR funaddr;
  1221.             struct type *val_type;

  1223.             funaddr = find_function_addr (method, &val_type);

  1225.             block_for_pc (funaddr);

  1227.             CHECK_TYPEDEF (val_type);

  1229.             if ((val_type == NULL)
  1230.                 || (TYPE_CODE(val_type) == TYPE_CODE_ERROR))
  1231.               {
  1232.                 if (expect_type != NULL)
  1233.                   val_type = expect_type;
  1234.               }

  1236.             struct_return = using_struct_return (exp->gdbarch, method,
  1237.                                                  val_type);
  1238.           }
  1239.         else if (expect_type != NULL)
  1240.           {
  1241.             struct_return = using_struct_return (exp->gdbarch, NULL,
  1242.                                                  check_typedef (expect_type));
  1243.           }

  1245.         /* Found a function symbol.  Now we will substitute its
  1246.            value in place of the message dispatcher (obj_msgSend),
  1247.            so that we call the method directly instead of thru
  1248.            the dispatcher.  The main reason for doing this is that
  1249.            we can now evaluate the return value and parameter values
  1250.            according to their known data types, in case we need to
  1251.            do things like promotion, dereferencing, special handling
  1252.            of structs and doubles, etc.

  1254.            We want to use the type signature of 'method', but still
  1255.            jump to objc_msgSend() or objc_msgSend_stret() to better
  1256.            mimic the behavior of the runtime.  */

  1258.         if (method)
  1259.           {
  1260.             if (TYPE_CODE (value_type (method)) != TYPE_CODE_FUNC)
  1261.               error (_("method address has symbol information "
  1262.                        "with non-function type; skipping"));

  1264.             /* Create a function pointer of the appropriate type, and
  1265.                replace its value with the value of msg_send or
  1266.                msg_send_stret.  We must use a pointer here, as
  1267.                msg_send and msg_send_stret are of pointer type, and
  1268.                the representation may be different on systems that use
  1269.                function descriptors.  */
  1270.             if (struct_return)
  1271.               called_method
  1272.                 = value_from_pointer (lookup_pointer_type (value_type (method)),
  1273.                                       value_as_address (msg_send_stret));
  1274.             else
  1275.               called_method
  1276.                 = value_from_pointer (lookup_pointer_type (value_type (method)),
  1277.                                       value_as_address (msg_send));
  1278.           }
  1279.         else
  1280.           {
  1281.             if (struct_return)
  1282.               called_method = msg_send_stret;
  1283.             else
  1284.               called_method = msg_send;
  1285.           }

  1287.         if (noside == EVAL_SKIP)
  1288.           goto nosideret;

  1290.         if (noside == EVAL_AVOID_SIDE_EFFECTS)
  1291.           {
  1292.             /* If the return type doesn't look like a function type,
  1293.                call an error.  This can happen if somebody tries to
  1294.                turn a variable into a function call.  This is here
  1295.                because people often want to call, eg, strcmp, which
  1296.                gdb doesn't know is a function.  If gdb isn't asked for
  1297.                it's opinion (ie. through "whatis"), it won't offer
  1298.                it.  */

  1300.             struct type *type = value_type (called_method);

  1302.             if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
  1303.               type = TYPE_TARGET_TYPE (type);
  1304.             type = TYPE_TARGET_TYPE (type);

  1306.             if (type)
  1307.             {
  1308.               if ((TYPE_CODE (type) == TYPE_CODE_ERROR) && expect_type)
  1309.                 return allocate_value (expect_type);
  1310.               else
  1311.                 return allocate_value (type);
  1312.             }
  1313.             else
  1314.               error (_("Expression of type other than "
  1315.                        "\"method returning ...\" used as a method"));
  1316.           }

  1318.         /* Now depending on whether we found a symbol for the method,
  1319.            we will either call the runtime dispatcher or the method
  1320.            directly.  */

  1322.         argvec[0] = called_method;
  1323.         argvec[1] = target;
  1324.         argvec[2] = value_from_longest (long_type, selector);
  1325.         /* User-supplied arguments.  */
  1326.         for (tem = 0; tem < nargs; tem++)
  1327.           argvec[tem + 3] = evaluate_subexp_with_coercion (exp, pos, noside);
  1328.         argvec[tem + 3] = 0;

  1330.         if (gnu_runtime && (method != NULL))
  1331.           {
  1332.             /* Function objc_msg_lookup returns a pointer.  */
  1333.             deprecated_set_value_type (argvec[0],
  1334.                                        lookup_pointer_type (lookup_function_type (value_type (argvec[0]))));
  1335.             argvec[0]
  1336.               = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
  1337.           }

  1339.         ret = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
  1340.         return ret;
  1341.       }
  1342.       break;

  1344.     case OP_FUNCALL:
  1345.       (*pos) += 2;
  1346.       op = exp->elts[*pos].opcode;
  1347.       nargs = longest_to_int (exp->elts[pc + 1].longconst);
  1348.       /* Allocate arg vector, including space for the function to be
  1349.          called in argvec[0], a potential `this', and a terminating NULL.  */
  1350.       argvec = (struct value **)
  1351.         alloca (sizeof (struct value *) * (nargs + 3));
  1352.       if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
  1353.         {
  1354.           /* First, evaluate the structure into arg2.  */
  1355.           pc2 = (*pos)++;

  1357.           if (op == STRUCTOP_MEMBER)
  1358.             {
  1359.               arg2 = evaluate_subexp_for_address (exp, pos, noside);
  1360.             }
  1361.           else
  1362.             {
  1363.               arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  1364.             }

  1366.           /* If the function is a virtual function, then the
  1367.              aggregate value (providing the structure) plays
  1368.              its part by providing the vtable.  Otherwise,
  1369.              it is just along for the ride: call the function
  1370.              directly.  */

  1372.           arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);

  1374.           type = check_typedef (value_type (arg1));
  1375.           if (noside == EVAL_SKIP)
  1376.             tem = 1;  /* Set it to the right arg index so that all arguments
  1377.                          can also be skipped.  */
  1378.           else if (TYPE_CODE (type) == TYPE_CODE_METHODPTR)
  1379.             {
  1380.               if (noside == EVAL_AVOID_SIDE_EFFECTS)
  1381.                 arg1 = value_zero (TYPE_TARGET_TYPE (type), not_lval);
  1382.               else
  1383.                 arg1 = cplus_method_ptr_to_value (&arg2, arg1);

  1385.               /* Now, say which argument to start evaluating from.  */
  1386.               nargs++;
  1387.               tem = 2;
  1388.               argvec[1] = arg2;
  1389.             }
  1390.           else if (TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)
  1391.             {
  1392.               struct type *type_ptr
  1393.                 = lookup_pointer_type (TYPE_DOMAIN_TYPE (type));
  1394.               struct type *target_type_ptr
  1395.                 = lookup_pointer_type (TYPE_TARGET_TYPE (type));

  1397.               /* Now, convert these values to an address.  */
  1398.               arg2 = value_cast (type_ptr, arg2);

  1400.               mem_offset = value_as_long (arg1);

  1402.               arg1 = value_from_pointer (target_type_ptr,
  1403.                                          value_as_long (arg2) + mem_offset);
  1404.               arg1 = value_ind (arg1);
  1405.               tem = 1;
  1406.             }
  1407.           else
  1408.             error (_("Non-pointer-to-member value used in pointer-to-member "
  1409.                      "construct"));
  1410.         }
  1411.       else if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
  1412.         {
  1413.           /* Hair for method invocations.  */
  1414.           int tem2;

  1416.           nargs++;
  1417.           /* First, evaluate the structure into arg2.  */
  1418.           pc2 = (*pos)++;
  1419.           tem2 = longest_to_int (exp->elts[pc2 + 1].longconst);
  1420.           *pos += 3 + BYTES_TO_EXP_ELEM (tem2 + 1);

  1422.           if (op == STRUCTOP_STRUCT)
  1423.             {
  1424.               /* If v is a variable in a register, and the user types
  1425.                  v.method (), this will produce an error, because v has
  1426.                  no address.

  1428.                  A possible way around this would be to allocate a
  1429.                  copy of the variable on the stack, copy in the
  1430.                  contents, call the function, and copy out the
  1431.                  contents.  I.e. convert this from call by reference
  1432.                  to call by copy-return (or whatever it's called).
  1433.                  However, this does not work because it is not the
  1434.                  same: the method being called could stash a copy of
  1435.                  the address, and then future uses through that address
  1436.                  (after the method returns) would be expected to
  1437.                  use the variable itself, not some copy of it.  */
  1438.               arg2 = evaluate_subexp_for_address (exp, pos, noside);
  1439.             }
  1440.           else
  1441.             {
  1442.               arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);

  1444.               /* Check to see if the operator '->' has been
  1445.                  overloaded.  If the operator has been overloaded
  1446.                  replace arg2 with the value returned by the custom
  1447.                  operator and continue evaluation.  */
  1448.               while (unop_user_defined_p (op, arg2))
  1449.                 {
  1450.                   volatile struct gdb_exception except;
  1451.                   struct value *value = NULL;
  1452.                   TRY_CATCH (except, RETURN_MASK_ERROR)
  1453.                     {
  1454.                       value = value_x_unop (arg2, op, noside);
  1455.                     }

  1457.                   if (except.reason < 0)
  1458.                     {
  1459.                       if (except.error == NOT_FOUND_ERROR)
  1460.                         break;
  1461.                       else
  1462.                         throw_exception (except);
  1463.                     }
  1464.                   arg2 = value;
  1465.                 }
  1466.             }
  1467.           /* Now, say which argument to start evaluating from.  */
  1468.           tem = 2;
  1469.         }
  1470.       else if (op == OP_SCOPE
  1471.                && overload_resolution
  1472.                && (exp->language_defn->la_language == language_cplus))
  1473.         {
  1474.           /* Unpack it locally so we can properly handle overload
  1475.              resolution.  */
  1476.           char *name;
  1477.           int local_tem;

  1479.           pc2 = (*pos)++;
  1480.           local_tem = longest_to_int (exp->elts[pc2 + 2].longconst);
  1481.           (*pos) += 4 + BYTES_TO_EXP_ELEM (local_tem + 1);
  1482.           type = exp->elts[pc2 + 1].type;
  1483.           name = &exp->elts[pc2 + 3].string;

  1485.           function = NULL;
  1486.           function_name = NULL;
  1487.           if (TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
  1488.             {
  1489.               function = cp_lookup_symbol_namespace (TYPE_TAG_NAME (type),
  1490.                                                      name,
  1491.                                                      get_selected_block (0),
  1492.                                                      VAR_DOMAIN);
  1493.               if (function == NULL)
  1494.                 error (_("No symbol \"%s\" in namespace \"%s\"."),
  1495.                        name, TYPE_TAG_NAME (type));

  1497.               tem = 1;
  1498.               /* arg2 is left as NULL on purpose.  */
  1499.             }
  1500.           else
  1501.             {
  1502.               gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
  1503.                           || TYPE_CODE (type) == TYPE_CODE_UNION);
  1504.               function_name = name;

  1506.               /* We need a properly typed value for method lookup.  For
  1507.                  static methods arg2 is otherwise unused.  */
  1508.               arg2 = value_zero (type, lval_memory);
  1509.               ++nargs;
  1510.               tem = 2;
  1511.             }
  1512.         }
  1513.       else if (op == OP_ADL_FUNC)
  1514.         {
  1515.           /* Save the function position and move pos so that the arguments
  1516.              can be evaluated.  */
  1517.           int func_name_len;

  1519.           save_pos1 = *pos;
  1520.           tem = 1;

  1522.           func_name_len = longest_to_int (exp->elts[save_pos1 + 3].longconst);
  1523.           (*pos) += 6 + BYTES_TO_EXP_ELEM (func_name_len + 1);
  1524.         }
  1525.       else
  1526.         {
  1527.           /* Non-method function call.  */
  1528.           save_pos1 = *pos;
  1529.           tem = 1;

  1531.           /* If this is a C++ function wait until overload resolution.  */
  1532.           if (op == OP_VAR_VALUE
  1533.               && overload_resolution
  1534.               && (exp->language_defn->la_language == language_cplus))
  1535.             {
  1536.               (*pos) += 4; /* Skip the evaluation of the symbol.  */
  1537.               argvec[0] = NULL;
  1538.             }
  1539.           else
  1540.             {
  1541.               argvec[0] = evaluate_subexp_with_coercion (exp, pos, noside);
  1542.               type = value_type (argvec[0]);
  1543.               if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
  1544.                 type = TYPE_TARGET_TYPE (type);
  1545.               if (type && TYPE_CODE (type) == TYPE_CODE_FUNC)
  1546.                 {
  1547.                   for (; tem <= nargs && tem <= TYPE_NFIELDS (type); tem++)
  1548.                     {
  1549.                       argvec[tem] = evaluate_subexp (TYPE_FIELD_TYPE (type,
  1550.                                                                       tem - 1),
  1551.                                                      exp, pos, noside);
  1552.                     }
  1553.                 }
  1554.             }
  1555.         }

  1557.       /* Evaluate arguments (if not already done, e.g., namespace::func()
  1558.          and overload-resolution is off).  */
  1559.       for (; tem <= nargs; tem++)
  1560.         {
  1561.           /* Ensure that array expressions are coerced into pointer
  1562.              objects.  */
  1563.           argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
  1564.         }

  1566.       /* Signal end of arglist.  */
  1567.       argvec[tem] = 0;

  1569.       if (noside == EVAL_SKIP)
  1570.         goto nosideret;

  1572.       if (op == OP_ADL_FUNC)
  1573.         {
  1574.           struct symbol *symp;
  1575.           char *func_name;
  1576.           int  name_len;
  1577.           int string_pc = save_pos1 + 3;

  1579.           /* Extract the function name.  */
  1580.           name_len = longest_to_int (exp->elts[string_pc].longconst);
  1581.           func_name = (char *) alloca (name_len + 1);
  1582.           strcpy (func_name, &exp->elts[string_pc + 1].string);

  1584.           find_overload_match (&argvec[1], nargs, func_name,
  1585.                                NON_METHOD, /* not method */
  1586.                                NULL, NULL, /* pass NULL symbol since
  1587.                                               symbol is unknown */
  1588.                                NULL, &symp, NULL, 0, noside);

  1590.           /* Now fix the expression being evaluated.  */
  1591.           exp->elts[save_pos1 + 2].symbol = symp;
  1592.           argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1, noside);
  1593.         }

  1595.       if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR
  1596.           || (op == OP_SCOPE && function_name != NULL))
  1597.         {
  1598.           int static_memfuncp;
  1599.           char *tstr;

  1601.           /* Method invocation: stuff "this" as first parameter.
  1602.              If the method turns out to be static we undo this below.  */
  1603.           argvec[1] = arg2;

  1605.           if (op != OP_SCOPE)
  1606.             {
  1607.               /* Name of method from expression.  */
  1608.               tstr = &exp->elts[pc2 + 2].string;
  1609.             }
  1610.           else
  1611.             tstr = function_name;

  1613.           if (overload_resolution && (exp->language_defn->la_language
  1614.                                       == language_cplus))
  1615.             {
  1616.               /* Language is C++, do some overload resolution before
  1617.                  evaluation.  */
  1618.               struct value *valp = NULL;

  1620.               (void) find_overload_match (&argvec[1], nargs, tstr,
  1621.                                           METHOD, /* method */
  1622.                                           &arg2,  /* the object */
  1623.                                           NULL, &valp, NULL,
  1624.                                           &static_memfuncp, 0, noside);

  1626.               if (op == OP_SCOPE && !static_memfuncp)
  1627.                 {
  1628.                   /* For the time being, we don't handle this.  */
  1629.                   error (_("Call to overloaded function %s requires "
  1630.                            "`this' pointer"),
  1631.                          function_name);
  1632.                 }
  1633.               argvec[1] = arg2;        /* the ``this'' pointer */
  1634.               argvec[0] = valp;        /* Use the method found after overload
  1635.                                    resolution.  */
  1636.             }
  1637.           else
  1638.             /* Non-C++ case -- or no overload resolution.  */
  1639.             {
  1640.               struct value *temp = arg2;

  1642.               argvec[0] = value_struct_elt (&temp, argvec + 1, tstr,
  1643.                                             &static_memfuncp,
  1644.                                             op == STRUCTOP_STRUCT
  1645.                                        ? "structure" : "structure pointer");
  1646.               /* value_struct_elt updates temp with the correct value
  1647.                   of the ``this'' pointer if necessary, so modify argvec[1] to
  1648.                  reflect any ``this'' changes.  */
  1649.               arg2
  1650.                 = value_from_longest (lookup_pointer_type(value_type (temp)),
  1651.                                       value_address (temp)
  1652.                                       + value_embedded_offset (temp));
  1653.               argvec[1] = arg2;        /* the ``this'' pointer */
  1654.             }

  1656.           /* Take out `this' if needed.  */
  1657.           if (static_memfuncp)
  1658.             {
  1659.               argvec[1] = argvec[0];
  1660.               nargs--;
  1661.               argvec++;
  1662.             }
  1663.         }
  1664.       else if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
  1665.         {
  1666.           /* Pointer to member.  argvec[1] is already set up.  */
  1667.           argvec[0] = arg1;
  1668.         }
  1669.       else if (op == OP_VAR_VALUE || (op == OP_SCOPE && function != NULL))
  1670.         {
  1671.           /* Non-member function being called.  */
  1672.           /* fn: This can only be done for C++ functions.  A C-style function
  1673.              in a C++ program, for instance, does not have the fields that
  1674.              are expected here.  */

  1676.           if (overload_resolution && (exp->language_defn->la_language
  1677.                                       == language_cplus))
  1678.             {
  1679.               /* Language is C++, do some overload resolution before
  1680.                  evaluation.  */
  1681.               struct symbol *symp;
  1682.               int no_adl = 0;

  1684.               /* If a scope has been specified disable ADL.  */
  1685.               if (op == OP_SCOPE)
  1686.                 no_adl = 1;

  1688.               if (op == OP_VAR_VALUE)
  1689.                 function = exp->elts[save_pos1+2].symbol;

  1691.               (void) find_overload_match (&argvec[1], nargs,
  1692.                                           NULL,        /* no need for name */
  1693.                                           NON_METHOD,  /* not method */
  1694.                                           NULL, function, /* the function */
  1695.                                           NULL, &symp, NULL, no_adl, noside);

  1697.               if (op == OP_VAR_VALUE)
  1698.                 {
  1699.                   /* Now fix the expression being evaluated.  */
  1700.                   exp->elts[save_pos1+2].symbol = symp;
  1701.                   argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1,
  1702.                                                              noside);
  1703.                 }
  1704.               else
  1705.                 argvec[0] = value_of_variable (symp, get_selected_block (0));
  1706.             }
  1707.           else
  1708.             {
  1709.               /* Not C++, or no overload resolution allowed.  */
  1710.               /* Nothing to be done; argvec already correctly set up.  */
  1711.             }
  1712.         }
  1713.       else
  1714.         {
  1715.           /* It is probably a C-style function.  */
  1716.           /* Nothing to be done; argvec already correctly set up.  */
  1717.         }

  1719.     do_call_it:

  1721.       if (argvec[0] == NULL)
  1722.         error (_("Cannot evaluate function -- may be inlined"));
  1723.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  1724.         {
  1725.           /* If the return type doesn't look like a function type, call an
  1726.              error.  This can happen if somebody tries to turn a variable into
  1727.              a function call.  This is here because people often want to
  1728.              call, eg, strcmp, which gdb doesn't know is a function.  If
  1729.              gdb isn't asked for it's opinion (ie. through "whatis"),
  1730.              it won't offer it.  */

  1732.           struct type *ftype = value_type (argvec[0]);

  1734.           if (TYPE_CODE (ftype) == TYPE_CODE_INTERNAL_FUNCTION)
  1735.             {
  1736.               /* We don't know anything about what the internal
  1737.                  function might return, but we have to return
  1738.                  something.  */
  1739.               return value_zero (builtin_type (exp->gdbarch)->builtin_int,
  1740.                                  not_lval);
  1741.             }
  1742.           else if (TYPE_GNU_IFUNC (ftype))
  1743.             return allocate_value (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype)));
  1744.           else if (TYPE_TARGET_TYPE (ftype))
  1745.             return allocate_value (TYPE_TARGET_TYPE (ftype));
  1746.           else
  1747.             error (_("Expression of type other than "
  1748.                      "\"Function returning ...\" used as function"));
  1749.         }
  1750.       switch (TYPE_CODE (value_type (argvec[0])))
  1751.         {
  1752.         case TYPE_CODE_INTERNAL_FUNCTION:
  1753.           return call_internal_function (exp->gdbarch, exp->language_defn,
  1754.                                          argvec[0], nargs, argvec + 1);
  1755.         case TYPE_CODE_XMETHOD:
  1756.           return call_xmethod (argvec[0], nargs, argvec + 1);
  1757.         default:
  1758.           return call_function_by_hand (argvec[0], nargs, argvec + 1);
  1759.         }
  1760.       /* pai: FIXME save value from call_function_by_hand, then adjust
  1761.          pc by adjust_fn_pc if +ve.  */

  1763.     case OP_F77_UNDETERMINED_ARGLIST:

  1765.       /* Remember that in F77, functions, substring ops and
  1766.          array subscript operations cannot be disambiguated
  1767.          at parse time.  We have made all array subscript operations,
  1768.          substring operations as well as function calls  come here
  1769.          and we now have to discover what the heck this thing actually was.
  1770.          If it is a function, we process just as if we got an OP_FUNCALL.  */

  1772.       nargs = longest_to_int (exp->elts[pc + 1].longconst);
  1773.       (*pos) += 2;

  1775.       /* First determine the type code we are dealing with.  */
  1776.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  1777.       type = check_typedef (value_type (arg1));
  1778.       code = TYPE_CODE (type);

  1780.       if (code == TYPE_CODE_PTR)
  1781.         {
  1782.           /* Fortran always passes variable to subroutines as pointer.
  1783.              So we need to look into its target type to see if it is
  1784.              array, string or function.  If it is, we need to switch
  1785.              to the target value the original one points to.  */
  1786.           struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));

  1788.           if (TYPE_CODE (target_type) == TYPE_CODE_ARRAY
  1789.               || TYPE_CODE (target_type) == TYPE_CODE_STRING
  1790.               || TYPE_CODE (target_type) == TYPE_CODE_FUNC)
  1791.             {
  1792.               arg1 = value_ind (arg1);
  1793.               type = check_typedef (value_type (arg1));
  1794.               code = TYPE_CODE (type);
  1795.             }
  1796.         }

  1798.       switch (code)
  1799.         {
  1800.         case TYPE_CODE_ARRAY:
  1801.           if (exp->elts[*pos].opcode == OP_F90_RANGE)
  1802.             return value_f90_subarray (arg1, exp, pos, noside);
  1803.           else
  1804.             goto multi_f77_subscript;

  1806.         case TYPE_CODE_STRING:
  1807.           if (exp->elts[*pos].opcode == OP_F90_RANGE)
  1808.             return value_f90_subarray (arg1, exp, pos, noside);
  1809.           else
  1810.             {
  1811.               arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
  1812.               return value_subscript (arg1, value_as_long (arg2));
  1813.             }

  1815.         case TYPE_CODE_PTR:
  1816.         case TYPE_CODE_FUNC:
  1817.           /* It's a function call.  */
  1818.           /* Allocate arg vector, including space for the function to be
  1819.              called in argvec[0] and a terminating NULL.  */
  1820.           argvec = (struct value **)
  1821.             alloca (sizeof (struct value *) * (nargs + 2));
  1822.           argvec[0] = arg1;
  1823.           tem = 1;
  1824.           for (; tem <= nargs; tem++)
  1825.             argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
  1826.           argvec[tem] = 0;        /* signal end of arglist */
  1827.           if (noside == EVAL_SKIP)
  1828.             goto nosideret;
  1829.           goto do_call_it;

  1831.         default:
  1832.           error (_("Cannot perform substring on this type"));
  1833.         }

  1835.     case OP_COMPLEX:
  1836.       /* We have a complex number, There should be 2 floating
  1837.          point numbers that compose it.  */
  1838.       (*pos) += 2;
  1839.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  1840.       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);

  1842.       return value_literal_complex (arg1, arg2, exp->elts[pc + 1].type);

  1844.     case STRUCTOP_STRUCT:
  1845.       tem = longest_to_int (exp->elts[pc + 1].longconst);
  1846.       (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
  1847.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  1848.       if (noside == EVAL_SKIP)
  1849.         goto nosideret;
  1850.       arg3 = value_struct_elt (&arg1, NULL, &exp->elts[pc + 2].string,
  1851.                                NULL, "structure");
  1852.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  1853.         arg3 = value_zero (value_type (arg3), not_lval);
  1854.       return arg3;

  1856.     case STRUCTOP_PTR:
  1857.       tem = longest_to_int (exp->elts[pc + 1].longconst);
  1858.       (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
  1859.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  1860.       if (noside == EVAL_SKIP)
  1861.         goto nosideret;

  1863.       /* Check to see if operator '->' has been overloaded.  If so replace
  1864.          arg1 with the value returned by evaluating operator->().  */
  1865.       while (unop_user_defined_p (op, arg1))
  1866.         {
  1867.           volatile struct gdb_exception except;
  1868.           struct value *value = NULL;
  1869.           TRY_CATCH (except, RETURN_MASK_ERROR)
  1870.             {
  1871.               value = value_x_unop (arg1, op, noside);
  1872.             }

  1874.           if (except.reason < 0)
  1875.             {
  1876.               if (except.error == NOT_FOUND_ERROR)
  1877.                 break;
  1878.               else
  1879.                 throw_exception (except);
  1880.             }
  1881.           arg1 = value;
  1882.         }

  1884.       /* JYG: if print object is on we need to replace the base type
  1885.          with rtti type in order to continue on with successful
  1886.          lookup of member / method only available in the rtti type.  */
  1887.       {
  1888.         struct type *type = value_type (arg1);
  1889.         struct type *real_type;
  1890.         int full, top, using_enc;
  1891.         struct value_print_options opts;

  1893.         get_user_print_options (&opts);
  1894.         if (opts.objectprint && TYPE_TARGET_TYPE(type)
  1895.             && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT))
  1896.           {
  1897.             real_type = value_rtti_indirect_type (arg1, &full, &top,
  1898.                                                   &using_enc);
  1899.             if (real_type)
  1900.                 arg1 = value_cast (real_type, arg1);
  1901.           }
  1902.       }

  1904.       arg3 = value_struct_elt (&arg1, NULL, &exp->elts[pc + 2].string,
  1905.                                NULL, "structure pointer");
  1906.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  1907.         arg3 = value_zero (value_type (arg3), not_lval);
  1908.       return arg3;

  1910.     case STRUCTOP_MEMBER:
  1911.     case STRUCTOP_MPTR:
  1912.       if (op == STRUCTOP_MEMBER)
  1913.         arg1 = evaluate_subexp_for_address (exp, pos, noside);
  1914.       else
  1915.         arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);

  1917.       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);

  1919.       if (noside == EVAL_SKIP)
  1920.         goto nosideret;

  1922.       type = check_typedef (value_type (arg2));
  1923.       switch (TYPE_CODE (type))
  1924.         {
  1925.         case TYPE_CODE_METHODPTR:
  1926.           if (noside == EVAL_AVOID_SIDE_EFFECTS)
  1927.             return value_zero (TYPE_TARGET_TYPE (type), not_lval);
  1928.           else
  1929.             {
  1930.               arg2 = cplus_method_ptr_to_value (&arg1, arg2);
  1931.               gdb_assert (TYPE_CODE (value_type (arg2)) == TYPE_CODE_PTR);
  1932.               return value_ind (arg2);
  1933.             }

  1935.         case TYPE_CODE_MEMBERPTR:
  1936.           /* Now, convert these values to an address.  */
  1937.           arg1 = value_cast_pointers (lookup_pointer_type (TYPE_DOMAIN_TYPE (type)),
  1938.                                       arg1, 1);

  1940.           mem_offset = value_as_long (arg2);

  1942.           arg3 = value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
  1943.                                      value_as_long (arg1) + mem_offset);
  1944.           return value_ind (arg3);

  1946.         default:
  1947.           error (_("non-pointer-to-member value used "
  1948.                    "in pointer-to-member construct"));
  1949.         }

  1951.     case TYPE_INSTANCE:
  1952.       nargs = longest_to_int (exp->elts[pc + 1].longconst);
  1953.       arg_types = (struct type **) alloca (nargs * sizeof (struct type *));
  1954.       for (ix = 0; ix < nargs; ++ix)
  1955.         arg_types[ix] = exp->elts[pc + 1 + ix + 1].type;

  1957.       expect_type = make_params (nargs, arg_types);
  1958.       *(pos) += 3 + nargs;
  1959.       arg1 = evaluate_subexp_standard (expect_type, exp, pos, noside);
  1960.       xfree (TYPE_FIELDS (expect_type));
  1961.       xfree (TYPE_MAIN_TYPE (expect_type));
  1962.       xfree (expect_type);
  1963.       return arg1;

  1965.     case BINOP_CONCAT:
  1966.       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
  1967.       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
  1968.       if (noside == EVAL_SKIP)
  1969.         goto nosideret;
  1970.       if (binop_user_defined_p (op, arg1, arg2))
  1971.         return value_x_binop (arg1, arg2, op, OP_NULL, noside);
  1972.       else
  1973.         return value_concat (arg1, arg2);

  1975.     case BINOP_ASSIGN:
  1976.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  1977.       arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);

  1979.       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
  1980.         return arg1;
  1981.       if (binop_user_defined_p (op, arg1, arg2))
  1982.         return value_x_binop (arg1, arg2, op, OP_NULL, noside);
  1983.       else
  1984.         return value_assign (arg1, arg2);

  1986.     case BINOP_ASSIGN_MODIFY:
  1987.       (*pos) += 2;
  1988.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  1989.       arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
  1990.       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
  1991.         return arg1;
  1992.       op = exp->elts[pc + 1].opcode;
  1993.       if (binop_user_defined_p (op, arg1, arg2))
  1994.         return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op, noside);
  1995.       else if (op == BINOP_ADD && ptrmath_type_p (exp->language_defn,
  1996.                                                   value_type (arg1))
  1997.                && is_integral_type (value_type (arg2)))
  1998.         arg2 = value_ptradd (arg1, value_as_long (arg2));
  1999.       else if (op == BINOP_SUB && ptrmath_type_p (exp->language_defn,
  2000.                                                   value_type (arg1))
  2001.                && is_integral_type (value_type (arg2)))
  2002.         arg2 = value_ptradd (arg1, - value_as_long (arg2));
  2003.       else
  2004.         {
  2005.           struct value *tmp = arg1;

  2007.           /* For shift and integer exponentiation operations,
  2008.              only promote the first argument.  */
  2009.           if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
  2010.               && is_integral_type (value_type (arg2)))
  2011.             unop_promote (exp->language_defn, exp->gdbarch, &tmp);
  2012.           else
  2013.             binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);

  2015.           arg2 = value_binop (tmp, arg2, op);
  2016.         }
  2017.       return value_assign (arg1, arg2);

  2019.     case BINOP_ADD:
  2020.       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
  2021.       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
  2022.       if (noside == EVAL_SKIP)
  2023.         goto nosideret;
  2024.       if (binop_user_defined_p (op, arg1, arg2))
  2025.         return value_x_binop (arg1, arg2, op, OP_NULL, noside);
  2026.       else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
  2027.                && is_integral_type (value_type (arg2)))
  2028.         return value_ptradd (arg1, value_as_long (arg2));
  2029.       else if (ptrmath_type_p (exp->language_defn, value_type (arg2))
  2030.                && is_integral_type (value_type (arg1)))
  2031.         return value_ptradd (arg2, value_as_long (arg1));
  2032.       else
  2033.         {
  2034.           binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
  2035.           return value_binop (arg1, arg2, BINOP_ADD);
  2036.         }

  2038.     case BINOP_SUB:
  2039.       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
  2040.       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
  2041.       if (noside == EVAL_SKIP)
  2042.         goto nosideret;
  2043.       if (binop_user_defined_p (op, arg1, arg2))
  2044.         return value_x_binop (arg1, arg2, op, OP_NULL, noside);
  2045.       else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
  2046.                && ptrmath_type_p (exp->language_defn, value_type (arg2)))
  2047.         {
  2048.           /* FIXME -- should be ptrdiff_t */
  2049.           type = builtin_type (exp->gdbarch)->builtin_long;
  2050.           return value_from_longest (type, value_ptrdiff (arg1, arg2));
  2051.         }
  2052.       else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
  2053.                && is_integral_type (value_type (arg2)))
  2054.         return value_ptradd (arg1, - value_as_long (arg2));
  2055.       else
  2056.         {
  2057.           binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
  2058.           return value_binop (arg1, arg2, BINOP_SUB);
  2059.         }

  2061.     case BINOP_EXP:
  2062.     case BINOP_MUL:
  2063.     case BINOP_DIV:
  2064.     case BINOP_INTDIV:
  2065.     case BINOP_REM:
  2066.     case BINOP_MOD:
  2067.     case BINOP_LSH:
  2068.     case BINOP_RSH:
  2069.     case BINOP_BITWISE_AND:
  2070.     case BINOP_BITWISE_IOR:
  2071.     case BINOP_BITWISE_XOR:
  2072.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  2073.       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  2074.       if (noside == EVAL_SKIP)
  2075.         goto nosideret;
  2076.       if (binop_user_defined_p (op, arg1, arg2))
  2077.         return value_x_binop (arg1, arg2, op, OP_NULL, noside);
  2078.       else
  2079.         {
  2080.           /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
  2081.              fudge arg2 to avoid division-by-zero, the caller is
  2082.              (theoretically) only looking for the type of the result.  */
  2083.           if (noside == EVAL_AVOID_SIDE_EFFECTS
  2084.               /* ??? Do we really want to test for BINOP_MOD here?
  2085.                  The implementation of value_binop gives it a well-defined
  2086.                  value.  */
  2087.               && (op == BINOP_DIV
  2088.                   || op == BINOP_INTDIV
  2089.                   || op == BINOP_REM
  2090.                   || op == BINOP_MOD)
  2091.               && value_logical_not (arg2))
  2092.             {
  2093.               struct value *v_one, *retval;

  2095.               v_one = value_one (value_type (arg2));
  2096.               binop_promote (exp->language_defn, exp->gdbarch, &arg1, &v_one);
  2097.               retval = value_binop (arg1, v_one, op);
  2098.               return retval;
  2099.             }
  2100.           else
  2101.             {
  2102.               /* For shift and integer exponentiation operations,
  2103.                  only promote the first argument.  */
  2104.               if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
  2105.                   && is_integral_type (value_type (arg2)))
  2106.                 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
  2107.               else
  2108.                 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);

  2110.               return value_binop (arg1, arg2, op);
  2111.             }
  2112.         }

  2114.     case BINOP_SUBSCRIPT:
  2115.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  2116.       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  2117.       if (noside == EVAL_SKIP)
  2118.         goto nosideret;
  2119.       if (binop_user_defined_p (op, arg1, arg2))
  2120.         return value_x_binop (arg1, arg2, op, OP_NULL, noside);
  2121.       else
  2122.         {
  2123.           /* If the user attempts to subscript something that is not an
  2124.              array or pointer type (like a plain int variable for example),
  2125.              then report this as an error.  */

  2127.           arg1 = coerce_ref (arg1);
  2128.           type = check_typedef (value_type (arg1));
  2129.           if (TYPE_CODE (type) != TYPE_CODE_ARRAY
  2130.               && TYPE_CODE (type) != TYPE_CODE_PTR)
  2131.             {
  2132.               if (TYPE_NAME (type))
  2133.                 error (_("cannot subscript something of type `%s'"),
  2134.                        TYPE_NAME (type));
  2135.               else
  2136.                 error (_("cannot subscript requested type"));
  2137.             }

  2139.           if (noside == EVAL_AVOID_SIDE_EFFECTS)
  2140.             return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1));
  2141.           else
  2142.             return value_subscript (arg1, value_as_long (arg2));
  2143.         }
  2144.     case MULTI_SUBSCRIPT:
  2145.       (*pos) += 2;
  2146.       nargs = longest_to_int (exp->elts[pc + 1].longconst);
  2147.       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
  2148.       while (nargs-- > 0)
  2149.         {
  2150.           arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
  2151.           /* FIXME:  EVAL_SKIP handling may not be correct.  */
  2152.           if (noside == EVAL_SKIP)
  2153.             {
  2154.               if (nargs > 0)
  2155.                 {
  2156.                   continue;
  2157.                 }
  2158.               else
  2159.                 {
  2160.                   goto nosideret;
  2161.                 }
  2162.             }
  2163.           /* FIXME:  EVAL_AVOID_SIDE_EFFECTS handling may not be correct.  */
  2164.           if (noside == EVAL_AVOID_SIDE_EFFECTS)
  2165.             {
  2166.               /* If the user attempts to subscript something that has no target
  2167.                  type (like a plain int variable for example), then report this
  2168.                  as an error.  */

  2170.               type = TYPE_TARGET_TYPE (check_typedef (value_type (arg1)));
  2171.               if (type != NULL)
  2172.                 {
  2173.                   arg1 = value_zero (type, VALUE_LVAL (arg1));
  2174.                   noside = EVAL_SKIP;
  2175.                   continue;
  2176.                 }
  2177.               else
  2178.                 {
  2179.                   error (_("cannot subscript something of type `%s'"),
  2180.                          TYPE_NAME (value_type (arg1)));
  2181.                 }
  2182.             }

  2184.           if (binop_user_defined_p (op, arg1, arg2))
  2185.             {
  2186.               arg1 = value_x_binop (arg1, arg2, op, OP_NULL, noside);
  2187.             }
  2188.           else
  2189.             {
  2190.               arg1 = coerce_ref (arg1);
  2191.               type = check_typedef (value_type (arg1));

  2193.               switch (TYPE_CODE (type))
  2194.                 {
  2195.                 case TYPE_CODE_PTR:
  2196.                 case TYPE_CODE_ARRAY:
  2197.                 case TYPE_CODE_STRING:
  2198.                   arg1 = value_subscript (arg1, value_as_long (arg2));
  2199.                   break;

  2201.                 default:
  2202.                   if (TYPE_NAME (type))
  2203.                     error (_("cannot subscript something of type `%s'"),
  2204.                            TYPE_NAME (type));
  2205.                   else
  2206.                     error (_("cannot subscript requested type"));
  2207.                 }
  2208.             }
  2209.         }
  2210.       return (arg1);

  2212.     multi_f77_subscript:
  2213.       {
  2214.         LONGEST subscript_array[MAX_FORTRAN_DIMS];
  2215.         int ndimensions = 1, i;
  2216.         struct value *array = arg1;

  2218.         if (nargs > MAX_FORTRAN_DIMS)
  2219.           error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS);

  2221.         ndimensions = calc_f77_array_dims (type);

  2223.         if (nargs != ndimensions)
  2224.           error (_("Wrong number of subscripts"));

  2226.         gdb_assert (nargs > 0);

  2228.         /* Now that we know we have a legal array subscript expression
  2229.            let us actually find out where this element exists in the array.  */

  2231.         /* Take array indices left to right.  */
  2232.         for (i = 0; i < nargs; i++)
  2233.           {
  2234.             /* Evaluate each subscript; it must be a legal integer in F77.  */
  2235.             arg2 = evaluate_subexp_with_coercion (exp, pos, noside);

  2237.             /* Fill in the subscript array.  */

  2239.             subscript_array[i] = value_as_long (arg2);
  2240.           }

  2242.         /* Internal type of array is arranged right to left.  */
  2243.         for (i = nargs; i > 0; i--)
  2244.           {
  2245.             struct type *array_type = check_typedef (value_type (array));
  2246.             LONGEST index = subscript_array[i - 1];

  2248.             array = value_subscripted_rvalue (array, index,
  2249.                                               f77_get_lowerbound (array_type));
  2250.           }

  2252.         return array;
  2253.       }

  2255.     case BINOP_LOGICAL_AND:
  2256.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  2257.       if (noside == EVAL_SKIP)
  2258.         {
  2259.           evaluate_subexp (NULL_TYPE, exp, pos, noside);
  2260.           goto nosideret;
  2261.         }

  2263.       oldpos = *pos;
  2264.       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
  2265.       *pos = oldpos;

  2267.       if (binop_user_defined_p (op, arg1, arg2))
  2268.         {
  2269.           arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  2270.           return value_x_binop (arg1, arg2, op, OP_NULL, noside);
  2271.         }
  2272.       else
  2273.         {
  2274.           tem = value_logical_not (arg1);
  2275.           arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
  2276.                                   (tem ? EVAL_SKIP : noside));
  2277.           type = language_bool_type (exp->language_defn, exp->gdbarch);
  2278.           return value_from_longest (type,
  2279.                              (LONGEST) (!tem && !value_logical_not (arg2)));
  2280.         }

  2282.     case BINOP_LOGICAL_OR:
  2283.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  2284.       if (noside == EVAL_SKIP)
  2285.         {
  2286.           evaluate_subexp (NULL_TYPE, exp, pos, noside);
  2287.           goto nosideret;
  2288.         }

  2290.       oldpos = *pos;
  2291.       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
  2292.       *pos = oldpos;

  2294.       if (binop_user_defined_p (op, arg1, arg2))
  2295.         {
  2296.           arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  2297.           return value_x_binop (arg1, arg2, op, OP_NULL, noside);
  2298.         }
  2299.       else
  2300.         {
  2301.           tem = value_logical_not (arg1);
  2302.           arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
  2303.                                   (!tem ? EVAL_SKIP : noside));
  2304.           type = language_bool_type (exp->language_defn, exp->gdbarch);
  2305.           return value_from_longest (type,
  2306.                              (LONGEST) (!tem || !value_logical_not (arg2)));
  2307.         }

  2309.     case BINOP_EQUAL:
  2310.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  2311.       arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
  2312.       if (noside == EVAL_SKIP)
  2313.         goto nosideret;
  2314.       if (binop_user_defined_p (op, arg1, arg2))
  2315.         {
  2316.           return value_x_binop (arg1, arg2, op, OP_NULL, noside);
  2317.         }
  2318.       else
  2319.         {
  2320.           binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
  2321.           tem = value_equal (arg1, arg2);
  2322.           type = language_bool_type (exp->language_defn, exp->gdbarch);
  2323.           return value_from_longest (type, (LONGEST) tem);
  2324.         }

  2326.     case BINOP_NOTEQUAL:
  2327.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  2328.       arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
  2329.       if (noside == EVAL_SKIP)
  2330.         goto nosideret;
  2331.       if (binop_user_defined_p (op, arg1, arg2))
  2332.         {
  2333.           return value_x_binop (arg1, arg2, op, OP_NULL, noside);
  2334.         }
  2335.       else
  2336.         {
  2337.           binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
  2338.           tem = value_equal (arg1, arg2);
  2339.           type = language_bool_type (exp->language_defn, exp->gdbarch);
  2340.           return value_from_longest (type, (LONGEST) ! tem);
  2341.         }

  2343.     case BINOP_LESS:
  2344.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  2345.       arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
  2346.       if (noside == EVAL_SKIP)
  2347.         goto nosideret;
  2348.       if (binop_user_defined_p (op, arg1, arg2))
  2349.         {
  2350.           return value_x_binop (arg1, arg2, op, OP_NULL, noside);
  2351.         }
  2352.       else
  2353.         {
  2354.           binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
  2355.           tem = value_less (arg1, arg2);
  2356.           type = language_bool_type (exp->language_defn, exp->gdbarch);
  2357.           return value_from_longest (type, (LONGEST) tem);
  2358.         }

  2360.     case BINOP_GTR:
  2361.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  2362.       arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
  2363.       if (noside == EVAL_SKIP)
  2364.         goto nosideret;
  2365.       if (binop_user_defined_p (op, arg1, arg2))
  2366.         {
  2367.           return value_x_binop (arg1, arg2, op, OP_NULL, noside);
  2368.         }
  2369.       else
  2370.         {
  2371.           binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
  2372.           tem = value_less (arg2, arg1);
  2373.           type = language_bool_type (exp->language_defn, exp->gdbarch);
  2374.           return value_from_longest (type, (LONGEST) tem);
  2375.         }

  2377.     case BINOP_GEQ:
  2378.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  2379.       arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
  2380.       if (noside == EVAL_SKIP)
  2381.         goto nosideret;
  2382.       if (binop_user_defined_p (op, arg1, arg2))
  2383.         {
  2384.           return value_x_binop (arg1, arg2, op, OP_NULL, noside);
  2385.         }
  2386.       else
  2387.         {
  2388.           binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
  2389.           tem = value_less (arg2, arg1) || value_equal (arg1, arg2);
  2390.           type = language_bool_type (exp->language_defn, exp->gdbarch);
  2391.           return value_from_longest (type, (LONGEST) tem);
  2392.         }

  2394.     case BINOP_LEQ:
  2395.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  2396.       arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
  2397.       if (noside == EVAL_SKIP)
  2398.         goto nosideret;
  2399.       if (binop_user_defined_p (op, arg1, arg2))
  2400.         {
  2401.           return value_x_binop (arg1, arg2, op, OP_NULL, noside);
  2402.         }
  2403.       else
  2404.         {
  2405.           binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
  2406.           tem = value_less (arg1, arg2) || value_equal (arg1, arg2);
  2407.           type = language_bool_type (exp->language_defn, exp->gdbarch);
  2408.           return value_from_longest (type, (LONGEST) tem);
  2409.         }

  2411.     case BINOP_REPEAT:
  2412.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  2413.       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  2414.       if (noside == EVAL_SKIP)
  2415.         goto nosideret;
  2416.       type = check_typedef (value_type (arg2));
  2417.       if (TYPE_CODE (type) != TYPE_CODE_INT)
  2418.         error (_("Non-integral right operand for \"@\" operator."));
  2419.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  2420.         {
  2421.           return allocate_repeat_value (value_type (arg1),
  2422.                                      longest_to_int (value_as_long (arg2)));
  2423.         }
  2424.       else
  2425.         return value_repeat (arg1, longest_to_int (value_as_long (arg2)));

  2427.     case BINOP_COMMA:
  2428.       evaluate_subexp (NULL_TYPE, exp, pos, noside);
  2429.       return evaluate_subexp (NULL_TYPE, exp, pos, noside);

  2431.     case UNOP_PLUS:
  2432.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  2433.       if (noside == EVAL_SKIP)
  2434.         goto nosideret;
  2435.       if (unop_user_defined_p (op, arg1))
  2436.         return value_x_unop (arg1, op, noside);
  2437.       else
  2438.         {
  2439.           unop_promote (exp->language_defn, exp->gdbarch, &arg1);
  2440.           return value_pos (arg1);
  2441.         }

  2443.     case UNOP_NEG:
  2444.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  2445.       if (noside == EVAL_SKIP)
  2446.         goto nosideret;
  2447.       if (unop_user_defined_p (op, arg1))
  2448.         return value_x_unop (arg1, op, noside);
  2449.       else
  2450.         {
  2451.           unop_promote (exp->language_defn, exp->gdbarch, &arg1);
  2452.           return value_neg (arg1);
  2453.         }

  2455.     case UNOP_COMPLEMENT:
  2456.       /* C++: check for and handle destructor names.  */
  2457.       op = exp->elts[*pos].opcode;

  2459.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  2460.       if (noside == EVAL_SKIP)
  2461.         goto nosideret;
  2462.       if (unop_user_defined_p (UNOP_COMPLEMENT, arg1))
  2463.         return value_x_unop (arg1, UNOP_COMPLEMENT, noside);
  2464.       else
  2465.         {
  2466.           unop_promote (exp->language_defn, exp->gdbarch, &arg1);
  2467.           return value_complement (arg1);
  2468.         }

  2470.     case UNOP_LOGICAL_NOT:
  2471.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  2472.       if (noside == EVAL_SKIP)
  2473.         goto nosideret;
  2474.       if (unop_user_defined_p (op, arg1))
  2475.         return value_x_unop (arg1, op, noside);
  2476.       else
  2477.         {
  2478.           type = language_bool_type (exp->language_defn, exp->gdbarch);
  2479.           return value_from_longest (type, (LONGEST) value_logical_not (arg1));
  2480.         }

  2482.     case UNOP_IND:
  2483.       if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
  2484.         expect_type = TYPE_TARGET_TYPE (check_typedef (expect_type));
  2485.       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
  2486.       type = check_typedef (value_type (arg1));
  2487.       if (TYPE_CODE (type) == TYPE_CODE_METHODPTR
  2488.           || TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)
  2489.         error (_("Attempt to dereference pointer "
  2490.                  "to member without an object"));
  2491.       if (noside == EVAL_SKIP)
  2492.         goto nosideret;
  2493.       if (unop_user_defined_p (op, arg1))
  2494.         return value_x_unop (arg1, op, noside);
  2495.       else if (noside == EVAL_AVOID_SIDE_EFFECTS)
  2496.         {
  2497.           type = check_typedef (value_type (arg1));
  2498.           if (TYPE_CODE (type) == TYPE_CODE_PTR
  2499.               || TYPE_CODE (type) == TYPE_CODE_REF
  2500.           /* In C you can dereference an array to get the 1st elt.  */
  2501.               || TYPE_CODE (type) == TYPE_CODE_ARRAY
  2502.             )
  2503.             return value_zero (TYPE_TARGET_TYPE (type),
  2504.                                lval_memory);
  2505.           else if (TYPE_CODE (type) == TYPE_CODE_INT)
  2506.             /* GDB allows dereferencing an int.  */
  2507.             return value_zero (builtin_type (exp->gdbarch)->builtin_int,
  2508.                                lval_memory);
  2509.           else
  2510.             error (_("Attempt to take contents of a non-pointer value."));
  2511.         }

  2513.       /* Allow * on an integer so we can cast it to whatever we want.
  2514.          This returns an int, which seems like the most C-like thing to
  2515.          do.  "long long" variables are rare enough that
  2516.          BUILTIN_TYPE_LONGEST would seem to be a mistake.  */
  2517.       if (TYPE_CODE (type) == TYPE_CODE_INT)
  2518.         return value_at_lazy (builtin_type (exp->gdbarch)->builtin_int,
  2519.                               (CORE_ADDR) value_as_address (arg1));
  2520.       return value_ind (arg1);

  2522.     case UNOP_ADDR:
  2523.       /* C++: check for and handle pointer to members.  */

  2525.       op = exp->elts[*pos].opcode;

  2527.       if (noside == EVAL_SKIP)
  2528.         {
  2529.           evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
  2530.           goto nosideret;
  2531.         }
  2532.       else
  2533.         {
  2534.           struct value *retvalp = evaluate_subexp_for_address (exp, pos,
  2535.                                                                noside);

  2537.           return retvalp;
  2538.         }

  2540.     case UNOP_SIZEOF:
  2541.       if (noside == EVAL_SKIP)
  2542.         {
  2543.           evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
  2544.           goto nosideret;
  2545.         }
  2546.       return evaluate_subexp_for_sizeof (exp, pos, noside);

  2548.     case UNOP_CAST:
  2549.       (*pos) += 2;
  2550.       type = exp->elts[pc + 1].type;
  2551.       arg1 = evaluate_subexp (type, exp, pos, noside);
  2552.       if (noside == EVAL_SKIP)
  2553.         goto nosideret;
  2554.       if (type != value_type (arg1))
  2555.         arg1 = value_cast (type, arg1);
  2556.       return arg1;

  2558.     case UNOP_CAST_TYPE:
  2559.       arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
  2560.       type = value_type (arg1);
  2561.       arg1 = evaluate_subexp (type, exp, pos, noside);
  2562.       if (noside == EVAL_SKIP)
  2563.         goto nosideret;
  2564.       if (type != value_type (arg1))
  2565.         arg1 = value_cast (type, arg1);
  2566.       return arg1;

  2568.     case UNOP_DYNAMIC_CAST:
  2569.       arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
  2570.       type = value_type (arg1);
  2571.       arg1 = evaluate_subexp (type, exp, pos, noside);
  2572.       if (noside == EVAL_SKIP)
  2573.         goto nosideret;
  2574.       return value_dynamic_cast (type, arg1);

  2576.     case UNOP_REINTERPRET_CAST:
  2577.       arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
  2578.       type = value_type (arg1);
  2579.       arg1 = evaluate_subexp (type, exp, pos, noside);
  2580.       if (noside == EVAL_SKIP)
  2581.         goto nosideret;
  2582.       return value_reinterpret_cast (type, arg1);

  2584.     case UNOP_MEMVAL:
  2585.       (*pos) += 2;
  2586.       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
  2587.       if (noside == EVAL_SKIP)
  2588.         goto nosideret;
  2589.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  2590.         return value_zero (exp->elts[pc + 1].type, lval_memory);
  2591.       else
  2592.         return value_at_lazy (exp->elts[pc + 1].type,
  2593.                               value_as_address (arg1));

  2595.     case UNOP_MEMVAL_TYPE:
  2596.       arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
  2597.       type = value_type (arg1);
  2598.       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
  2599.       if (noside == EVAL_SKIP)
  2600.         goto nosideret;
  2601.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  2602.         return value_zero (type, lval_memory);
  2603.       else
  2604.         return value_at_lazy (type, value_as_address (arg1));

  2606.     case UNOP_MEMVAL_TLS:
  2607.       (*pos) += 3;
  2608.       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
  2609.       if (noside == EVAL_SKIP)
  2610.         goto nosideret;
  2611.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  2612.         return value_zero (exp->elts[pc + 2].type, lval_memory);
  2613.       else
  2614.         {
  2615.           CORE_ADDR tls_addr;

  2617.           tls_addr = target_translate_tls_address (exp->elts[pc + 1].objfile,
  2618.                                                    value_as_address (arg1));
  2619.           return value_at_lazy (exp->elts[pc + 2].type, tls_addr);
  2620.         }

  2622.     case UNOP_PREINCREMENT:
  2623.       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
  2624.       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
  2625.         return arg1;
  2626.       else if (unop_user_defined_p (op, arg1))
  2627.         {
  2628.           return value_x_unop (arg1, op, noside);
  2629.         }
  2630.       else
  2631.         {
  2632.           if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
  2633.             arg2 = value_ptradd (arg1, 1);
  2634.           else
  2635.             {
  2636.               struct value *tmp = arg1;

  2638.               arg2 = value_one (value_type (arg1));
  2639.               binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
  2640.               arg2 = value_binop (tmp, arg2, BINOP_ADD);
  2641.             }

  2643.           return value_assign (arg1, arg2);
  2644.         }

  2646.     case UNOP_PREDECREMENT:
  2647.       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
  2648.       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
  2649.         return arg1;
  2650.       else if (unop_user_defined_p (op, arg1))
  2651.         {
  2652.           return value_x_unop (arg1, op, noside);
  2653.         }
  2654.       else
  2655.         {
  2656.           if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
  2657.             arg2 = value_ptradd (arg1, -1);
  2658.           else
  2659.             {
  2660.               struct value *tmp = arg1;

  2662.               arg2 = value_one (value_type (arg1));
  2663.               binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
  2664.               arg2 = value_binop (tmp, arg2, BINOP_SUB);
  2665.             }

  2667.           return value_assign (arg1, arg2);
  2668.         }

  2670.     case UNOP_POSTINCREMENT:
  2671.       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
  2672.       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
  2673.         return arg1;
  2674.       else if (unop_user_defined_p (op, arg1))
  2675.         {
  2676.           return value_x_unop (arg1, op, noside);
  2677.         }
  2678.       else
  2679.         {
  2680.           arg3 = value_non_lval (arg1);

  2682.           if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
  2683.             arg2 = value_ptradd (arg1, 1);
  2684.           else
  2685.             {
  2686.               struct value *tmp = arg1;

  2688.               arg2 = value_one (value_type (arg1));
  2689.               binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
  2690.               arg2 = value_binop (tmp, arg2, BINOP_ADD);
  2691.             }

  2693.           value_assign (arg1, arg2);
  2694.           return arg3;
  2695.         }

  2697.     case UNOP_POSTDECREMENT:
  2698.       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
  2699.       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
  2700.         return arg1;
  2701.       else if (unop_user_defined_p (op, arg1))
  2702.         {
  2703.           return value_x_unop (arg1, op, noside);
  2704.         }
  2705.       else
  2706.         {
  2707.           arg3 = value_non_lval (arg1);

  2709.           if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
  2710.             arg2 = value_ptradd (arg1, -1);
  2711.           else
  2712.             {
  2713.               struct value *tmp = arg1;

  2715.               arg2 = value_one (value_type (arg1));
  2716.               binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
  2717.               arg2 = value_binop (tmp, arg2, BINOP_SUB);
  2718.             }

  2720.           value_assign (arg1, arg2);
  2721.           return arg3;
  2722.         }

  2724.     case OP_THIS:
  2725.       (*pos) += 1;
  2726.       return value_of_this (exp->language_defn);

  2728.     case OP_TYPE:
  2729.       /* The value is not supposed to be used.  This is here to make it
  2730.          easier to accommodate expressions that contain types.  */
  2731.       (*pos) += 2;
  2732.       if (noside == EVAL_SKIP)
  2733.         goto nosideret;
  2734.       else if (noside == EVAL_AVOID_SIDE_EFFECTS)
  2735.         {
  2736.           struct type *type = exp->elts[pc + 1].type;

  2738.           /* If this is a typedef, then find its immediate target.  We
  2739.              use check_typedef to resolve stubs, but we ignore its
  2740.              result because we do not want to dig past all
  2741.              typedefs.  */
  2742.           check_typedef (type);
  2743.           if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
  2744.             type = TYPE_TARGET_TYPE (type);
  2745.           return allocate_value (type);
  2746.         }
  2747.       else
  2748.         error (_("Attempt to use a type name as an expression"));

  2750.     case OP_TYPEOF:
  2751.     case OP_DECLTYPE:
  2752.       if (noside == EVAL_SKIP)
  2753.         {
  2754.           evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
  2755.           goto nosideret;
  2756.         }
  2757.       else if (noside == EVAL_AVOID_SIDE_EFFECTS)
  2758.         {
  2759.           enum exp_opcode sub_op = exp->elts[*pos].opcode;
  2760.           struct value *result;

  2762.           result = evaluate_subexp (NULL_TYPE, exp, pos,
  2763.                                     EVAL_AVOID_SIDE_EFFECTS);

  2765.           /* 'decltype' has special semantics for lvalues.  */
  2766.           if (op == OP_DECLTYPE
  2767.               && (sub_op == BINOP_SUBSCRIPT
  2768.                   || sub_op == STRUCTOP_MEMBER
  2769.                   || sub_op == STRUCTOP_MPTR
  2770.                   || sub_op == UNOP_IND
  2771.                   || sub_op == STRUCTOP_STRUCT
  2772.                   || sub_op == STRUCTOP_PTR
  2773.                   || sub_op == OP_SCOPE))
  2774.             {
  2775.               struct type *type = value_type (result);

  2777.               if (TYPE_CODE (check_typedef (type)) != TYPE_CODE_REF)
  2778.                 {
  2779.                   type = lookup_reference_type (type);
  2780.                   result = allocate_value (type);
  2781.                 }
  2782.             }

  2784.           return result;
  2785.         }
  2786.       else
  2787.         error (_("Attempt to use a type as an expression"));

  2789.     case OP_TYPEID:
  2790.       {
  2791.         struct value *result;
  2792.         enum exp_opcode sub_op = exp->elts[*pos].opcode;

  2794.         if (sub_op == OP_TYPE || sub_op == OP_DECLTYPE || sub_op == OP_TYPEOF)
  2795.           result = evaluate_subexp (NULL_TYPE, exp, pos,
  2796.                                     EVAL_AVOID_SIDE_EFFECTS);
  2797.         else
  2798.           result = evaluate_subexp (NULL_TYPE, exp, pos, noside);

  2800.         if (noside != EVAL_NORMAL)
  2801.           return allocate_value (cplus_typeid_type (exp->gdbarch));

  2803.         return cplus_typeid (result);
  2804.       }

  2806.     default:
  2807.       /* Removing this case and compiling with gcc -Wall reveals that
  2808.          a lot of cases are hitting this case.  Some of these should
  2809.          probably be removed from expression.h; others are legitimate
  2810.          expressions which are (apparently) not fully implemented.

  2812.          If there are any cases landing here which mean a user error,
  2813.          then they should be separate cases, with more descriptive
  2814.          error messages.  */

  2816.       error (_("GDB does not (yet) know how to "
  2817.                "evaluate that kind of expression"));
  2818.     }

  2820. nosideret:
  2821.   return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1);
  2822. }

  2824. /* Evaluate a subexpression of EXP, at index *POS,
  2825.    and return the address of that subexpression.
  2826.    Advance *POS over the subexpression.
  2827.    If the subexpression isn't an lvalue, get an error.
  2828.    NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
  2829.    then only the type of the result need be correct.  */

  2831. static struct value *
  2832. ‌evaluate_subexp_for_address (struct expression *exp, int *pos,
  2833.                              enum noside noside)
  2834. {
  2835.   enum exp_opcode op;
  2836.   int pc;
  2837.   struct symbol *var;
  2838.   struct value *x;
  2839.   int tem;

  2841.   pc = (*pos);
  2842.   op = exp->elts[pc].opcode;

  2844.   switch (op)
  2845.     {
  2846.     case UNOP_IND:
  2847.       (*pos)++;
  2848.       x = evaluate_subexp (NULL_TYPE, exp, pos, noside);

  2850.       /* We can't optimize out "&*" if there's a user-defined operator*.  */
  2851.       if (unop_user_defined_p (op, x))
  2852.         {
  2853.           x = value_x_unop (x, op, noside);
  2854.           goto default_case_after_eval;
  2855.         }

  2857.       return coerce_array (x);

  2859.     case UNOP_MEMVAL:
  2860.       (*pos) += 3;
  2861.       return value_cast (lookup_pointer_type (exp->elts[pc + 1].type),
  2862.                          evaluate_subexp (NULL_TYPE, exp, pos, noside));

  2864.     case UNOP_MEMVAL_TYPE:
  2865.       {
  2866.         struct type *type;

  2868.         (*pos) += 1;
  2869.         x = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
  2870.         type = value_type (x);
  2871.         return value_cast (lookup_pointer_type (type),
  2872.                            evaluate_subexp (NULL_TYPE, exp, pos, noside));
  2873.       }

  2875.     case OP_VAR_VALUE:
  2876.       var = exp->elts[pc + 2].symbol;

  2878.       /* C++: The "address" of a reference should yield the address
  2879.        * of the object pointed to.  Let value_addr() deal with it.  */
  2880.       if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_REF)
  2881.         goto default_case;

  2883.       (*pos) += 4;
  2884.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  2885.         {
  2886.           struct type *type =
  2887.             lookup_pointer_type (SYMBOL_TYPE (var));
  2888.           enum address_class sym_class = SYMBOL_CLASS (var);

  2890.           if (sym_class == LOC_CONST
  2891.               || sym_class == LOC_CONST_BYTES
  2892.               || sym_class == LOC_REGISTER)
  2893.             error (_("Attempt to take address of register or constant."));

  2895.           return
  2896.             value_zero (type, not_lval);
  2897.         }
  2898.       else
  2899.         return address_of_variable (var, exp->elts[pc + 1].block);

  2901.     case OP_SCOPE:
  2902.       tem = longest_to_int (exp->elts[pc + 2].longconst);
  2903.       (*pos) += 5 + BYTES_TO_EXP_ELEM (tem + 1);
  2904.       x = value_aggregate_elt (exp->elts[pc + 1].type,
  2905.                                &exp->elts[pc + 3].string,
  2906.                                NULL, 1, noside);
  2907.       if (x == NULL)
  2908.         error (_("There is no field named %s"), &exp->elts[pc + 3].string);
  2909.       return x;

  2911.     default:
  2912.     default_case:
  2913.       x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  2914.     default_case_after_eval:
  2915.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  2916.         {
  2917.           struct type *type = check_typedef (value_type (x));

  2919.           if (TYPE_CODE (type) == TYPE_CODE_REF)
  2920.             return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
  2921.                                not_lval);
  2922.           else if (VALUE_LVAL (x) == lval_memory || value_must_coerce_to_target (x))
  2923.             return value_zero (lookup_pointer_type (value_type (x)),
  2924.                                not_lval);
  2925.           else
  2926.             error (_("Attempt to take address of "
  2927.                      "value not located in memory."));
  2928.         }
  2929.       return value_addr (x);
  2930.     }
  2931. }

  2933. /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
  2934.    When used in contexts where arrays will be coerced anyway, this is
  2935.    equivalent to `evaluate_subexp' but much faster because it avoids
  2936.    actually fetching array contents (perhaps obsolete now that we have
  2937.    value_lazy()).

  2939.    Note that we currently only do the coercion for C expressions, where
  2940.    arrays are zero based and the coercion is correct.  For other languages,
  2941.    with nonzero based arrays, coercion loses.  Use CAST_IS_CONVERSION
  2942.    to decide if coercion is appropriate.  */

  2944. struct value *
  2945. ‌evaluate_subexp_with_coercion (struct expression *exp,
  2946.                                int *pos, enum noside noside)
  2947. {
  2948.   enum exp_opcode op;
  2949.   int pc;
  2950.   struct value *val;
  2951.   struct symbol *var;
  2952.   struct type *type;

  2954.   pc = (*pos);
  2955.   op = exp->elts[pc].opcode;

  2957.   switch (op)
  2958.     {
  2959.     case OP_VAR_VALUE:
  2960.       var = exp->elts[pc + 2].symbol;
  2961.       type = check_typedef (SYMBOL_TYPE (var));
  2962.       if (TYPE_CODE (type) == TYPE_CODE_ARRAY
  2963.           && !TYPE_VECTOR (type)
  2964.           && CAST_IS_CONVERSION (exp->language_defn))
  2965.         {
  2966.           (*pos) += 4;
  2967.           val = address_of_variable (var, exp->elts[pc + 1].block);
  2968.           return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
  2969.                              val);
  2970.         }
  2971.       /* FALLTHROUGH */

  2973.     default:
  2974.       return evaluate_subexp (NULL_TYPE, exp, pos, noside);
  2975.     }
  2976. }

  2978. /* Evaluate a subexpression of EXP, at index *POS,
  2979.    and return a value for the size of that subexpression.
  2980.    Advance *POS over the subexpression.  If NOSIDE is EVAL_NORMAL
  2981.    we allow side-effects on the operand if its type is a variable
  2982.    length array.   */

  2984. static struct value *
  2985. ‌evaluate_subexp_for_sizeof (struct expression *exp, int *pos,
  2986.                             enum noside noside)
  2987. {
  2988.   /* FIXME: This should be size_t.  */
  2989.   struct type *size_type = builtin_type (exp->gdbarch)->builtin_int;
  2990.   enum exp_opcode op;
  2991.   int pc;
  2992.   struct type *type;
  2993.   struct value *val;

  2995.   pc = (*pos);
  2996.   op = exp->elts[pc].opcode;

  2998.   switch (op)
  2999.     {
  3000.       /* This case is handled specially
  3001.          so that we avoid creating a value for the result type.
  3002.          If the result type is very big, it's desirable not to
  3003.          create a value unnecessarily.  */
  3004.     case UNOP_IND:
  3005.       (*pos)++;
  3006.       val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
  3007.       type = check_typedef (value_type (val));
  3008.       if (TYPE_CODE (type) != TYPE_CODE_PTR
  3009.           && TYPE_CODE (type) != TYPE_CODE_REF
  3010.           && TYPE_CODE (type) != TYPE_CODE_ARRAY)
  3011.         error (_("Attempt to take contents of a non-pointer value."));
  3012.       type = TYPE_TARGET_TYPE (type);
  3013.       if (is_dynamic_type (type))
  3014.         type = value_type (value_ind (val));
  3015.       return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));

  3017.     case UNOP_MEMVAL:
  3018.       (*pos) += 3;
  3019.       type = exp->elts[pc + 1].type;
  3020.       break;

  3022.     case UNOP_MEMVAL_TYPE:
  3023.       (*pos) += 1;
  3024.       val = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
  3025.       type = value_type (val);
  3026.       break;

  3028.     case OP_VAR_VALUE:
  3029.       type = SYMBOL_TYPE (exp->elts[pc + 2].symbol);
  3030.       if (is_dynamic_type (type))
  3031.         {
  3032.           val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
  3033.           type = value_type (val);
  3034.         }
  3035.       else
  3036.         (*pos) += 4;
  3037.       break;

  3039.       /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
  3040.          type of the subscript is a variable length array type. In this case we
  3041.          must re-evaluate the right hand side of the subcription to allow
  3042.          side-effects. */
  3043.     case BINOP_SUBSCRIPT:
  3044.       if (noside == EVAL_NORMAL)
  3045.         {
  3046.           int pc = (*pos) + 1;

  3048.           val = evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
  3049.           type = check_typedef (value_type (val));
  3050.           if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
  3051.             {
  3052.               type = check_typedef (TYPE_TARGET_TYPE (type));
  3053.               if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
  3054.                 {
  3055.                   type = TYPE_INDEX_TYPE (type);
  3056.                   /* Only re-evaluate the right hand side if the resulting type
  3057.                      is a variable length type.  */
  3058.                   if (TYPE_RANGE_DATA (type)->flag_bound_evaluated)
  3059.                     {
  3060.                       val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
  3061.                       return value_from_longest
  3062.                         (size_type, (LONGEST) TYPE_LENGTH (value_type (val)));
  3063.                     }
  3064.                 }
  3065.             }
  3066.         }

  3068.       /* Fall through.  */

  3070.     default:
  3071.       val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
  3072.       type = value_type (val);
  3073.       break;
  3074.     }

  3076.   /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
  3077.      "When applied to a reference or a reference type, the result is
  3078.      the size of the referenced type."  */
  3079.   CHECK_TYPEDEF (type);
  3080.   if (exp->language_defn->la_language == language_cplus
  3081.       && TYPE_CODE (type) == TYPE_CODE_REF)
  3082.     type = check_typedef (TYPE_TARGET_TYPE (type));
  3083.   return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
  3084. }

  3086. /* Parse a type expression in the string [P..P+LENGTH).  */

  3088. struct type *
  3089. ‌parse_and_eval_type (char *p, int length)
  3090. {
  3091.   char *tmp = (char *) alloca (length + 4);
  3092.   struct expression *expr;

  3094.   tmp[0] = '(';
  3095.   memcpy (tmp + 1, p, length);
  3096.   tmp[length + 1] = ')';
  3097.   tmp[length + 2] = '0';
  3098.   tmp[length + 3] = '\0';
  3099.   expr = parse_expression (tmp);
  3100.   if (expr->elts[0].opcode != UNOP_CAST)
  3101.     error (_("Internal error in eval_type."));
  3102.   return expr->elts[1].type;
  3103. }

  3105. int
  3106. ‌calc_f77_array_dims (struct type *array_type)
  3107. {
  3108.   int ndimen = 1;
  3109.   struct type *tmp_type;

  3111.   if ((TYPE_CODE (array_type) != TYPE_CODE_ARRAY))
  3112.     error (_("Can't get dimensions for a non-array type"));

  3114.   tmp_type = array_type;

  3116.   while ((tmp_type = TYPE_TARGET_TYPE (tmp_type)))
  3117.     {
  3118.       if (TYPE_CODE (tmp_type) == TYPE_CODE_ARRAY)
  3119.         ++ndimen;
  3120.     }
  3121.   return ndimen;
  3122. }