gdb/valarith.c - gdb

Functions defined

Macros defined

Source code

  1. /* Perform arithmetic and other operations on values, 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 "value.h"
  22. #include "symtab.h"
  23. #include "gdbtypes.h"
  24. #include "expression.h"
  25. #include "target.h"
  26. #include "language.h"
  27. #include "doublest.h"
  28. #include "dfp.h"
  29. #include <math.h>
  30. #include "infcall.h"

  32. /* Define whether or not the C operator '/' truncates towards zero for
  33.    differently signed operands (truncation direction is undefined in C).  */

  35. #ifndef TRUNCATION_TOWARDS_ZERO
  36. ‌#define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
  37. #endif

  39. void _initialize_valarith (void);


  42. /* Given a pointer, return the size of its target.
  43.    If the pointer type is void *, then return 1.
  44.    If the target type is incomplete, then error out.
  45.    This isn't a general purpose function, but just a
  46.    helper for value_ptradd.  */

  48. static LONGEST
  49. ‌find_size_for_pointer_math (struct type *ptr_type)
  50. {
  51.   LONGEST sz = -1;
  52.   struct type *ptr_target;

  54.   gdb_assert (TYPE_CODE (ptr_type) == TYPE_CODE_PTR);
  55.   ptr_target = check_typedef (TYPE_TARGET_TYPE (ptr_type));

  57.   sz = TYPE_LENGTH (ptr_target);
  58.   if (sz == 0)
  59.     {
  60.       if (TYPE_CODE (ptr_type) == TYPE_CODE_VOID)
  61.         sz = 1;
  62.       else
  63.         {
  64.           const char *name;

  66.           name = TYPE_NAME (ptr_target);
  67.           if (name == NULL)
  68.             name = TYPE_TAG_NAME (ptr_target);
  69.           if (name == NULL)
  70.             error (_("Cannot perform pointer math on incomplete types, "
  71.                    "try casting to a known type, or void *."));
  72.           else
  73.             error (_("Cannot perform pointer math on incomplete type \"%s\", "
  74.                    "try casting to a known type, or void *."), name);
  75.         }
  76.     }
  77.   return sz;
  78. }

  80. /* Given a pointer ARG1 and an integral value ARG2, return the
  81.    result of C-style pointer arithmetic ARG1 + ARG2.  */

  83. struct value *
  84. ‌value_ptradd (struct value *arg1, LONGEST arg2)
  85. {
  86.   struct type *valptrtype;
  87.   LONGEST sz;
  88.   struct value *result;

  90.   arg1 = coerce_array (arg1);
  91.   valptrtype = check_typedef (value_type (arg1));
  92.   sz = find_size_for_pointer_math (valptrtype);

  94.   result = value_from_pointer (valptrtype,
  95.                                value_as_address (arg1) + sz * arg2);
  96.   if (VALUE_LVAL (result) != lval_internalvar)
  97.     set_value_component_location (result, arg1);
  98.   return result;
  99. }

  101. /* Given two compatible pointer values ARG1 and ARG2, return the
  102.    result of C-style pointer arithmetic ARG1 - ARG2.  */

  104. LONGEST
  105. ‌value_ptrdiff (struct value *arg1, struct value *arg2)
  106. {
  107.   struct type *type1, *type2;
  108.   LONGEST sz;

  110.   arg1 = coerce_array (arg1);
  111.   arg2 = coerce_array (arg2);
  112.   type1 = check_typedef (value_type (arg1));
  113.   type2 = check_typedef (value_type (arg2));

  115.   gdb_assert (TYPE_CODE (type1) == TYPE_CODE_PTR);
  116.   gdb_assert (TYPE_CODE (type2) == TYPE_CODE_PTR);

  118.   if (TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)))
  119.       != TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2))))
  120.     error (_("First argument of `-' is a pointer and "
  121.              "second argument is neither\n"
  122.              "an integer nor a pointer of the same type."));

  124.   sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
  125.   if (sz == 0)
  126.     {
  127.       warning (_("Type size unknown, assuming 1. "
  128.                "Try casting to a known type, or void *."));
  129.       sz = 1;
  130.     }

  132.   return (value_as_long (arg1) - value_as_long (arg2)) / sz;
  133. }

  135. /* Return the value of ARRAY[IDX].

  137.    ARRAY may be of type TYPE_CODE_ARRAY or TYPE_CODE_STRING.  If the
  138.    current language supports C-style arrays, it may also be TYPE_CODE_PTR.

  140.    See comments in value_coerce_array() for rationale for reason for
  141.    doing lower bounds adjustment here rather than there.
  142.    FIXME:  Perhaps we should validate that the index is valid and if
  143.    verbosity is set, warn about invalid indices (but still use them).  */

  145. struct value *
  146. ‌value_subscript (struct value *array, LONGEST index)
  147. {
  148.   int c_style = current_language->c_style_arrays;
  149.   struct type *tarray;

  151.   array = coerce_ref (array);
  152.   tarray = check_typedef (value_type (array));

  154.   if (TYPE_CODE (tarray) == TYPE_CODE_ARRAY
  155.       || TYPE_CODE (tarray) == TYPE_CODE_STRING)
  156.     {
  157.       struct type *range_type = TYPE_INDEX_TYPE (tarray);
  158.       LONGEST lowerbound, upperbound;

  160.       get_discrete_bounds (range_type, &lowerbound, &upperbound);
  161.       if (VALUE_LVAL (array) != lval_memory)
  162.         return value_subscripted_rvalue (array, index, lowerbound);

  164.       if (c_style == 0)
  165.         {
  166.           if (index >= lowerbound && index <= upperbound)
  167.             return value_subscripted_rvalue (array, index, lowerbound);
  168.           /* Emit warning unless we have an array of unknown size.
  169.              An array of unknown size has lowerbound 0 and upperbound -1.  */
  170.           if (upperbound > -1)
  171.             warning (_("array or string index out of range"));
  172.           /* fall doing C stuff */
  173.           c_style = 1;
  174.         }

  176.       index -= lowerbound;
  177.       array = value_coerce_array (array);
  178.     }

  180.   if (c_style)
  181.     return value_ind (value_ptradd (array, index));
  182.   else
  183.     error (_("not an array or string"));
  184. }

  186. /* Return the value of EXPR[IDX], expr an aggregate rvalue
  187.    (eg, a vector register).  This routine used to promote floats
  188.    to doubles, but no longer does.  */

  190. struct value *
  191. ‌value_subscripted_rvalue (struct value *array, LONGEST index, int lowerbound)
  192. {
  193.   struct type *array_type = check_typedef (value_type (array));
  194.   struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (array_type));
  195.   unsigned int elt_size = TYPE_LENGTH (elt_type);
  196.   unsigned int elt_offs = elt_size * longest_to_int (index - lowerbound);
  197.   struct value *v;

  199.   if (index < lowerbound || (!TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (array_type)
  200.                              && elt_offs >= TYPE_LENGTH (array_type)))
  201.     error (_("no such vector element"));

  203.   if (VALUE_LVAL (array) == lval_memory && value_lazy (array))
  204.     v = allocate_value_lazy (elt_type);
  205.   else
  206.     {
  207.       v = allocate_value (elt_type);
  208.       value_contents_copy (v, value_embedded_offset (v),
  209.                            array, value_embedded_offset (array) + elt_offs,
  210.                            elt_size);
  211.     }

  213.   set_value_component_location (v, array);
  214.   VALUE_REGNUM (v) = VALUE_REGNUM (array);
  215.   VALUE_FRAME_ID (v) = VALUE_FRAME_ID (array);
  216.   set_value_offset (v, value_offset (array) + elt_offs);
  217.   return v;
  218. }


  221. /* Check to see if either argument is a structure, or a reference to
  222.    one.  This is called so we know whether to go ahead with the normal
  223.    binop or look for a user defined function instead.

  225.    For now, we do not overload the `=' operator.  */

  227. int
  228. ‌binop_types_user_defined_p (enum exp_opcode op,
  229.                             struct type *type1, struct type *type2)
  230. {
  231.   if (op == BINOP_ASSIGN || op == BINOP_CONCAT)
  232.     return 0;

  234.   type1 = check_typedef (type1);
  235.   if (TYPE_CODE (type1) == TYPE_CODE_REF)
  236.     type1 = check_typedef (TYPE_TARGET_TYPE (type1));

  238.   type2 = check_typedef (type2);
  239.   if (TYPE_CODE (type2) == TYPE_CODE_REF)
  240.     type2 = check_typedef (TYPE_TARGET_TYPE (type2));

  242.   return (TYPE_CODE (type1) == TYPE_CODE_STRUCT
  243.           || TYPE_CODE (type2) == TYPE_CODE_STRUCT);
  244. }

  246. /* Check to see if either argument is a structure, or a reference to
  247.    one.  This is called so we know whether to go ahead with the normal
  248.    binop or look for a user defined function instead.

  250.    For now, we do not overload the `=' operator.  */

  252. int
  253. ‌binop_user_defined_p (enum exp_opcode op,
  254.                       struct value *arg1, struct value *arg2)
  255. {
  256.   return binop_types_user_defined_p (op, value_type (arg1), value_type (arg2));
  257. }

  259. /* Check to see if argument is a structure.  This is called so
  260.    we know whether to go ahead with the normal unop or look for a
  261.    user defined function instead.

  263.    For now, we do not overload the `&' operator.  */

  265. int
  266. ‌unop_user_defined_p (enum exp_opcode op, struct value *arg1)
  267. {
  268.   struct type *type1;

  270.   if (op == UNOP_ADDR)
  271.     return 0;
  272.   type1 = check_typedef (value_type (arg1));
  273.   if (TYPE_CODE (type1) == TYPE_CODE_REF)
  274.     type1 = check_typedef (TYPE_TARGET_TYPE (type1));
  275.   return TYPE_CODE (type1) == TYPE_CODE_STRUCT;
  276. }

  278. /* Try to find an operator named OPERATOR which takes NARGS arguments
  279.    specified in ARGS.  If the operator found is a static member operator
  280.    *STATIC_MEMFUNP will be set to 1, and otherwise 0.
  281.    The search if performed through find_overload_match which will handle
  282.    member operators, non member operators, operators imported implicitly or
  283.    explicitly, and perform correct overload resolution in all of the above
  284.    situations or combinations thereof.  */

  286. static struct value *
  287. ‌value_user_defined_cpp_op (struct value **args, int nargs, char *operator,
  288.                            int *static_memfuncp, enum noside noside)
  289. {

  291.   struct symbol *symp = NULL;
  292.   struct value *valp = NULL;

  294.   find_overload_match (args, nargs, operator, BOTH /* could be method */,
  295.                        &args[0] /* objp */,
  296.                        NULL /* pass NULL symbol since symbol is unknown */,
  297.                        &valp, &symp, static_memfuncp, 0, noside);

  299.   if (valp)
  300.     return valp;

  302.   if (symp)
  303.     {
  304.       /* This is a non member function and does not
  305.          expect a reference as its first argument
  306.          rather the explicit structure.  */
  307.       args[0] = value_ind (args[0]);
  308.       return value_of_variable (symp, 0);
  309.     }

  311.   error (_("Could not find %s."), operator);
  312. }

  314. /* Lookup user defined operator NAME.  Return a value representing the
  315.    function, otherwise return NULL.  */

  317. static struct value *
  318. ‌value_user_defined_op (struct value **argp, struct value **args, char *name,
  319.                        int *static_memfuncp, int nargs, enum noside noside)
  320. {
  321.   struct value *result = NULL;

  323.   if (current_language->la_language == language_cplus)
  324.     {
  325.       result = value_user_defined_cpp_op (args, nargs, name, static_memfuncp,
  326.                                           noside);
  327.     }
  328.   else
  329.     result = value_struct_elt (argp, args, name, static_memfuncp,
  330.                                "structure");

  332.   return result;
  333. }

  335. /* We know either arg1 or arg2 is a structure, so try to find the right
  336.    user defined function.  Create an argument vector that calls
  337.    arg1.operator @ (arg1,arg2) and return that value (where '@' is any
  338.    binary operator which is legal for GNU C++).

  340.    OP is the operatore, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP
  341.    is the opcode saying how to modify it.  Otherwise, OTHEROP is
  342.    unused.  */

  344. struct value *
  345. ‌value_x_binop (struct value *arg1, struct value *arg2, enum exp_opcode op,
  346.                enum exp_opcode otherop, enum noside noside)
  347. {
  348.   struct value **argvec;
  349.   char *ptr;
  350.   char tstr[13];
  351.   int static_memfuncp;

  353.   arg1 = coerce_ref (arg1);
  354.   arg2 = coerce_ref (arg2);

  356.   /* now we know that what we have to do is construct our
  357.      arg vector and find the right function to call it with.  */

  359.   if (TYPE_CODE (check_typedef (value_type (arg1))) != TYPE_CODE_STRUCT)
  360.     error (_("Can't do that binary op on that type"));        /* FIXME be explicit */

  362.   argvec = (struct value **) alloca (sizeof (struct value *) * 4);
  363.   argvec[1] = value_addr (arg1);
  364.   argvec[2] = arg2;
  365.   argvec[3] = 0;

  367.   /* Make the right function name up.  */
  368.   strcpy (tstr, "operator__");
  369.   ptr = tstr + 8;
  370.   switch (op)
  371.     {
  372.     case BINOP_ADD:
  373.       strcpy (ptr, "+");
  374.       break;
  375.     case BINOP_SUB:
  376.       strcpy (ptr, "-");
  377.       break;
  378.     case BINOP_MUL:
  379.       strcpy (ptr, "*");
  380.       break;
  381.     case BINOP_DIV:
  382.       strcpy (ptr, "/");
  383.       break;
  384.     case BINOP_REM:
  385.       strcpy (ptr, "%");
  386.       break;
  387.     case BINOP_LSH:
  388.       strcpy (ptr, "<<");
  389.       break;
  390.     case BINOP_RSH:
  391.       strcpy (ptr, ">>");
  392.       break;
  393.     case BINOP_BITWISE_AND:
  394.       strcpy (ptr, "&");
  395.       break;
  396.     case BINOP_BITWISE_IOR:
  397.       strcpy (ptr, "|");
  398.       break;
  399.     case BINOP_BITWISE_XOR:
  400.       strcpy (ptr, "^");
  401.       break;
  402.     case BINOP_LOGICAL_AND:
  403.       strcpy (ptr, "&&");
  404.       break;
  405.     case BINOP_LOGICAL_OR:
  406.       strcpy (ptr, "||");
  407.       break;
  408.     case BINOP_MIN:
  409.       strcpy (ptr, "<?");
  410.       break;
  411.     case BINOP_MAX:
  412.       strcpy (ptr, ">?");
  413.       break;
  414.     case BINOP_ASSIGN:
  415.       strcpy (ptr, "=");
  416.       break;
  417.     case BINOP_ASSIGN_MODIFY:
  418.       switch (otherop)
  419.         {
  420.         case BINOP_ADD:
  421.           strcpy (ptr, "+=");
  422.           break;
  423.         case BINOP_SUB:
  424.           strcpy (ptr, "-=");
  425.           break;
  426.         case BINOP_MUL:
  427.           strcpy (ptr, "*=");
  428.           break;
  429.         case BINOP_DIV:
  430.           strcpy (ptr, "/=");
  431.           break;
  432.         case BINOP_REM:
  433.           strcpy (ptr, "%=");
  434.           break;
  435.         case BINOP_BITWISE_AND:
  436.           strcpy (ptr, "&=");
  437.           break;
  438.         case BINOP_BITWISE_IOR:
  439.           strcpy (ptr, "|=");
  440.           break;
  441.         case BINOP_BITWISE_XOR:
  442.           strcpy (ptr, "^=");
  443.           break;
  444.         case BINOP_MOD:        /* invalid */
  445.         default:
  446.           error (_("Invalid binary operation specified."));
  447.         }
  448.       break;
  449.     case BINOP_SUBSCRIPT:
  450.       strcpy (ptr, "[]");
  451.       break;
  452.     case BINOP_EQUAL:
  453.       strcpy (ptr, "==");
  454.       break;
  455.     case BINOP_NOTEQUAL:
  456.       strcpy (ptr, "!=");
  457.       break;
  458.     case BINOP_LESS:
  459.       strcpy (ptr, "<");
  460.       break;
  461.     case BINOP_GTR:
  462.       strcpy (ptr, ">");
  463.       break;
  464.     case BINOP_GEQ:
  465.       strcpy (ptr, ">=");
  466.       break;
  467.     case BINOP_LEQ:
  468.       strcpy (ptr, "<=");
  469.       break;
  470.     case BINOP_MOD:                /* invalid */
  471.     default:
  472.       error (_("Invalid binary operation specified."));
  473.     }

  475.   argvec[0] = value_user_defined_op (&arg1, argvec + 1, tstr,
  476.                                      &static_memfuncp, 2, noside);

  478.   if (argvec[0])
  479.     {
  480.       if (static_memfuncp)
  481.         {
  482.           argvec[1] = argvec[0];
  483.           argvec++;
  484.         }
  485.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  486.         {
  487.           struct type *return_type;

  489.           return_type
  490.             = TYPE_TARGET_TYPE (check_typedef (value_type (argvec[0])));
  491.           return value_zero (return_type, VALUE_LVAL (arg1));
  492.         }

  494.       if (TYPE_CODE (value_type (argvec[0])) == TYPE_CODE_XMETHOD)
  495.         {
  496.           /* Static xmethods are not supported yet.  */
  497.           gdb_assert (static_memfuncp == 0);
  498.           return call_xmethod (argvec[0], 2, argvec + 1);
  499.         }
  500.       else
  501.         return call_function_by_hand (argvec[0], 2 - static_memfuncp,
  502.                                       argvec + 1);
  503.     }
  504.   throw_error (NOT_FOUND_ERROR,
  505.                _("member function %s not found"), tstr);
  506. #ifdef lint
  507.   return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1);
  508. #endif
  509. }

  511. /* We know that arg1 is a structure, so try to find a unary user
  512.    defined operator that matches the operator in question.
  513.    Create an argument vector that calls arg1.operator @ (arg1)
  514.    and return that value (where '@' is (almost) any unary operator which
  515.    is legal for GNU C++).  */

  517. struct value *
  518. ‌value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside)
  519. {
  520.   struct gdbarch *gdbarch = get_type_arch (value_type (arg1));
  521.   struct value **argvec;
  522.   char *ptr;
  523.   char tstr[13], mangle_tstr[13];
  524.   int static_memfuncp, nargs;

  526.   arg1 = coerce_ref (arg1);

  528.   /* now we know that what we have to do is construct our
  529.      arg vector and find the right function to call it with.  */

  531.   if (TYPE_CODE (check_typedef (value_type (arg1))) != TYPE_CODE_STRUCT)
  532.     error (_("Can't do that unary op on that type"));        /* FIXME be explicit */

  534.   argvec = (struct value **) alloca (sizeof (struct value *) * 4);
  535.   argvec[1] = value_addr (arg1);
  536.   argvec[2] = 0;

  538.   nargs = 1;

  540.   /* Make the right function name up.  */
  541.   strcpy (tstr, "operator__");
  542.   ptr = tstr + 8;
  543.   strcpy (mangle_tstr, "__");
  544.   switch (op)
  545.     {
  546.     case UNOP_PREINCREMENT:
  547.       strcpy (ptr, "++");
  548.       break;
  549.     case UNOP_PREDECREMENT:
  550.       strcpy (ptr, "--");
  551.       break;
  552.     case UNOP_POSTINCREMENT:
  553.       strcpy (ptr, "++");
  554.       argvec[2] = value_from_longest (builtin_type (gdbarch)->builtin_int, 0);
  555.       argvec[3] = 0;
  556.       nargs ++;
  557.       break;
  558.     case UNOP_POSTDECREMENT:
  559.       strcpy (ptr, "--");
  560.       argvec[2] = value_from_longest (builtin_type (gdbarch)->builtin_int, 0);
  561.       argvec[3] = 0;
  562.       nargs ++;
  563.       break;
  564.     case UNOP_LOGICAL_NOT:
  565.       strcpy (ptr, "!");
  566.       break;
  567.     case UNOP_COMPLEMENT:
  568.       strcpy (ptr, "~");
  569.       break;
  570.     case UNOP_NEG:
  571.       strcpy (ptr, "-");
  572.       break;
  573.     case UNOP_PLUS:
  574.       strcpy (ptr, "+");
  575.       break;
  576.     case UNOP_IND:
  577.       strcpy (ptr, "*");
  578.       break;
  579.     case STRUCTOP_PTR:
  580.       strcpy (ptr, "->");
  581.       break;
  582.     default:
  583.       error (_("Invalid unary operation specified."));
  584.     }

  586.   argvec[0] = value_user_defined_op (&arg1, argvec + 1, tstr,
  587.                                      &static_memfuncp, nargs, noside);

  589.   if (argvec[0])
  590.     {
  591.       if (static_memfuncp)
  592.         {
  593.           argvec[1] = argvec[0];
  594.           nargs --;
  595.           argvec++;
  596.         }
  597.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  598.         {
  599.           struct type *return_type;

  601.           return_type
  602.             = TYPE_TARGET_TYPE (check_typedef (value_type (argvec[0])));
  603.           return value_zero (return_type, VALUE_LVAL (arg1));
  604.         }
  605.       if (TYPE_CODE (value_type (argvec[0])) == TYPE_CODE_XMETHOD)
  606.         {
  607.           /* Static xmethods are not supported yet.  */
  608.           gdb_assert (static_memfuncp == 0);
  609.           return call_xmethod (argvec[0], 1, argvec + 1);
  610.         }
  611.       else
  612.         return call_function_by_hand (argvec[0], nargs, argvec + 1);
  613.     }
  614.   throw_error (NOT_FOUND_ERROR,
  615.                _("member function %s not found"), tstr);

  617.   return 0;                        /* For lint -- never reached */
  618. }


  621. /* Concatenate two values with the following conditions:

  623.    (1)  Both values must be either bitstring values or character string
  624.    values and the resulting value consists of the concatenation of
  625.    ARG1 followed by ARG2.

  627.    or

  629.    One value must be an integer value and the other value must be
  630.    either a bitstring value or character string value, which is
  631.    to be repeated by the number of times specified by the integer
  632.    value.


  635.    (2)  Boolean values are also allowed and are treated as bit string
  636.    values of length 1.

  638.    (3)  Character values are also allowed and are treated as character
  639.    string values of length 1.  */

  641. struct value *
  642. ‌value_concat (struct value *arg1, struct value *arg2)
  643. {
  644.   struct value *inval1;
  645.   struct value *inval2;
  646.   struct value *outval = NULL;
  647.   int inval1len, inval2len;
  648.   int count, idx;
  649.   char *ptr;
  650.   char inchar;
  651.   struct type *type1 = check_typedef (value_type (arg1));
  652.   struct type *type2 = check_typedef (value_type (arg2));
  653.   struct type *char_type;

  655.   /* First figure out if we are dealing with two values to be concatenated
  656.      or a repeat count and a value to be repeated.  INVAL1 is set to the
  657.      first of two concatenated values, or the repeat count.  INVAL2 is set
  658.      to the second of the two concatenated values or the value to be
  659.      repeated.  */

  661.   if (TYPE_CODE (type2) == TYPE_CODE_INT)
  662.     {
  663.       struct type *tmp = type1;

  665.       type1 = tmp;
  666.       tmp = type2;
  667.       inval1 = arg2;
  668.       inval2 = arg1;
  669.     }
  670.   else
  671.     {
  672.       inval1 = arg1;
  673.       inval2 = arg2;
  674.     }

  676.   /* Now process the input values.  */

  678.   if (TYPE_CODE (type1) == TYPE_CODE_INT)
  679.     {
  680.       /* We have a repeat count.  Validate the second value and then
  681.          construct a value repeated that many times.  */
  682.       if (TYPE_CODE (type2) == TYPE_CODE_STRING
  683.           || TYPE_CODE (type2) == TYPE_CODE_CHAR)
  684.         {
  685.           struct cleanup *back_to;

  687.           count = longest_to_int (value_as_long (inval1));
  688.           inval2len = TYPE_LENGTH (type2);
  689.           ptr = (char *) xmalloc (count * inval2len);
  690.           back_to = make_cleanup (xfree, ptr);
  691.           if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
  692.             {
  693.               char_type = type2;

  695.               inchar = (char) unpack_long (type2,
  696.                                            value_contents (inval2));
  697.               for (idx = 0; idx < count; idx++)
  698.                 {
  699.                   *(ptr + idx) = inchar;
  700.                 }
  701.             }
  702.           else
  703.             {
  704.               char_type = TYPE_TARGET_TYPE (type2);

  706.               for (idx = 0; idx < count; idx++)
  707.                 {
  708.                   memcpy (ptr + (idx * inval2len), value_contents (inval2),
  709.                           inval2len);
  710.                 }
  711.             }
  712.           outval = value_string (ptr, count * inval2len, char_type);
  713.           do_cleanups (back_to);
  714.         }
  715.       else if (TYPE_CODE (type2) == TYPE_CODE_BOOL)
  716.         {
  717.           error (_("unimplemented support for boolean repeats"));
  718.         }
  719.       else
  720.         {
  721.           error (_("can't repeat values of that type"));
  722.         }
  723.     }
  724.   else if (TYPE_CODE (type1) == TYPE_CODE_STRING
  725.            || TYPE_CODE (type1) == TYPE_CODE_CHAR)
  726.     {
  727.       struct cleanup *back_to;

  729.       /* We have two character strings to concatenate.  */
  730.       if (TYPE_CODE (type2) != TYPE_CODE_STRING
  731.           && TYPE_CODE (type2) != TYPE_CODE_CHAR)
  732.         {
  733.           error (_("Strings can only be concatenated with other strings."));
  734.         }
  735.       inval1len = TYPE_LENGTH (type1);
  736.       inval2len = TYPE_LENGTH (type2);
  737.       ptr = (char *) xmalloc (inval1len + inval2len);
  738.       back_to = make_cleanup (xfree, ptr);
  739.       if (TYPE_CODE (type1) == TYPE_CODE_CHAR)
  740.         {
  741.           char_type = type1;

  743.           *ptr = (char) unpack_long (type1, value_contents (inval1));
  744.         }
  745.       else
  746.         {
  747.           char_type = TYPE_TARGET_TYPE (type1);

  749.           memcpy (ptr, value_contents (inval1), inval1len);
  750.         }
  751.       if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
  752.         {
  753.           *(ptr + inval1len) =
  754.             (char) unpack_long (type2, value_contents (inval2));
  755.         }
  756.       else
  757.         {
  758.           memcpy (ptr + inval1len, value_contents (inval2), inval2len);
  759.         }
  760.       outval = value_string (ptr, inval1len + inval2len, char_type);
  761.       do_cleanups (back_to);
  762.     }
  763.   else if (TYPE_CODE (type1) == TYPE_CODE_BOOL)
  764.     {
  765.       /* We have two bitstrings to concatenate.  */
  766.       if (TYPE_CODE (type2) != TYPE_CODE_BOOL)
  767.         {
  768.           error (_("Booleans can only be concatenated "
  769.                    "with other bitstrings or booleans."));
  770.         }
  771.       error (_("unimplemented support for boolean concatenation."));
  772.     }
  773.   else
  774.     {
  775.       /* We don't know how to concatenate these operands.  */
  776.       error (_("illegal operands for concatenation."));
  777.     }
  778.   return (outval);
  779. }

  781. /* Integer exponentiation: V1**V2, where both arguments are
  782.    integers.  Requires V1 != 0 if V2 < 0.  Returns 1 for 0 ** 0.  */

  784. static LONGEST
  785. ‌integer_pow (LONGEST v1, LONGEST v2)
  786. {
  787.   if (v2 < 0)
  788.     {
  789.       if (v1 == 0)
  790.         error (_("Attempt to raise 0 to negative power."));
  791.       else
  792.         return 0;
  793.     }
  794.   else
  795.     {
  796.       /* The Russian Peasant's Algorithm.  */
  797.       LONGEST v;

  799.       v = 1;
  800.       for (;;)
  801.         {
  802.           if (v2 & 1L)
  803.             v *= v1;
  804.           v2 >>= 1;
  805.           if (v2 == 0)
  806.             return v;
  807.           v1 *= v1;
  808.         }
  809.     }
  810. }

  812. /* Integer exponentiation: V1**V2, where both arguments are
  813.    integers.  Requires V1 != 0 if V2 < 0.  Returns 1 for 0 ** 0.  */

  815. static ULONGEST
  816. ‌uinteger_pow (ULONGEST v1, LONGEST v2)
  817. {
  818.   if (v2 < 0)
  819.     {
  820.       if (v1 == 0)
  821.         error (_("Attempt to raise 0 to negative power."));
  822.       else
  823.         return 0;
  824.     }
  825.   else
  826.     {
  827.       /* The Russian Peasant's Algorithm.  */
  828.       ULONGEST v;

  830.       v = 1;
  831.       for (;;)
  832.         {
  833.           if (v2 & 1L)
  834.             v *= v1;
  835.           v2 >>= 1;
  836.           if (v2 == 0)
  837.             return v;
  838.           v1 *= v1;
  839.         }
  840.     }
  841. }

  843. /* Obtain decimal value of arguments for binary operation, converting from
  844.    other types if one of them is not decimal floating point.  */
  845. static void
  846. ‌value_args_as_decimal (struct value *arg1, struct value *arg2,
  847.                        gdb_byte *x, int *len_x, enum bfd_endian *byte_order_x,
  848.                        gdb_byte *y, int *len_y, enum bfd_endian *byte_order_y)
  849. {
  850.   struct type *type1, *type2;

  852.   type1 = check_typedef (value_type (arg1));
  853.   type2 = check_typedef (value_type (arg2));

  855.   /* At least one of the arguments must be of decimal float type.  */
  856.   gdb_assert (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
  857.               || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT);

  859.   if (TYPE_CODE (type1) == TYPE_CODE_FLT
  860.       || TYPE_CODE (type2) == TYPE_CODE_FLT)
  861.     /* The DFP extension to the C language does not allow mixing of
  862.      * decimal float types with other float types in expressions
  863.      * (see WDTR 24732, page 12).  */
  864.     error (_("Mixing decimal floating types with "
  865.              "other floating types is not allowed."));

  867.   /* Obtain decimal value of arg1, converting from other types
  868.      if necessary.  */

  870.   if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT)
  871.     {
  872.       *byte_order_x = gdbarch_byte_order (get_type_arch (type1));
  873.       *len_x = TYPE_LENGTH (type1);
  874.       memcpy (x, value_contents (arg1), *len_x);
  875.     }
  876.   else if (is_integral_type (type1))
  877.     {
  878.       *byte_order_x = gdbarch_byte_order (get_type_arch (type2));
  879.       *len_x = TYPE_LENGTH (type2);
  880.       decimal_from_integral (arg1, x, *len_x, *byte_order_x);
  881.     }
  882.   else
  883.     error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1),
  884.              TYPE_NAME (type2));

  886.   /* Obtain decimal value of arg2, converting from other types
  887.      if necessary.  */

  889.   if (TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
  890.     {
  891.       *byte_order_y = gdbarch_byte_order (get_type_arch (type2));
  892.       *len_y = TYPE_LENGTH (type2);
  893.       memcpy (y, value_contents (arg2), *len_y);
  894.     }
  895.   else if (is_integral_type (type2))
  896.     {
  897.       *byte_order_y = gdbarch_byte_order (get_type_arch (type1));
  898.       *len_y = TYPE_LENGTH (type1);
  899.       decimal_from_integral (arg2, y, *len_y, *byte_order_y);
  900.     }
  901.   else
  902.     error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1),
  903.              TYPE_NAME (type2));
  904. }

  906. /* Perform a binary operation on two operands which have reasonable
  907.    representations as integers or floats.  This includes booleans,
  908.    characters, integers, or floats.
  909.    Does not support addition and subtraction on pointers;
  910.    use value_ptradd, value_ptrsub or value_ptrdiff for those operations.  */

  912. static struct value *
  913. ‌scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
  914. {
  915.   struct value *val;
  916.   struct type *type1, *type2, *result_type;

  918.   arg1 = coerce_ref (arg1);
  919.   arg2 = coerce_ref (arg2);

  921.   type1 = check_typedef (value_type (arg1));
  922.   type2 = check_typedef (value_type (arg2));

  924.   if ((TYPE_CODE (type1) != TYPE_CODE_FLT
  925.        && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT
  926.        && !is_integral_type (type1))
  927.       || (TYPE_CODE (type2) != TYPE_CODE_FLT
  928.           && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT
  929.           && !is_integral_type (type2)))
  930.     error (_("Argument to arithmetic operation not a number or boolean."));

  932.   if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
  933.       || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
  934.     {
  935.       int len_v1, len_v2, len_v;
  936.       enum bfd_endian byte_order_v1, byte_order_v2, byte_order_v;
  937.       gdb_byte v1[16], v2[16];
  938.       gdb_byte v[16];

  940.       /* If only one type is decimal float, use its type.
  941.          Otherwise use the bigger type.  */
  942.       if (TYPE_CODE (type1) != TYPE_CODE_DECFLOAT)
  943.         result_type = type2;
  944.       else if (TYPE_CODE (type2) != TYPE_CODE_DECFLOAT)
  945.         result_type = type1;
  946.       else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
  947.         result_type = type2;
  948.       else
  949.         result_type = type1;

  951.       len_v = TYPE_LENGTH (result_type);
  952.       byte_order_v = gdbarch_byte_order (get_type_arch (result_type));

  954.       value_args_as_decimal (arg1, arg2, v1, &len_v1, &byte_order_v1,
  955.                                          v2, &len_v2, &byte_order_v2);

  957.       switch (op)
  958.         {
  959.         case BINOP_ADD:
  960.         case BINOP_SUB:
  961.         case BINOP_MUL:
  962.         case BINOP_DIV:
  963.         case BINOP_EXP:
  964.           decimal_binop (op, v1, len_v1, byte_order_v1,
  965.                              v2, len_v2, byte_order_v2,
  966.                              v, len_v, byte_order_v);
  967.           break;

  969.         default:
  970.           error (_("Operation not valid for decimal floating point number."));
  971.         }

  973.       val = value_from_decfloat (result_type, v);
  974.     }
  975.   else if (TYPE_CODE (type1) == TYPE_CODE_FLT
  976.            || TYPE_CODE (type2) == TYPE_CODE_FLT)
  977.     {
  978.       /* FIXME-if-picky-about-floating-accuracy: Should be doing this
  979.          in target format.  real.c in GCC probably has the necessary
  980.          code.  */
  981.       DOUBLEST v1, v2, v = 0;

  983.       v1 = value_as_double (arg1);
  984.       v2 = value_as_double (arg2);

  986.       switch (op)
  987.         {
  988.         case BINOP_ADD:
  989.           v = v1 + v2;
  990.           break;

  992.         case BINOP_SUB:
  993.           v = v1 - v2;
  994.           break;

  996.         case BINOP_MUL:
  997.           v = v1 * v2;
  998.           break;

  1000.         case BINOP_DIV:
  1001.           v = v1 / v2;
  1002.           break;

  1004.         case BINOP_EXP:
  1005.           errno = 0;
  1006.           v = pow (v1, v2);
  1007.           if (errno)
  1008.             error (_("Cannot perform exponentiation: %s"),
  1009.                    safe_strerror (errno));
  1010.           break;

  1012.         case BINOP_MIN:
  1013.           v = v1 < v2 ? v1 : v2;
  1014.           break;

  1016.         case BINOP_MAX:
  1017.           v = v1 > v2 ? v1 : v2;
  1018.           break;

  1020.         default:
  1021.           error (_("Integer-only operation on floating point number."));
  1022.         }

  1024.       /* If only one type is float, use its type.
  1025.          Otherwise use the bigger type.  */
  1026.       if (TYPE_CODE (type1) != TYPE_CODE_FLT)
  1027.         result_type = type2;
  1028.       else if (TYPE_CODE (type2) != TYPE_CODE_FLT)
  1029.         result_type = type1;
  1030.       else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
  1031.         result_type = type2;
  1032.       else
  1033.         result_type = type1;

  1035.       val = allocate_value (result_type);
  1036.       store_typed_floating (value_contents_raw (val), value_type (val), v);
  1037.     }
  1038.   else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
  1039.            || TYPE_CODE (type2) == TYPE_CODE_BOOL)
  1040.     {
  1041.       LONGEST v1, v2, v = 0;

  1043.       v1 = value_as_long (arg1);
  1044.       v2 = value_as_long (arg2);

  1046.       switch (op)
  1047.         {
  1048.         case BINOP_BITWISE_AND:
  1049.           v = v1 & v2;
  1050.           break;

  1052.         case BINOP_BITWISE_IOR:
  1053.           v = v1 | v2;
  1054.           break;

  1056.         case BINOP_BITWISE_XOR:
  1057.           v = v1 ^ v2;
  1058.           break;

  1060.         case BINOP_EQUAL:
  1061.           v = v1 == v2;
  1062.           break;

  1064.         case BINOP_NOTEQUAL:
  1065.           v = v1 != v2;
  1066.           break;

  1068.         default:
  1069.           error (_("Invalid operation on booleans."));
  1070.         }

  1072.       result_type = type1;

  1074.       val = allocate_value (result_type);
  1075.       store_signed_integer (value_contents_raw (val),
  1076.                             TYPE_LENGTH (result_type),
  1077.                             gdbarch_byte_order (get_type_arch (result_type)),
  1078.                             v);
  1079.     }
  1080.   else
  1081.     /* Integral operations here.  */
  1082.     {
  1083.       /* Determine type length of the result, and if the operation should
  1084.          be done unsigned.  For exponentiation and shift operators,
  1085.          use the length and type of the left operand.  Otherwise,
  1086.          use the signedness of the operand with the greater length.
  1087.          If both operands are of equal length, use unsigned operation
  1088.          if one of the operands is unsigned.  */
  1089.       if (op == BINOP_RSH || op == BINOP_LSH || op == BINOP_EXP)
  1090.         result_type = type1;
  1091.       else if (TYPE_LENGTH (type1) > TYPE_LENGTH (type2))
  1092.         result_type = type1;
  1093.       else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
  1094.         result_type = type2;
  1095.       else if (TYPE_UNSIGNED (type1))
  1096.         result_type = type1;
  1097.       else if (TYPE_UNSIGNED (type2))
  1098.         result_type = type2;
  1099.       else
  1100.         result_type = type1;

  1102.       if (TYPE_UNSIGNED (result_type))
  1103.         {
  1104.           LONGEST v2_signed = value_as_long (arg2);
  1105.           ULONGEST v1, v2, v = 0;

  1107.           v1 = (ULONGEST) value_as_long (arg1);
  1108.           v2 = (ULONGEST) v2_signed;

  1110.           switch (op)
  1111.             {
  1112.             case BINOP_ADD:
  1113.               v = v1 + v2;
  1114.               break;

  1116.             case BINOP_SUB:
  1117.               v = v1 - v2;
  1118.               break;

  1120.             case BINOP_MUL:
  1121.               v = v1 * v2;
  1122.               break;

  1124.             case BINOP_DIV:
  1125.             case BINOP_INTDIV:
  1126.               if (v2 != 0)
  1127.                 v = v1 / v2;
  1128.               else
  1129.                 error (_("Division by zero"));
  1130.               break;

  1132.             case BINOP_EXP:
  1133.               v = uinteger_pow (v1, v2_signed);
  1134.               break;

  1136.             case BINOP_REM:
  1137.               if (v2 != 0)
  1138.                 v = v1 % v2;
  1139.               else
  1140.                 error (_("Division by zero"));
  1141.               break;

  1143.             case BINOP_MOD:
  1144.               /* Knuth 1.2.4, integer only.  Note that unlike the C '%' op,
  1145.                  v1 mod 0 has a defined value, v1.  */
  1146.               if (v2 == 0)
  1147.                 {
  1148.                   v = v1;
  1149.                 }
  1150.               else
  1151.                 {
  1152.                   v = v1 / v2;
  1153.                   /* Note floor(v1/v2) == v1/v2 for unsigned.  */
  1154.                   v = v1 - (v2 * v);
  1155.                 }
  1156.               break;

  1158.             case BINOP_LSH:
  1159.               v = v1 << v2;
  1160.               break;

  1162.             case BINOP_RSH:
  1163.               v = v1 >> v2;
  1164.               break;

  1166.             case BINOP_BITWISE_AND:
  1167.               v = v1 & v2;
  1168.               break;

  1170.             case BINOP_BITWISE_IOR:
  1171.               v = v1 | v2;
  1172.               break;

  1174.             case BINOP_BITWISE_XOR:
  1175.               v = v1 ^ v2;
  1176.               break;

  1178.             case BINOP_LOGICAL_AND:
  1179.               v = v1 && v2;
  1180.               break;

  1182.             case BINOP_LOGICAL_OR:
  1183.               v = v1 || v2;
  1184.               break;

  1186.             case BINOP_MIN:
  1187.               v = v1 < v2 ? v1 : v2;
  1188.               break;

  1190.             case BINOP_MAX:
  1191.               v = v1 > v2 ? v1 : v2;
  1192.               break;

  1194.             case BINOP_EQUAL:
  1195.               v = v1 == v2;
  1196.               break;

  1198.             case BINOP_NOTEQUAL:
  1199.               v = v1 != v2;
  1200.               break;

  1202.             case BINOP_LESS:
  1203.               v = v1 < v2;
  1204.               break;

  1206.             case BINOP_GTR:
  1207.               v = v1 > v2;
  1208.               break;

  1210.             case BINOP_LEQ:
  1211.               v = v1 <= v2;
  1212.               break;

  1214.             case BINOP_GEQ:
  1215.               v = v1 >= v2;
  1216.               break;

  1218.             default:
  1219.               error (_("Invalid binary operation on numbers."));
  1220.             }

  1222.           val = allocate_value (result_type);
  1223.           store_unsigned_integer (value_contents_raw (val),
  1224.                                   TYPE_LENGTH (value_type (val)),
  1225.                                   gdbarch_byte_order
  1226.                                     (get_type_arch (result_type)),
  1227.                                   v);
  1228.         }
  1229.       else
  1230.         {
  1231.           LONGEST v1, v2, v = 0;

  1233.           v1 = value_as_long (arg1);
  1234.           v2 = value_as_long (arg2);

  1236.           switch (op)
  1237.             {
  1238.             case BINOP_ADD:
  1239.               v = v1 + v2;
  1240.               break;

  1242.             case BINOP_SUB:
  1243.               v = v1 - v2;
  1244.               break;

  1246.             case BINOP_MUL:
  1247.               v = v1 * v2;
  1248.               break;

  1250.             case BINOP_DIV:
  1251.             case BINOP_INTDIV:
  1252.               if (v2 != 0)
  1253.                 v = v1 / v2;
  1254.               else
  1255.                 error (_("Division by zero"));
  1256.               break;

  1258.             case BINOP_EXP:
  1259.               v = integer_pow (v1, v2);
  1260.               break;

  1262.             case BINOP_REM:
  1263.               if (v2 != 0)
  1264.                 v = v1 % v2;
  1265.               else
  1266.                 error (_("Division by zero"));
  1267.               break;

  1269.             case BINOP_MOD:
  1270.               /* Knuth 1.2.4, integer only.  Note that unlike the C '%' op,
  1271.                  X mod 0 has a defined value, X.  */
  1272.               if (v2 == 0)
  1273.                 {
  1274.                   v = v1;
  1275.                 }
  1276.               else
  1277.                 {
  1278.                   v = v1 / v2;
  1279.                   /* Compute floor.  */
  1280.                   if (TRUNCATION_TOWARDS_ZERO && (v < 0) && ((v1 % v2) != 0))
  1281.                     {
  1282.                       v--;
  1283.                     }
  1284.                   v = v1 - (v2 * v);
  1285.                 }
  1286.               break;

  1288.             case BINOP_LSH:
  1289.               v = v1 << v2;
  1290.               break;

  1292.             case BINOP_RSH:
  1293.               v = v1 >> v2;
  1294.               break;

  1296.             case BINOP_BITWISE_AND:
  1297.               v = v1 & v2;
  1298.               break;

  1300.             case BINOP_BITWISE_IOR:
  1301.               v = v1 | v2;
  1302.               break;

  1304.             case BINOP_BITWISE_XOR:
  1305.               v = v1 ^ v2;
  1306.               break;

  1308.             case BINOP_LOGICAL_AND:
  1309.               v = v1 && v2;
  1310.               break;

  1312.             case BINOP_LOGICAL_OR:
  1313.               v = v1 || v2;
  1314.               break;

  1316.             case BINOP_MIN:
  1317.               v = v1 < v2 ? v1 : v2;
  1318.               break;

  1320.             case BINOP_MAX:
  1321.               v = v1 > v2 ? v1 : v2;
  1322.               break;

  1324.             case BINOP_EQUAL:
  1325.               v = v1 == v2;
  1326.               break;

  1328.             case BINOP_NOTEQUAL:
  1329.               v = v1 != v2;
  1330.               break;

  1332.             case BINOP_LESS:
  1333.               v = v1 < v2;
  1334.               break;

  1336.             case BINOP_GTR:
  1337.               v = v1 > v2;
  1338.               break;

  1340.             case BINOP_LEQ:
  1341.               v = v1 <= v2;
  1342.               break;

  1344.             case BINOP_GEQ:
  1345.               v = v1 >= v2;
  1346.               break;

  1348.             default:
  1349.               error (_("Invalid binary operation on numbers."));
  1350.             }

  1352.           val = allocate_value (result_type);
  1353.           store_signed_integer (value_contents_raw (val),
  1354.                                 TYPE_LENGTH (value_type (val)),
  1355.                                 gdbarch_byte_order
  1356.                                   (get_type_arch (result_type)),
  1357.                                 v);
  1358.         }
  1359.     }

  1361.   return val;
  1362. }

  1364. /* Widen a scalar value SCALAR_VALUE to vector type VECTOR_TYPE by
  1365.    replicating SCALAR_VALUE for each element of the vector.  Only scalar
  1366.    types that can be cast to the type of one element of the vector are
  1367.    acceptable.  The newly created vector value is returned upon success,
  1368.    otherwise an error is thrown.  */

  1370. struct value *
  1371. ‌value_vector_widen (struct value *scalar_value, struct type *vector_type)
  1372. {
  1373.   /* Widen the scalar to a vector.  */
  1374.   struct type *eltype, *scalar_type;
  1375.   struct value *val, *elval;
  1376.   LONGEST low_bound, high_bound;
  1377.   int i;

  1379.   CHECK_TYPEDEF (vector_type);

  1381.   gdb_assert (TYPE_CODE (vector_type) == TYPE_CODE_ARRAY
  1382.               && TYPE_VECTOR (vector_type));

  1384.   if (!get_array_bounds (vector_type, &low_bound, &high_bound))
  1385.     error (_("Could not determine the vector bounds"));

  1387.   eltype = check_typedef (TYPE_TARGET_TYPE (vector_type));
  1388.   elval = value_cast (eltype, scalar_value);

  1390.   scalar_type = check_typedef (value_type (scalar_value));

  1392.   /* If we reduced the length of the scalar then check we didn't loose any
  1393.      important bits.  */
  1394.   if (TYPE_LENGTH (eltype) < TYPE_LENGTH (scalar_type)
  1395.       && !value_equal (elval, scalar_value))
  1396.     error (_("conversion of scalar to vector involves truncation"));

  1398.   val = allocate_value (vector_type);
  1399.   for (i = 0; i < high_bound - low_bound + 1; i++)
  1400.     /* Duplicate the contents of elval into the destination vector.  */
  1401.     memcpy (value_contents_writeable (val) + (i * TYPE_LENGTH (eltype)),
  1402.             value_contents_all (elval), TYPE_LENGTH (eltype));

  1404.   return val;
  1405. }

  1407. /* Performs a binary operation on two vector operands by calling scalar_binop
  1408.    for each pair of vector components.  */

  1410. static struct value *
  1411. ‌vector_binop (struct value *val1, struct value *val2, enum exp_opcode op)
  1412. {
  1413.   struct value *val, *tmp, *mark;
  1414.   struct type *type1, *type2, *eltype1, *eltype2;
  1415.   int t1_is_vec, t2_is_vec, elsize, i;
  1416.   LONGEST low_bound1, high_bound1, low_bound2, high_bound2;

  1418.   type1 = check_typedef (value_type (val1));
  1419.   type2 = check_typedef (value_type (val2));

  1421.   t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY
  1422.                && TYPE_VECTOR (type1)) ? 1 : 0;
  1423.   t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY
  1424.                && TYPE_VECTOR (type2)) ? 1 : 0;

  1426.   if (!t1_is_vec || !t2_is_vec)
  1427.     error (_("Vector operations are only supported among vectors"));

  1429.   if (!get_array_bounds (type1, &low_bound1, &high_bound1)
  1430.       || !get_array_bounds (type2, &low_bound2, &high_bound2))
  1431.     error (_("Could not determine the vector bounds"));

  1433.   eltype1 = check_typedef (TYPE_TARGET_TYPE (type1));
  1434.   eltype2 = check_typedef (TYPE_TARGET_TYPE (type2));
  1435.   elsize = TYPE_LENGTH (eltype1);

  1437.   if (TYPE_CODE (eltype1) != TYPE_CODE (eltype2)
  1438.       || elsize != TYPE_LENGTH (eltype2)
  1439.       || TYPE_UNSIGNED (eltype1) != TYPE_UNSIGNED (eltype2)
  1440.       || low_bound1 != low_bound2 || high_bound1 != high_bound2)
  1441.     error (_("Cannot perform operation on vectors with different types"));

  1443.   val = allocate_value (type1);
  1444.   mark = value_mark ();
  1445.   for (i = 0; i < high_bound1 - low_bound1 + 1; i++)
  1446.     {
  1447.       tmp = value_binop (value_subscript (val1, i),
  1448.                          value_subscript (val2, i), op);
  1449.       memcpy (value_contents_writeable (val) + i * elsize,
  1450.               value_contents_all (tmp),
  1451.               elsize);
  1452.      }
  1453.   value_free_to_mark (mark);

  1455.   return val;
  1456. }

  1458. /* Perform a binary operation on two operands.  */

  1460. struct value *
  1461. ‌value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
  1462. {
  1463.   struct value *val;
  1464.   struct type *type1 = check_typedef (value_type (arg1));
  1465.   struct type *type2 = check_typedef (value_type (arg2));
  1466.   int t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY
  1467.                    && TYPE_VECTOR (type1));
  1468.   int t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY
  1469.                    && TYPE_VECTOR (type2));

  1471.   if (!t1_is_vec && !t2_is_vec)
  1472.     val = scalar_binop (arg1, arg2, op);
  1473.   else if (t1_is_vec && t2_is_vec)
  1474.     val = vector_binop (arg1, arg2, op);
  1475.   else
  1476.     {
  1477.       /* Widen the scalar operand to a vector.  */
  1478.       struct value **v = t1_is_vec ? &arg2 : &arg1;
  1479.       struct type *t = t1_is_vec ? type2 : type1;

  1481.       if (TYPE_CODE (t) != TYPE_CODE_FLT
  1482.           && TYPE_CODE (t) != TYPE_CODE_DECFLOAT
  1483.           && !is_integral_type (t))
  1484.         error (_("Argument to operation not a number or boolean."));

  1486.       /* Replicate the scalar value to make a vector value.  */
  1487.       *v = value_vector_widen (*v, t1_is_vec ? type1 : type2);

  1489.       val = vector_binop (arg1, arg2, op);
  1490.     }

  1492.   return val;
  1493. }

  1495. /* Simulate the C operator ! -- return 1 if ARG1 contains zero.  */

  1497. int
  1498. ‌value_logical_not (struct value *arg1)
  1499. {
  1500.   int len;
  1501.   const gdb_byte *p;
  1502.   struct type *type1;

  1504.   arg1 = coerce_array (arg1);
  1505.   type1 = check_typedef (value_type (arg1));

  1507.   if (TYPE_CODE (type1) == TYPE_CODE_FLT)
  1508.     return 0 == value_as_double (arg1);
  1509.   else if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT)
  1510.     return decimal_is_zero (value_contents (arg1), TYPE_LENGTH (type1),
  1511.                             gdbarch_byte_order (get_type_arch (type1)));

  1513.   len = TYPE_LENGTH (type1);
  1514.   p = value_contents (arg1);

  1516.   while (--len >= 0)
  1517.     {
  1518.       if (*p++)
  1519.         break;
  1520.     }

  1522.   return len < 0;
  1523. }

  1525. /* Perform a comparison on two string values (whose content are not
  1526.    necessarily null terminated) based on their length.  */

  1528. static int
  1529. ‌value_strcmp (struct value *arg1, struct value *arg2)
  1530. {
  1531.   int len1 = TYPE_LENGTH (value_type (arg1));
  1532.   int len2 = TYPE_LENGTH (value_type (arg2));
  1533.   const gdb_byte *s1 = value_contents (arg1);
  1534.   const gdb_byte *s2 = value_contents (arg2);
  1535.   int i, len = len1 < len2 ? len1 : len2;

  1537.   for (i = 0; i < len; i++)
  1538.     {
  1539.       if (s1[i] < s2[i])
  1540.         return -1;
  1541.       else if (s1[i] > s2[i])
  1542.         return 1;
  1543.       else
  1544.         continue;
  1545.     }

  1547.   if (len1 < len2)
  1548.     return -1;
  1549.   else if (len1 > len2)
  1550.     return 1;
  1551.   else
  1552.     return 0;
  1553. }

  1555. /* Simulate the C operator == by returning a 1
  1556.    iff ARG1 and ARG2 have equal contents.  */

  1558. int
  1559. ‌value_equal (struct value *arg1, struct value *arg2)
  1560. {
  1561.   int len;
  1562.   const gdb_byte *p1;
  1563.   const gdb_byte *p2;
  1564.   struct type *type1, *type2;
  1565.   enum type_code code1;
  1566.   enum type_code code2;
  1567.   int is_int1, is_int2;

  1569.   arg1 = coerce_array (arg1);
  1570.   arg2 = coerce_array (arg2);

  1572.   type1 = check_typedef (value_type (arg1));
  1573.   type2 = check_typedef (value_type (arg2));
  1574.   code1 = TYPE_CODE (type1);
  1575.   code2 = TYPE_CODE (type2);
  1576.   is_int1 = is_integral_type (type1);
  1577.   is_int2 = is_integral_type (type2);

  1579.   if (is_int1 && is_int2)
  1580.     return longest_to_int (value_as_long (value_binop (arg1, arg2,
  1581.                                                        BINOP_EQUAL)));
  1582.   else if ((code1 == TYPE_CODE_FLT || is_int1)
  1583.            && (code2 == TYPE_CODE_FLT || is_int2))
  1584.     {
  1585.       /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
  1586.          `long double' values are returned in static storage (m68k).  */
  1587.       DOUBLEST d = value_as_double (arg1);

  1589.       return d == value_as_double (arg2);
  1590.     }
  1591.   else if ((code1 == TYPE_CODE_DECFLOAT || is_int1)
  1592.            && (code2 == TYPE_CODE_DECFLOAT || is_int2))
  1593.     {
  1594.       gdb_byte v1[16], v2[16];
  1595.       int len_v1, len_v2;
  1596.       enum bfd_endian byte_order_v1, byte_order_v2;

  1598.       value_args_as_decimal (arg1, arg2, v1, &len_v1, &byte_order_v1,
  1599.                                          v2, &len_v2, &byte_order_v2);

  1601.       return decimal_compare (v1, len_v1, byte_order_v1,
  1602.                               v2, len_v2, byte_order_v2) == 0;
  1603.     }

  1605.   /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
  1606.      is bigger.  */
  1607.   else if (code1 == TYPE_CODE_PTR && is_int2)
  1608.     return value_as_address (arg1) == (CORE_ADDR) value_as_long (arg2);
  1609.   else if (code2 == TYPE_CODE_PTR && is_int1)
  1610.     return (CORE_ADDR) value_as_long (arg1) == value_as_address (arg2);

  1612.   else if (code1 == code2
  1613.            && ((len = (int) TYPE_LENGTH (type1))
  1614.                == (int) TYPE_LENGTH (type2)))
  1615.     {
  1616.       p1 = value_contents (arg1);
  1617.       p2 = value_contents (arg2);
  1618.       while (--len >= 0)
  1619.         {
  1620.           if (*p1++ != *p2++)
  1621.             break;
  1622.         }
  1623.       return len < 0;
  1624.     }
  1625.   else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
  1626.     {
  1627.       return value_strcmp (arg1, arg2) == 0;
  1628.     }
  1629.   else
  1630.     {
  1631.       error (_("Invalid type combination in equality test."));
  1632.       return 0;                        /* For lint -- never reached.  */
  1633.     }
  1634. }

  1636. /* Compare values based on their raw contents.  Useful for arrays since
  1637.    value_equal coerces them to pointers, thus comparing just the address
  1638.    of the array instead of its contents.  */

  1640. int
  1641. ‌value_equal_contents (struct value *arg1, struct value *arg2)
  1642. {
  1643.   struct type *type1, *type2;

  1645.   type1 = check_typedef (value_type (arg1));
  1646.   type2 = check_typedef (value_type (arg2));

  1648.   return (TYPE_CODE (type1) == TYPE_CODE (type2)
  1649.           && TYPE_LENGTH (type1) == TYPE_LENGTH (type2)
  1650.           && memcmp (value_contents (arg1), value_contents (arg2),
  1651.                      TYPE_LENGTH (type1)) == 0);
  1652. }

  1654. /* Simulate the C operator < by returning 1
  1655.    iff ARG1's contents are less than ARG2's.  */

  1657. int
  1658. ‌value_less (struct value *arg1, struct value *arg2)
  1659. {
  1660.   enum type_code code1;
  1661.   enum type_code code2;
  1662.   struct type *type1, *type2;
  1663.   int is_int1, is_int2;

  1665.   arg1 = coerce_array (arg1);
  1666.   arg2 = coerce_array (arg2);

  1668.   type1 = check_typedef (value_type (arg1));
  1669.   type2 = check_typedef (value_type (arg2));
  1670.   code1 = TYPE_CODE (type1);
  1671.   code2 = TYPE_CODE (type2);
  1672.   is_int1 = is_integral_type (type1);
  1673.   is_int2 = is_integral_type (type2);

  1675.   if (is_int1 && is_int2)
  1676.     return longest_to_int (value_as_long (value_binop (arg1, arg2,
  1677.                                                        BINOP_LESS)));
  1678.   else if ((code1 == TYPE_CODE_FLT || is_int1)
  1679.            && (code2 == TYPE_CODE_FLT || is_int2))
  1680.     {
  1681.       /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
  1682.          `long double' values are returned in static storage (m68k).  */
  1683.       DOUBLEST d = value_as_double (arg1);

  1685.       return d < value_as_double (arg2);
  1686.     }
  1687.   else if ((code1 == TYPE_CODE_DECFLOAT || is_int1)
  1688.            && (code2 == TYPE_CODE_DECFLOAT || is_int2))
  1689.     {
  1690.       gdb_byte v1[16], v2[16];
  1691.       int len_v1, len_v2;
  1692.       enum bfd_endian byte_order_v1, byte_order_v2;

  1694.       value_args_as_decimal (arg1, arg2, v1, &len_v1, &byte_order_v1,
  1695.                                          v2, &len_v2, &byte_order_v2);

  1697.       return decimal_compare (v1, len_v1, byte_order_v1,
  1698.                               v2, len_v2, byte_order_v2) == -1;
  1699.     }
  1700.   else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
  1701.     return value_as_address (arg1) < value_as_address (arg2);

  1703.   /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
  1704.      is bigger.  */
  1705.   else if (code1 == TYPE_CODE_PTR && is_int2)
  1706.     return value_as_address (arg1) < (CORE_ADDR) value_as_long (arg2);
  1707.   else if (code2 == TYPE_CODE_PTR && is_int1)
  1708.     return (CORE_ADDR) value_as_long (arg1) < value_as_address (arg2);
  1709.   else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
  1710.     return value_strcmp (arg1, arg2) < 0;
  1711.   else
  1712.     {
  1713.       error (_("Invalid type combination in ordering comparison."));
  1714.       return 0;
  1715.     }
  1716. }

  1718. /* The unary operators +, - and ~.  They free the argument ARG1.  */

  1720. struct value *
  1721. ‌value_pos (struct value *arg1)
  1722. {
  1723.   struct type *type;

  1725.   arg1 = coerce_ref (arg1);
  1726.   type = check_typedef (value_type (arg1));

  1728.   if (TYPE_CODE (type) == TYPE_CODE_FLT)
  1729.     return value_from_double (type, value_as_double (arg1));
  1730.   else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
  1731.     return value_from_decfloat (type, value_contents (arg1));
  1732.   else if (is_integral_type (type))
  1733.     {
  1734.       return value_from_longest (type, value_as_long (arg1));
  1735.     }
  1736.   else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
  1737.     {
  1738.       struct value *val = allocate_value (type);

  1740.       memcpy (value_contents_raw (val), value_contents (arg1),
  1741.               TYPE_LENGTH (type));
  1742.       return val;
  1743.     }
  1744.   else
  1745.     {
  1746.       error (_("Argument to positive operation not a number."));
  1747.       return 0;                        /* For lint -- never reached.  */
  1748.     }
  1749. }

  1751. struct value *
  1752. ‌value_neg (struct value *arg1)
  1753. {
  1754.   struct type *type;

  1756.   arg1 = coerce_ref (arg1);
  1757.   type = check_typedef (value_type (arg1));

  1759.   if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
  1760.     {
  1761.       struct value *val = allocate_value (type);
  1762.       int len = TYPE_LENGTH (type);
  1763.       gdb_byte decbytes[16];  /* a decfloat is at most 128 bits long.  */

  1765.       memcpy (decbytes, value_contents (arg1), len);

  1767.       if (gdbarch_byte_order (get_type_arch (type)) == BFD_ENDIAN_LITTLE)
  1768.         decbytes[len-1] = decbytes[len - 1] | 0x80;
  1769.       else
  1770.         decbytes[0] = decbytes[0] | 0x80;

  1772.       memcpy (value_contents_raw (val), decbytes, len);
  1773.       return val;
  1774.     }
  1775.   else if (TYPE_CODE (type) == TYPE_CODE_FLT)
  1776.     return value_from_double (type, -value_as_double (arg1));
  1777.   else if (is_integral_type (type))
  1778.     {
  1779.       return value_from_longest (type, -value_as_long (arg1));
  1780.     }
  1781.   else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
  1782.     {
  1783.       struct value *tmp, *val = allocate_value (type);
  1784.       struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
  1785.       int i;
  1786.       LONGEST low_bound, high_bound;

  1788.       if (!get_array_bounds (type, &low_bound, &high_bound))
  1789.         error (_("Could not determine the vector bounds"));

  1791.       for (i = 0; i < high_bound - low_bound + 1; i++)
  1792.         {
  1793.           tmp = value_neg (value_subscript (arg1, i));
  1794.           memcpy (value_contents_writeable (val) + i * TYPE_LENGTH (eltype),
  1795.                   value_contents_all (tmp), TYPE_LENGTH (eltype));
  1796.         }
  1797.       return val;
  1798.     }
  1799.   else
  1800.     {
  1801.       error (_("Argument to negate operation not a number."));
  1802.       return 0;                        /* For lint -- never reached.  */
  1803.     }
  1804. }

  1806. struct value *
  1807. ‌value_complement (struct value *arg1)
  1808. {
  1809.   struct type *type;
  1810.   struct value *val;

  1812.   arg1 = coerce_ref (arg1);
  1813.   type = check_typedef (value_type (arg1));

  1815.   if (is_integral_type (type))
  1816.     val = value_from_longest (type, ~value_as_long (arg1));
  1817.   else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
  1818.     {
  1819.       struct value *tmp;
  1820.       struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
  1821.       int i;
  1822.       LONGEST low_bound, high_bound;

  1824.       if (!get_array_bounds (type, &low_bound, &high_bound))
  1825.         error (_("Could not determine the vector bounds"));

  1827.       val = allocate_value (type);
  1828.       for (i = 0; i < high_bound - low_bound + 1; i++)
  1829.         {
  1830.           tmp = value_complement (value_subscript (arg1, i));
  1831.           memcpy (value_contents_writeable (val) + i * TYPE_LENGTH (eltype),
  1832.                   value_contents_all (tmp), TYPE_LENGTH (eltype));
  1833.         }
  1834.     }
  1835.   else
  1836.     error (_("Argument to complement operation not an integer, boolean."));

  1838.   return val;
  1839. }

  1841. /* The INDEX'th bit of SET value whose value_type is TYPE,
  1842.    and whose value_contents is valaddr.
  1843.    Return -1 if out of range, -2 other error.  */

  1845. int
  1846. ‌value_bit_index (struct type *type, const gdb_byte *valaddr, int index)
  1847. {
  1848.   struct gdbarch *gdbarch = get_type_arch (type);
  1849.   LONGEST low_bound, high_bound;
  1850.   LONGEST word;
  1851.   unsigned rel_index;
  1852.   struct type *range = TYPE_INDEX_TYPE (type);

  1854.   if (get_discrete_bounds (range, &low_bound, &high_bound) < 0)
  1855.     return -2;
  1856.   if (index < low_bound || index > high_bound)
  1857.     return -1;
  1858.   rel_index = index - low_bound;
  1859.   word = extract_unsigned_integer (valaddr + (rel_index / TARGET_CHAR_BIT), 1,
  1860.                                    gdbarch_byte_order (gdbarch));
  1861.   rel_index %= TARGET_CHAR_BIT;
  1862.   if (gdbarch_bits_big_endian (gdbarch))
  1863.     rel_index = TARGET_CHAR_BIT - 1 - rel_index;
  1864.   return (word >> rel_index) & 1;
  1865. }

  1867. int
  1868. ‌value_in (struct value *element, struct value *set)
  1869. {
  1870.   int member;
  1871.   struct type *settype = check_typedef (value_type (set));
  1872.   struct type *eltype = check_typedef (value_type (element));

  1874.   if (TYPE_CODE (eltype) == TYPE_CODE_RANGE)
  1875.     eltype = TYPE_TARGET_TYPE (eltype);
  1876.   if (TYPE_CODE (settype) != TYPE_CODE_SET)
  1877.     error (_("Second argument of 'IN' has wrong type"));
  1878.   if (TYPE_CODE (eltype) != TYPE_CODE_INT
  1879.       && TYPE_CODE (eltype) != TYPE_CODE_CHAR
  1880.       && TYPE_CODE (eltype) != TYPE_CODE_ENUM
  1881.       && TYPE_CODE (eltype) != TYPE_CODE_BOOL)
  1882.     error (_("First argument of 'IN' has wrong type"));
  1883.   member = value_bit_index (settype, value_contents (set),
  1884.                             value_as_long (element));
  1885.   if (member < 0)
  1886.     error (_("First argument of 'IN' not in range"));
  1887.   return member;
  1888. }

  1890. void
  1891. ‌_initialize_valarith (void)
  1892. {
  1893. }