OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [gdb/] [valarith.c] - Blame information for rev 578

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 578 markom
/* Perform arithmetic and other operations on values, for GDB.
2
   Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
3
   1997, 1998, 1999, 2000
4
   Free Software Foundation, Inc.
5
 
6
   This file is part of GDB.
7
 
8
   This program is free software; you can redistribute it and/or modify
9
   it under the terms of the GNU General Public License as published by
10
   the Free Software Foundation; either version 2 of the License, or
11
   (at your option) any later version.
12
 
13
   This program is distributed in the hope that it will be useful,
14
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
   GNU General Public License for more details.
17
 
18
   You should have received a copy of the GNU General Public License
19
   along with this program; if not, write to the Free Software
20
   Foundation, Inc., 59 Temple Place - Suite 330,
21
   Boston, MA 02111-1307, USA.  */
22
 
23
#include "defs.h"
24
#include "value.h"
25
#include "symtab.h"
26
#include "gdbtypes.h"
27
#include "expression.h"
28
#include "target.h"
29
#include "language.h"
30
#include "gdb_string.h"
31
#include <math.h>
32
 
33
/* Define whether or not the C operator '/' truncates towards zero for
34
   differently signed operands (truncation direction is undefined in C). */
35
 
36
#ifndef TRUNCATION_TOWARDS_ZERO
37
#define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
38
#endif
39
 
40
static value_ptr value_subscripted_rvalue (value_ptr, value_ptr, int);
41
 
42
void _initialize_valarith (void);
43
 
44
 
45
value_ptr
46
value_add (value_ptr arg1, value_ptr arg2)
47
{
48
  register value_ptr valint, valptr;
49
  register int len;
50
  struct type *type1, *type2, *valptrtype;
51
 
52
  COERCE_NUMBER (arg1);
53
  COERCE_NUMBER (arg2);
54
  type1 = check_typedef (VALUE_TYPE (arg1));
55
  type2 = check_typedef (VALUE_TYPE (arg2));
56
 
57
  if ((TYPE_CODE (type1) == TYPE_CODE_PTR
58
       || TYPE_CODE (type2) == TYPE_CODE_PTR)
59
      &&
60
      (TYPE_CODE (type1) == TYPE_CODE_INT
61
       || TYPE_CODE (type2) == TYPE_CODE_INT))
62
    /* Exactly one argument is a pointer, and one is an integer.  */
63
    {
64
      value_ptr retval;
65
 
66
      if (TYPE_CODE (type1) == TYPE_CODE_PTR)
67
        {
68
          valptr = arg1;
69
          valint = arg2;
70
          valptrtype = type1;
71
        }
72
      else
73
        {
74
          valptr = arg2;
75
          valint = arg1;
76
          valptrtype = type2;
77
        }
78
      len = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (valptrtype)));
79
      if (len == 0)
80
        len = 1;                /* For (void *) */
81
      retval = value_from_pointer (valptrtype,
82
                                   value_as_pointer (valptr)
83
                                   + (len * value_as_long (valint)));
84
      VALUE_BFD_SECTION (retval) = VALUE_BFD_SECTION (valptr);
85
      return retval;
86
    }
87
 
88
  return value_binop (arg1, arg2, BINOP_ADD);
89
}
90
 
91
value_ptr
92
value_sub (value_ptr arg1, value_ptr arg2)
93
{
94
  struct type *type1, *type2;
95
  COERCE_NUMBER (arg1);
96
  COERCE_NUMBER (arg2);
97
  type1 = check_typedef (VALUE_TYPE (arg1));
98
  type2 = check_typedef (VALUE_TYPE (arg2));
99
 
100
  if (TYPE_CODE (type1) == TYPE_CODE_PTR)
101
    {
102
      if (TYPE_CODE (type2) == TYPE_CODE_INT)
103
        {
104
          /* pointer - integer.  */
105
          LONGEST sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
106
          return value_from_pointer (VALUE_TYPE (arg1),
107
                                     (value_as_pointer (arg1)
108
                                      - (sz * value_as_long (arg2))));
109
        }
110
      else if (TYPE_CODE (type2) == TYPE_CODE_PTR
111
               && TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)))
112
               == TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2))))
113
        {
114
          /* pointer to <type x> - pointer to <type x>.  */
115
          LONGEST sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
116
          return value_from_longest
117
            (builtin_type_long, /* FIXME -- should be ptrdiff_t */
118
             (value_as_long (arg1) - value_as_long (arg2)) / sz);
119
        }
120
      else
121
        {
122
          error ("\
123
First argument of `-' is a pointer and second argument is neither\n\
124
an integer nor a pointer of the same type.");
125
        }
126
    }
127
 
128
  return value_binop (arg1, arg2, BINOP_SUB);
129
}
130
 
131
/* Return the value of ARRAY[IDX].
132
   See comments in value_coerce_array() for rationale for reason for
133
   doing lower bounds adjustment here rather than there.
134
   FIXME:  Perhaps we should validate that the index is valid and if
135
   verbosity is set, warn about invalid indices (but still use them). */
136
 
137
value_ptr
138
value_subscript (value_ptr array, value_ptr idx)
139
{
140
  value_ptr bound;
141
  int c_style = current_language->c_style_arrays;
142
  struct type *tarray;
143
 
144
  COERCE_REF (array);
145
  tarray = check_typedef (VALUE_TYPE (array));
146
  COERCE_VARYING_ARRAY (array, tarray);
147
 
148
  if (TYPE_CODE (tarray) == TYPE_CODE_ARRAY
149
      || TYPE_CODE (tarray) == TYPE_CODE_STRING)
150
    {
151
      struct type *range_type = TYPE_INDEX_TYPE (tarray);
152
      LONGEST lowerbound, upperbound;
153
      get_discrete_bounds (range_type, &lowerbound, &upperbound);
154
 
155
      if (VALUE_LVAL (array) != lval_memory)
156
        return value_subscripted_rvalue (array, idx, lowerbound);
157
 
158
      if (c_style == 0)
159
        {
160
          LONGEST index = value_as_long (idx);
161
          if (index >= lowerbound && index <= upperbound)
162
            return value_subscripted_rvalue (array, idx, lowerbound);
163
          warning ("array or string index out of range");
164
          /* fall doing C stuff */
165
          c_style = 1;
166
        }
167
 
168
      if (lowerbound != 0)
169
        {
170
          bound = value_from_longest (builtin_type_int, (LONGEST) lowerbound);
171
          idx = value_sub (idx, bound);
172
        }
173
 
174
      array = value_coerce_array (array);
175
    }
176
 
177
  if (TYPE_CODE (tarray) == TYPE_CODE_BITSTRING)
178
    {
179
      struct type *range_type = TYPE_INDEX_TYPE (tarray);
180
      LONGEST index = value_as_long (idx);
181
      value_ptr v;
182
      int offset, byte, bit_index;
183
      LONGEST lowerbound, upperbound;
184
      get_discrete_bounds (range_type, &lowerbound, &upperbound);
185
      if (index < lowerbound || index > upperbound)
186
        error ("bitstring index out of range");
187
      index -= lowerbound;
188
      offset = index / TARGET_CHAR_BIT;
189
      byte = *((char *) VALUE_CONTENTS (array) + offset);
190
      bit_index = index % TARGET_CHAR_BIT;
191
      byte >>= (BITS_BIG_ENDIAN ? TARGET_CHAR_BIT - 1 - bit_index : bit_index);
192
      v = value_from_longest (LA_BOOL_TYPE, byte & 1);
193
      VALUE_BITPOS (v) = bit_index;
194
      VALUE_BITSIZE (v) = 1;
195
      VALUE_LVAL (v) = VALUE_LVAL (array);
196
      if (VALUE_LVAL (array) == lval_internalvar)
197
        VALUE_LVAL (v) = lval_internalvar_component;
198
      VALUE_ADDRESS (v) = VALUE_ADDRESS (array);
199
      VALUE_OFFSET (v) = offset + VALUE_OFFSET (array);
200
      return v;
201
    }
202
 
203
  if (c_style)
204
    return value_ind (value_add (array, idx));
205
  else
206
    error ("not an array or string");
207
}
208
 
209
/* Return the value of EXPR[IDX], expr an aggregate rvalue
210
   (eg, a vector register).  This routine used to promote floats
211
   to doubles, but no longer does.  */
212
 
213
static value_ptr
214
value_subscripted_rvalue (value_ptr array, value_ptr idx, int lowerbound)
215
{
216
  struct type *array_type = check_typedef (VALUE_TYPE (array));
217
  struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (array_type));
218
  unsigned int elt_size = TYPE_LENGTH (elt_type);
219
  LONGEST index = value_as_long (idx);
220
  unsigned int elt_offs = elt_size * longest_to_int (index - lowerbound);
221
  value_ptr v;
222
 
223
  if (index < lowerbound || elt_offs >= TYPE_LENGTH (array_type))
224
    error ("no such vector element");
225
 
226
  v = allocate_value (elt_type);
227
  if (VALUE_LAZY (array))
228
    VALUE_LAZY (v) = 1;
229
  else
230
    memcpy (VALUE_CONTENTS (v), VALUE_CONTENTS (array) + elt_offs, elt_size);
231
 
232
  if (VALUE_LVAL (array) == lval_internalvar)
233
    VALUE_LVAL (v) = lval_internalvar_component;
234
  else
235
    VALUE_LVAL (v) = VALUE_LVAL (array);
236
  VALUE_ADDRESS (v) = VALUE_ADDRESS (array);
237
  VALUE_OFFSET (v) = VALUE_OFFSET (array) + elt_offs;
238
  return v;
239
}
240
 
241
/* Check to see if either argument is a structure.  This is called so
242
   we know whether to go ahead with the normal binop or look for a
243
   user defined function instead.
244
 
245
   For now, we do not overload the `=' operator.  */
246
 
247
int
248
binop_user_defined_p (enum exp_opcode op, value_ptr arg1, value_ptr arg2)
249
{
250
  struct type *type1, *type2;
251
  if (op == BINOP_ASSIGN || op == BINOP_CONCAT)
252
    return 0;
253
  type1 = check_typedef (VALUE_TYPE (arg1));
254
  type2 = check_typedef (VALUE_TYPE (arg2));
255
  return (TYPE_CODE (type1) == TYPE_CODE_STRUCT
256
          || TYPE_CODE (type2) == TYPE_CODE_STRUCT
257
          || (TYPE_CODE (type1) == TYPE_CODE_REF
258
              && TYPE_CODE (TYPE_TARGET_TYPE (type1)) == TYPE_CODE_STRUCT)
259
          || (TYPE_CODE (type2) == TYPE_CODE_REF
260
              && TYPE_CODE (TYPE_TARGET_TYPE (type2)) == TYPE_CODE_STRUCT));
261
}
262
 
263
/* Check to see if argument is a structure.  This is called so
264
   we know whether to go ahead with the normal unop or look for a
265
   user defined function instead.
266
 
267
   For now, we do not overload the `&' operator.  */
268
 
269
int
270
unop_user_defined_p (enum exp_opcode op, value_ptr arg1)
271
{
272
  struct type *type1;
273
  if (op == UNOP_ADDR)
274
    return 0;
275
  type1 = check_typedef (VALUE_TYPE (arg1));
276
  for (;;)
277
    {
278
      if (TYPE_CODE (type1) == TYPE_CODE_STRUCT)
279
        return 1;
280
      else if (TYPE_CODE (type1) == TYPE_CODE_REF)
281
        type1 = TYPE_TARGET_TYPE (type1);
282
      else
283
        return 0;
284
    }
285
}
286
 
287
/* We know either arg1 or arg2 is a structure, so try to find the right
288
   user defined function.  Create an argument vector that calls
289
   arg1.operator @ (arg1,arg2) and return that value (where '@' is any
290
   binary operator which is legal for GNU C++).
291
 
292
   OP is the operatore, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP
293
   is the opcode saying how to modify it.  Otherwise, OTHEROP is
294
   unused.  */
295
 
296
value_ptr
297
value_x_binop (value_ptr arg1, value_ptr arg2, enum exp_opcode op,
298
               enum exp_opcode otherop, enum noside noside)
299
{
300
  value_ptr *argvec;
301
  char *ptr;
302
  char tstr[13];
303
  int static_memfuncp;
304
 
305
  COERCE_REF (arg1);
306
  COERCE_REF (arg2);
307
  COERCE_ENUM (arg1);
308
  COERCE_ENUM (arg2);
309
 
310
  /* now we know that what we have to do is construct our
311
     arg vector and find the right function to call it with.  */
312
 
313
  if (TYPE_CODE (check_typedef (VALUE_TYPE (arg1))) != TYPE_CODE_STRUCT)
314
    error ("Can't do that binary op on that type");     /* FIXME be explicit */
315
 
316
  argvec = (value_ptr *) alloca (sizeof (value_ptr) * 4);
317
  argvec[1] = value_addr (arg1);
318
  argvec[2] = arg2;
319
  argvec[3] = 0;
320
 
321
  /* make the right function name up */
322
  strcpy (tstr, "operator__");
323
  ptr = tstr + 8;
324
  switch (op)
325
    {
326
    case BINOP_ADD:
327
      strcpy (ptr, "+");
328
      break;
329
    case BINOP_SUB:
330
      strcpy (ptr, "-");
331
      break;
332
    case BINOP_MUL:
333
      strcpy (ptr, "*");
334
      break;
335
    case BINOP_DIV:
336
      strcpy (ptr, "/");
337
      break;
338
    case BINOP_REM:
339
      strcpy (ptr, "%");
340
      break;
341
    case BINOP_LSH:
342
      strcpy (ptr, "<<");
343
      break;
344
    case BINOP_RSH:
345
      strcpy (ptr, ">>");
346
      break;
347
    case BINOP_BITWISE_AND:
348
      strcpy (ptr, "&");
349
      break;
350
    case BINOP_BITWISE_IOR:
351
      strcpy (ptr, "|");
352
      break;
353
    case BINOP_BITWISE_XOR:
354
      strcpy (ptr, "^");
355
      break;
356
    case BINOP_LOGICAL_AND:
357
      strcpy (ptr, "&&");
358
      break;
359
    case BINOP_LOGICAL_OR:
360
      strcpy (ptr, "||");
361
      break;
362
    case BINOP_MIN:
363
      strcpy (ptr, "<?");
364
      break;
365
    case BINOP_MAX:
366
      strcpy (ptr, ">?");
367
      break;
368
    case BINOP_ASSIGN:
369
      strcpy (ptr, "=");
370
      break;
371
    case BINOP_ASSIGN_MODIFY:
372
      switch (otherop)
373
        {
374
        case BINOP_ADD:
375
          strcpy (ptr, "+=");
376
          break;
377
        case BINOP_SUB:
378
          strcpy (ptr, "-=");
379
          break;
380
        case BINOP_MUL:
381
          strcpy (ptr, "*=");
382
          break;
383
        case BINOP_DIV:
384
          strcpy (ptr, "/=");
385
          break;
386
        case BINOP_REM:
387
          strcpy (ptr, "%=");
388
          break;
389
        case BINOP_BITWISE_AND:
390
          strcpy (ptr, "&=");
391
          break;
392
        case BINOP_BITWISE_IOR:
393
          strcpy (ptr, "|=");
394
          break;
395
        case BINOP_BITWISE_XOR:
396
          strcpy (ptr, "^=");
397
          break;
398
        case BINOP_MOD: /* invalid */
399
        default:
400
          error ("Invalid binary operation specified.");
401
        }
402
      break;
403
    case BINOP_SUBSCRIPT:
404
      strcpy (ptr, "[]");
405
      break;
406
    case BINOP_EQUAL:
407
      strcpy (ptr, "==");
408
      break;
409
    case BINOP_NOTEQUAL:
410
      strcpy (ptr, "!=");
411
      break;
412
    case BINOP_LESS:
413
      strcpy (ptr, "<");
414
      break;
415
    case BINOP_GTR:
416
      strcpy (ptr, ">");
417
      break;
418
    case BINOP_GEQ:
419
      strcpy (ptr, ">=");
420
      break;
421
    case BINOP_LEQ:
422
      strcpy (ptr, "<=");
423
      break;
424
    case BINOP_MOD:             /* invalid */
425
    default:
426
      error ("Invalid binary operation specified.");
427
    }
428
 
429
  argvec[0] = value_struct_elt (&arg1, argvec + 1, tstr, &static_memfuncp, "structure");
430
 
431
  if (argvec[0])
432
    {
433
      if (static_memfuncp)
434
        {
435
          argvec[1] = argvec[0];
436
          argvec++;
437
        }
438
      if (noside == EVAL_AVOID_SIDE_EFFECTS)
439
        {
440
          struct type *return_type;
441
          return_type
442
            = TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (argvec[0])));
443
          return value_zero (return_type, VALUE_LVAL (arg1));
444
        }
445
      return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1);
446
    }
447
  error ("member function %s not found", tstr);
448
#ifdef lint
449
  return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1);
450
#endif
451
}
452
 
453
/* We know that arg1 is a structure, so try to find a unary user
454
   defined operator that matches the operator in question.
455
   Create an argument vector that calls arg1.operator @ (arg1)
456
   and return that value (where '@' is (almost) any unary operator which
457
   is legal for GNU C++).  */
458
 
459
value_ptr
460
value_x_unop (value_ptr arg1, enum exp_opcode op, enum noside noside)
461
{
462
  value_ptr *argvec;
463
  char *ptr, *mangle_ptr;
464
  char tstr[13], mangle_tstr[13];
465
  int static_memfuncp;
466
 
467
  COERCE_REF (arg1);
468
  COERCE_ENUM (arg1);
469
 
470
  /* now we know that what we have to do is construct our
471
     arg vector and find the right function to call it with.  */
472
 
473
  if (TYPE_CODE (check_typedef (VALUE_TYPE (arg1))) != TYPE_CODE_STRUCT)
474
    error ("Can't do that unary op on that type");      /* FIXME be explicit */
475
 
476
  argvec = (value_ptr *) alloca (sizeof (value_ptr) * 3);
477
  argvec[1] = value_addr (arg1);
478
  argvec[2] = 0;
479
 
480
  /* make the right function name up */
481
  strcpy (tstr, "operator__");
482
  ptr = tstr + 8;
483
  strcpy (mangle_tstr, "__");
484
  mangle_ptr = mangle_tstr + 2;
485
  switch (op)
486
    {
487
    case UNOP_PREINCREMENT:
488
      strcpy (ptr, "++");
489
      break;
490
    case UNOP_PREDECREMENT:
491
      strcpy (ptr, "++");
492
      break;
493
    case UNOP_POSTINCREMENT:
494
      strcpy (ptr, "++");
495
      break;
496
    case UNOP_POSTDECREMENT:
497
      strcpy (ptr, "++");
498
      break;
499
    case UNOP_LOGICAL_NOT:
500
      strcpy (ptr, "!");
501
      break;
502
    case UNOP_COMPLEMENT:
503
      strcpy (ptr, "~");
504
      break;
505
    case UNOP_NEG:
506
      strcpy (ptr, "-");
507
      break;
508
    case UNOP_IND:
509
      strcpy (ptr, "*");
510
      break;
511
    default:
512
      error ("Invalid unary operation specified.");
513
    }
514
 
515
  argvec[0] = value_struct_elt (&arg1, argvec + 1, tstr, &static_memfuncp, "structure");
516
 
517
  if (argvec[0])
518
    {
519
      if (static_memfuncp)
520
        {
521
          argvec[1] = argvec[0];
522
          argvec++;
523
        }
524
      if (noside == EVAL_AVOID_SIDE_EFFECTS)
525
        {
526
          struct type *return_type;
527
          return_type
528
            = TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (argvec[0])));
529
          return value_zero (return_type, VALUE_LVAL (arg1));
530
        }
531
      return call_function_by_hand (argvec[0], 1 - static_memfuncp, argvec + 1);
532
    }
533
  error ("member function %s not found", tstr);
534
  return 0;                      /* For lint -- never reached */
535
}
536
 
537
 
538
/* Concatenate two values with the following conditions:
539
 
540
   (1)  Both values must be either bitstring values or character string
541
   values and the resulting value consists of the concatenation of
542
   ARG1 followed by ARG2.
543
 
544
   or
545
 
546
   One value must be an integer value and the other value must be
547
   either a bitstring value or character string value, which is
548
   to be repeated by the number of times specified by the integer
549
   value.
550
 
551
 
552
   (2)  Boolean values are also allowed and are treated as bit string
553
   values of length 1.
554
 
555
   (3)  Character values are also allowed and are treated as character
556
   string values of length 1.
557
 */
558
 
559
value_ptr
560
value_concat (value_ptr arg1, value_ptr arg2)
561
{
562
  register value_ptr inval1, inval2, outval = NULL;
563
  int inval1len, inval2len;
564
  int count, idx;
565
  char *ptr;
566
  char inchar;
567
  struct type *type1 = check_typedef (VALUE_TYPE (arg1));
568
  struct type *type2 = check_typedef (VALUE_TYPE (arg2));
569
 
570
  COERCE_VARYING_ARRAY (arg1, type1);
571
  COERCE_VARYING_ARRAY (arg2, type2);
572
 
573
  /* First figure out if we are dealing with two values to be concatenated
574
     or a repeat count and a value to be repeated.  INVAL1 is set to the
575
     first of two concatenated values, or the repeat count.  INVAL2 is set
576
     to the second of the two concatenated values or the value to be
577
     repeated. */
578
 
579
  if (TYPE_CODE (type2) == TYPE_CODE_INT)
580
    {
581
      struct type *tmp = type1;
582
      type1 = tmp;
583
      tmp = type2;
584
      inval1 = arg2;
585
      inval2 = arg1;
586
    }
587
  else
588
    {
589
      inval1 = arg1;
590
      inval2 = arg2;
591
    }
592
 
593
  /* Now process the input values. */
594
 
595
  if (TYPE_CODE (type1) == TYPE_CODE_INT)
596
    {
597
      /* We have a repeat count.  Validate the second value and then
598
         construct a value repeated that many times. */
599
      if (TYPE_CODE (type2) == TYPE_CODE_STRING
600
          || TYPE_CODE (type2) == TYPE_CODE_CHAR)
601
        {
602
          count = longest_to_int (value_as_long (inval1));
603
          inval2len = TYPE_LENGTH (type2);
604
          ptr = (char *) alloca (count * inval2len);
605
          if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
606
            {
607
              inchar = (char) unpack_long (type2,
608
                                           VALUE_CONTENTS (inval2));
609
              for (idx = 0; idx < count; idx++)
610
                {
611
                  *(ptr + idx) = inchar;
612
                }
613
            }
614
          else
615
            {
616
              for (idx = 0; idx < count; idx++)
617
                {
618
                  memcpy (ptr + (idx * inval2len), VALUE_CONTENTS (inval2),
619
                          inval2len);
620
                }
621
            }
622
          outval = value_string (ptr, count * inval2len);
623
        }
624
      else if (TYPE_CODE (type2) == TYPE_CODE_BITSTRING
625
               || TYPE_CODE (type2) == TYPE_CODE_BOOL)
626
        {
627
          error ("unimplemented support for bitstring/boolean repeats");
628
        }
629
      else
630
        {
631
          error ("can't repeat values of that type");
632
        }
633
    }
634
  else if (TYPE_CODE (type1) == TYPE_CODE_STRING
635
           || TYPE_CODE (type1) == TYPE_CODE_CHAR)
636
    {
637
      /* We have two character strings to concatenate. */
638
      if (TYPE_CODE (type2) != TYPE_CODE_STRING
639
          && TYPE_CODE (type2) != TYPE_CODE_CHAR)
640
        {
641
          error ("Strings can only be concatenated with other strings.");
642
        }
643
      inval1len = TYPE_LENGTH (type1);
644
      inval2len = TYPE_LENGTH (type2);
645
      ptr = (char *) alloca (inval1len + inval2len);
646
      if (TYPE_CODE (type1) == TYPE_CODE_CHAR)
647
        {
648
          *ptr = (char) unpack_long (type1, VALUE_CONTENTS (inval1));
649
        }
650
      else
651
        {
652
          memcpy (ptr, VALUE_CONTENTS (inval1), inval1len);
653
        }
654
      if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
655
        {
656
          *(ptr + inval1len) =
657
            (char) unpack_long (type2, VALUE_CONTENTS (inval2));
658
        }
659
      else
660
        {
661
          memcpy (ptr + inval1len, VALUE_CONTENTS (inval2), inval2len);
662
        }
663
      outval = value_string (ptr, inval1len + inval2len);
664
    }
665
  else if (TYPE_CODE (type1) == TYPE_CODE_BITSTRING
666
           || TYPE_CODE (type1) == TYPE_CODE_BOOL)
667
    {
668
      /* We have two bitstrings to concatenate. */
669
      if (TYPE_CODE (type2) != TYPE_CODE_BITSTRING
670
          && TYPE_CODE (type2) != TYPE_CODE_BOOL)
671
        {
672
          error ("Bitstrings or booleans can only be concatenated with other bitstrings or booleans.");
673
        }
674
      error ("unimplemented support for bitstring/boolean concatenation.");
675
    }
676
  else
677
    {
678
      /* We don't know how to concatenate these operands. */
679
      error ("illegal operands for concatenation.");
680
    }
681
  return (outval);
682
}
683
 
684
 
685
 
686
/* Perform a binary operation on two operands which have reasonable
687
   representations as integers or floats.  This includes booleans,
688
   characters, integers, or floats.
689
   Does not support addition and subtraction on pointers;
690
   use value_add or value_sub if you want to handle those possibilities.  */
691
 
692
value_ptr
693
value_binop (value_ptr arg1, value_ptr arg2, enum exp_opcode op)
694
{
695
  register value_ptr val;
696
  struct type *type1, *type2;
697
 
698
  COERCE_REF (arg1);
699
  COERCE_REF (arg2);
700
  COERCE_ENUM (arg1);
701
  COERCE_ENUM (arg2);
702
  type1 = check_typedef (VALUE_TYPE (arg1));
703
  type2 = check_typedef (VALUE_TYPE (arg2));
704
 
705
  if ((TYPE_CODE (type1) != TYPE_CODE_FLT
706
       && TYPE_CODE (type1) != TYPE_CODE_CHAR
707
       && TYPE_CODE (type1) != TYPE_CODE_INT
708
       && TYPE_CODE (type1) != TYPE_CODE_BOOL
709
       && TYPE_CODE (type1) != TYPE_CODE_RANGE)
710
      ||
711
      (TYPE_CODE (type2) != TYPE_CODE_FLT
712
       && TYPE_CODE (type2) != TYPE_CODE_CHAR
713
       && TYPE_CODE (type2) != TYPE_CODE_INT
714
       && TYPE_CODE (type2) != TYPE_CODE_BOOL
715
       && TYPE_CODE (type2) != TYPE_CODE_RANGE))
716
    error ("Argument to arithmetic operation not a number or boolean.");
717
 
718
  if (TYPE_CODE (type1) == TYPE_CODE_FLT
719
      ||
720
      TYPE_CODE (type2) == TYPE_CODE_FLT)
721
    {
722
      /* FIXME-if-picky-about-floating-accuracy: Should be doing this
723
         in target format.  real.c in GCC probably has the necessary
724
         code.  */
725
      DOUBLEST v1, v2, v = 0;
726
      v1 = value_as_double (arg1);
727
      v2 = value_as_double (arg2);
728
      switch (op)
729
        {
730
        case BINOP_ADD:
731
          v = v1 + v2;
732
          break;
733
 
734
        case BINOP_SUB:
735
          v = v1 - v2;
736
          break;
737
 
738
        case BINOP_MUL:
739
          v = v1 * v2;
740
          break;
741
 
742
        case BINOP_DIV:
743
          v = v1 / v2;
744
          break;
745
 
746
        case BINOP_EXP:
747
          v = pow (v1, v2);
748
          if (errno)
749
            error ("Cannot perform exponentiation: %s", strerror (errno));
750
          break;
751
 
752
        default:
753
          error ("Integer-only operation on floating point number.");
754
        }
755
 
756
      /* If either arg was long double, make sure that value is also long
757
         double.  */
758
 
759
      if (TYPE_LENGTH (type1) * 8 > TARGET_DOUBLE_BIT
760
          || TYPE_LENGTH (type2) * 8 > TARGET_DOUBLE_BIT)
761
        val = allocate_value (builtin_type_long_double);
762
      else
763
        val = allocate_value (builtin_type_double);
764
 
765
      store_floating (VALUE_CONTENTS_RAW (val), TYPE_LENGTH (VALUE_TYPE (val)),
766
                      v);
767
    }
768
  else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
769
           &&
770
           TYPE_CODE (type2) == TYPE_CODE_BOOL)
771
    {
772
      LONGEST v1, v2, v = 0;
773
      v1 = value_as_long (arg1);
774
      v2 = value_as_long (arg2);
775
 
776
      switch (op)
777
        {
778
        case BINOP_BITWISE_AND:
779
          v = v1 & v2;
780
          break;
781
 
782
        case BINOP_BITWISE_IOR:
783
          v = v1 | v2;
784
          break;
785
 
786
        case BINOP_BITWISE_XOR:
787
          v = v1 ^ v2;
788
          break;
789
 
790
        case BINOP_EQUAL:
791
          v = v1 == v2;
792
          break;
793
 
794
        case BINOP_NOTEQUAL:
795
          v = v1 != v2;
796
          break;
797
 
798
        default:
799
          error ("Invalid operation on booleans.");
800
        }
801
 
802
      val = allocate_value (type1);
803
      store_signed_integer (VALUE_CONTENTS_RAW (val),
804
                            TYPE_LENGTH (type1),
805
                            v);
806
    }
807
  else
808
    /* Integral operations here.  */
809
    /* FIXME:  Also mixed integral/booleans, with result an integer. */
810
    /* FIXME: This implements ANSI C rules (also correct for C++).
811
       What about FORTRAN and chill?  */
812
    {
813
      unsigned int promoted_len1 = TYPE_LENGTH (type1);
814
      unsigned int promoted_len2 = TYPE_LENGTH (type2);
815
      int is_unsigned1 = TYPE_UNSIGNED (type1);
816
      int is_unsigned2 = TYPE_UNSIGNED (type2);
817
      unsigned int result_len;
818
      int unsigned_operation;
819
 
820
      /* Determine type length and signedness after promotion for
821
         both operands.  */
822
      if (promoted_len1 < TYPE_LENGTH (builtin_type_int))
823
        {
824
          is_unsigned1 = 0;
825
          promoted_len1 = TYPE_LENGTH (builtin_type_int);
826
        }
827
      if (promoted_len2 < TYPE_LENGTH (builtin_type_int))
828
        {
829
          is_unsigned2 = 0;
830
          promoted_len2 = TYPE_LENGTH (builtin_type_int);
831
        }
832
 
833
      /* Determine type length of the result, and if the operation should
834
         be done unsigned.
835
         Use the signedness of the operand with the greater length.
836
         If both operands are of equal length, use unsigned operation
837
         if one of the operands is unsigned.  */
838
      if (promoted_len1 > promoted_len2)
839
        {
840
          unsigned_operation = is_unsigned1;
841
          result_len = promoted_len1;
842
        }
843
      else if (promoted_len2 > promoted_len1)
844
        {
845
          unsigned_operation = is_unsigned2;
846
          result_len = promoted_len2;
847
        }
848
      else
849
        {
850
          unsigned_operation = is_unsigned1 || is_unsigned2;
851
          result_len = promoted_len1;
852
        }
853
 
854
      if (unsigned_operation)
855
        {
856
          ULONGEST v1, v2, v = 0;
857
          v1 = (ULONGEST) value_as_long (arg1);
858
          v2 = (ULONGEST) value_as_long (arg2);
859
 
860
          /* Truncate values to the type length of the result.  */
861
          if (result_len < sizeof (ULONGEST))
862
            {
863
              v1 &= ((LONGEST) 1 << HOST_CHAR_BIT * result_len) - 1;
864
              v2 &= ((LONGEST) 1 << HOST_CHAR_BIT * result_len) - 1;
865
            }
866
 
867
          switch (op)
868
            {
869
            case BINOP_ADD:
870
              v = v1 + v2;
871
              break;
872
 
873
            case BINOP_SUB:
874
              v = v1 - v2;
875
              break;
876
 
877
            case BINOP_MUL:
878
              v = v1 * v2;
879
              break;
880
 
881
            case BINOP_DIV:
882
              v = v1 / v2;
883
              break;
884
 
885
            case BINOP_EXP:
886
              v = pow (v1, v2);
887
              if (errno)
888
                error ("Cannot perform exponentiation: %s", strerror (errno));
889
              break;
890
 
891
            case BINOP_REM:
892
              v = v1 % v2;
893
              break;
894
 
895
            case BINOP_MOD:
896
              /* Knuth 1.2.4, integer only.  Note that unlike the C '%' op,
897
                 v1 mod 0 has a defined value, v1. */
898
              /* Chill specifies that v2 must be > 0, so check for that. */
899
              if (current_language->la_language == language_chill
900
                  && value_as_long (arg2) <= 0)
901
                {
902
                  error ("Second operand of MOD must be greater than zero.");
903
                }
904
              if (v2 == 0)
905
                {
906
                  v = v1;
907
                }
908
              else
909
                {
910
                  v = v1 / v2;
911
                  /* Note floor(v1/v2) == v1/v2 for unsigned. */
912
                  v = v1 - (v2 * v);
913
                }
914
              break;
915
 
916
            case BINOP_LSH:
917
              v = v1 << v2;
918
              break;
919
 
920
            case BINOP_RSH:
921
              v = v1 >> v2;
922
              break;
923
 
924
            case BINOP_BITWISE_AND:
925
              v = v1 & v2;
926
              break;
927
 
928
            case BINOP_BITWISE_IOR:
929
              v = v1 | v2;
930
              break;
931
 
932
            case BINOP_BITWISE_XOR:
933
              v = v1 ^ v2;
934
              break;
935
 
936
            case BINOP_LOGICAL_AND:
937
              v = v1 && v2;
938
              break;
939
 
940
            case BINOP_LOGICAL_OR:
941
              v = v1 || v2;
942
              break;
943
 
944
            case BINOP_MIN:
945
              v = v1 < v2 ? v1 : v2;
946
              break;
947
 
948
            case BINOP_MAX:
949
              v = v1 > v2 ? v1 : v2;
950
              break;
951
 
952
            case BINOP_EQUAL:
953
              v = v1 == v2;
954
              break;
955
 
956
            case BINOP_NOTEQUAL:
957
              v = v1 != v2;
958
              break;
959
 
960
            case BINOP_LESS:
961
              v = v1 < v2;
962
              break;
963
 
964
            default:
965
              error ("Invalid binary operation on numbers.");
966
            }
967
 
968
          /* This is a kludge to get around the fact that we don't
969
             know how to determine the result type from the types of
970
             the operands.  (I'm not really sure how much we feel the
971
             need to duplicate the exact rules of the current
972
             language.  They can get really hairy.  But not to do so
973
             makes it hard to document just what we *do* do).  */
974
 
975
          /* Can't just call init_type because we wouldn't know what
976
             name to give the type.  */
977
          val = allocate_value
978
            (result_len > TARGET_LONG_BIT / HOST_CHAR_BIT
979
             ? builtin_type_unsigned_long_long
980
             : builtin_type_unsigned_long);
981
          store_unsigned_integer (VALUE_CONTENTS_RAW (val),
982
                                  TYPE_LENGTH (VALUE_TYPE (val)),
983
                                  v);
984
        }
985
      else
986
        {
987
          LONGEST v1, v2, v = 0;
988
          v1 = value_as_long (arg1);
989
          v2 = value_as_long (arg2);
990
 
991
          switch (op)
992
            {
993
            case BINOP_ADD:
994
              v = v1 + v2;
995
              break;
996
 
997
            case BINOP_SUB:
998
              v = v1 - v2;
999
              break;
1000
 
1001
            case BINOP_MUL:
1002
              v = v1 * v2;
1003
              break;
1004
 
1005
            case BINOP_DIV:
1006
              v = v1 / v2;
1007
              break;
1008
 
1009
            case BINOP_EXP:
1010
              v = pow (v1, v2);
1011
              if (errno)
1012
                error ("Cannot perform exponentiation: %s", strerror (errno));
1013
              break;
1014
 
1015
            case BINOP_REM:
1016
              v = v1 % v2;
1017
              break;
1018
 
1019
            case BINOP_MOD:
1020
              /* Knuth 1.2.4, integer only.  Note that unlike the C '%' op,
1021
                 X mod 0 has a defined value, X. */
1022
              /* Chill specifies that v2 must be > 0, so check for that. */
1023
              if (current_language->la_language == language_chill
1024
                  && v2 <= 0)
1025
                {
1026
                  error ("Second operand of MOD must be greater than zero.");
1027
                }
1028
              if (v2 == 0)
1029
                {
1030
                  v = v1;
1031
                }
1032
              else
1033
                {
1034
                  v = v1 / v2;
1035
                  /* Compute floor. */
1036
                  if (TRUNCATION_TOWARDS_ZERO && (v < 0) && ((v1 % v2) != 0))
1037
                    {
1038
                      v--;
1039
                    }
1040
                  v = v1 - (v2 * v);
1041
                }
1042
              break;
1043
 
1044
            case BINOP_LSH:
1045
              v = v1 << v2;
1046
              break;
1047
 
1048
            case BINOP_RSH:
1049
              v = v1 >> v2;
1050
              break;
1051
 
1052
            case BINOP_BITWISE_AND:
1053
              v = v1 & v2;
1054
              break;
1055
 
1056
            case BINOP_BITWISE_IOR:
1057
              v = v1 | v2;
1058
              break;
1059
 
1060
            case BINOP_BITWISE_XOR:
1061
              v = v1 ^ v2;
1062
              break;
1063
 
1064
            case BINOP_LOGICAL_AND:
1065
              v = v1 && v2;
1066
              break;
1067
 
1068
            case BINOP_LOGICAL_OR:
1069
              v = v1 || v2;
1070
              break;
1071
 
1072
            case BINOP_MIN:
1073
              v = v1 < v2 ? v1 : v2;
1074
              break;
1075
 
1076
            case BINOP_MAX:
1077
              v = v1 > v2 ? v1 : v2;
1078
              break;
1079
 
1080
            case BINOP_EQUAL:
1081
              v = v1 == v2;
1082
              break;
1083
 
1084
            case BINOP_LESS:
1085
              v = v1 < v2;
1086
              break;
1087
 
1088
            default:
1089
              error ("Invalid binary operation on numbers.");
1090
            }
1091
 
1092
          /* This is a kludge to get around the fact that we don't
1093
             know how to determine the result type from the types of
1094
             the operands.  (I'm not really sure how much we feel the
1095
             need to duplicate the exact rules of the current
1096
             language.  They can get really hairy.  But not to do so
1097
             makes it hard to document just what we *do* do).  */
1098
 
1099
          /* Can't just call init_type because we wouldn't know what
1100
             name to give the type.  */
1101
          val = allocate_value
1102
            (result_len > TARGET_LONG_BIT / HOST_CHAR_BIT
1103
             ? builtin_type_long_long
1104
             : builtin_type_long);
1105
          store_signed_integer (VALUE_CONTENTS_RAW (val),
1106
                                TYPE_LENGTH (VALUE_TYPE (val)),
1107
                                v);
1108
        }
1109
    }
1110
 
1111
  return val;
1112
}
1113
 
1114
/* Simulate the C operator ! -- return 1 if ARG1 contains zero.  */
1115
 
1116
int
1117
value_logical_not (value_ptr arg1)
1118
{
1119
  register int len;
1120
  register char *p;
1121
  struct type *type1;
1122
 
1123
  COERCE_NUMBER (arg1);
1124
  type1 = check_typedef (VALUE_TYPE (arg1));
1125
 
1126
  if (TYPE_CODE (type1) == TYPE_CODE_FLT)
1127
    return 0 == value_as_double (arg1);
1128
 
1129
  len = TYPE_LENGTH (type1);
1130
  p = VALUE_CONTENTS (arg1);
1131
 
1132
  while (--len >= 0)
1133
    {
1134
      if (*p++)
1135
        break;
1136
    }
1137
 
1138
  return len < 0;
1139
}
1140
 
1141
/* Perform a comparison on two string values (whose content are not
1142
   necessarily null terminated) based on their length */
1143
 
1144
static int
1145
value_strcmp (register value_ptr arg1, register value_ptr arg2)
1146
{
1147
  int len1 = TYPE_LENGTH (VALUE_TYPE (arg1));
1148
  int len2 = TYPE_LENGTH (VALUE_TYPE (arg2));
1149
  char *s1 = VALUE_CONTENTS (arg1);
1150
  char *s2 = VALUE_CONTENTS (arg2);
1151
  int i, len = len1 < len2 ? len1 : len2;
1152
 
1153
  for (i = 0; i < len; i++)
1154
    {
1155
      if (s1[i] < s2[i])
1156
        return -1;
1157
      else if (s1[i] > s2[i])
1158
        return 1;
1159
      else
1160
        continue;
1161
    }
1162
 
1163
  if (len1 < len2)
1164
    return -1;
1165
  else if (len1 > len2)
1166
    return 1;
1167
  else
1168
    return 0;
1169
}
1170
 
1171
/* Simulate the C operator == by returning a 1
1172
   iff ARG1 and ARG2 have equal contents.  */
1173
 
1174
int
1175
value_equal (register value_ptr arg1, register value_ptr arg2)
1176
{
1177
  register int len;
1178
  register char *p1, *p2;
1179
  struct type *type1, *type2;
1180
  enum type_code code1;
1181
  enum type_code code2;
1182
 
1183
  COERCE_NUMBER (arg1);
1184
  COERCE_NUMBER (arg2);
1185
 
1186
  type1 = check_typedef (VALUE_TYPE (arg1));
1187
  type2 = check_typedef (VALUE_TYPE (arg2));
1188
  code1 = TYPE_CODE (type1);
1189
  code2 = TYPE_CODE (type2);
1190
 
1191
  if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL) &&
1192
      (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
1193
    return longest_to_int (value_as_long (value_binop (arg1, arg2,
1194
                                                       BINOP_EQUAL)));
1195
  else if ((code1 == TYPE_CODE_FLT || code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL)
1196
           && (code2 == TYPE_CODE_FLT || code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
1197
    return value_as_double (arg1) == value_as_double (arg2);
1198
 
1199
  /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1200
     is bigger.  */
1201
  else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
1202
    return value_as_pointer (arg1) == (CORE_ADDR) value_as_long (arg2);
1203
  else if (code2 == TYPE_CODE_PTR && (code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL))
1204
    return (CORE_ADDR) value_as_long (arg1) == value_as_pointer (arg2);
1205
 
1206
  else if (code1 == code2
1207
           && ((len = (int) TYPE_LENGTH (type1))
1208
               == (int) TYPE_LENGTH (type2)))
1209
    {
1210
      p1 = VALUE_CONTENTS (arg1);
1211
      p2 = VALUE_CONTENTS (arg2);
1212
      while (--len >= 0)
1213
        {
1214
          if (*p1++ != *p2++)
1215
            break;
1216
        }
1217
      return len < 0;
1218
    }
1219
  else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
1220
    {
1221
      return value_strcmp (arg1, arg2) == 0;
1222
    }
1223
  else
1224
    {
1225
      error ("Invalid type combination in equality test.");
1226
      return 0;                  /* For lint -- never reached */
1227
    }
1228
}
1229
 
1230
/* Simulate the C operator < by returning 1
1231
   iff ARG1's contents are less than ARG2's.  */
1232
 
1233
int
1234
value_less (register value_ptr arg1, register value_ptr arg2)
1235
{
1236
  register enum type_code code1;
1237
  register enum type_code code2;
1238
  struct type *type1, *type2;
1239
 
1240
  COERCE_NUMBER (arg1);
1241
  COERCE_NUMBER (arg2);
1242
 
1243
  type1 = check_typedef (VALUE_TYPE (arg1));
1244
  type2 = check_typedef (VALUE_TYPE (arg2));
1245
  code1 = TYPE_CODE (type1);
1246
  code2 = TYPE_CODE (type2);
1247
 
1248
  if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL) &&
1249
      (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
1250
    return longest_to_int (value_as_long (value_binop (arg1, arg2,
1251
                                                       BINOP_LESS)));
1252
  else if ((code1 == TYPE_CODE_FLT || code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL)
1253
           && (code2 == TYPE_CODE_FLT || code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
1254
    return value_as_double (arg1) < value_as_double (arg2);
1255
  else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
1256
    return value_as_pointer (arg1) < value_as_pointer (arg2);
1257
 
1258
  /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1259
     is bigger.  */
1260
  else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
1261
    return value_as_pointer (arg1) < (CORE_ADDR) value_as_long (arg2);
1262
  else if (code2 == TYPE_CODE_PTR && (code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL))
1263
    return (CORE_ADDR) value_as_long (arg1) < value_as_pointer (arg2);
1264
  else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
1265
    return value_strcmp (arg1, arg2) < 0;
1266
  else
1267
    {
1268
      error ("Invalid type combination in ordering comparison.");
1269
      return 0;
1270
    }
1271
}
1272
 
1273
/* The unary operators - and ~.  Both free the argument ARG1.  */
1274
 
1275
value_ptr
1276
value_neg (register value_ptr arg1)
1277
{
1278
  register struct type *type;
1279
  register struct type *result_type = VALUE_TYPE (arg1);
1280
 
1281
  COERCE_REF (arg1);
1282
  COERCE_ENUM (arg1);
1283
 
1284
  type = check_typedef (VALUE_TYPE (arg1));
1285
 
1286
  if (TYPE_CODE (type) == TYPE_CODE_FLT)
1287
    return value_from_double (result_type, -value_as_double (arg1));
1288
  else if (TYPE_CODE (type) == TYPE_CODE_INT || TYPE_CODE (type) == TYPE_CODE_BOOL)
1289
    {
1290
      /* Perform integral promotion for ANSI C/C++.
1291
         FIXME: What about FORTRAN and chill ?  */
1292
      if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
1293
        result_type = builtin_type_int;
1294
 
1295
      return value_from_longest (result_type, -value_as_long (arg1));
1296
    }
1297
  else
1298
    {
1299
      error ("Argument to negate operation not a number.");
1300
      return 0;                  /* For lint -- never reached */
1301
    }
1302
}
1303
 
1304
value_ptr
1305
value_complement (register value_ptr arg1)
1306
{
1307
  register struct type *type;
1308
  register struct type *result_type = VALUE_TYPE (arg1);
1309
  int typecode;
1310
 
1311
  COERCE_REF (arg1);
1312
  COERCE_ENUM (arg1);
1313
 
1314
  type = check_typedef (VALUE_TYPE (arg1));
1315
 
1316
  typecode = TYPE_CODE (type);
1317
  if ((typecode != TYPE_CODE_INT) && (typecode != TYPE_CODE_BOOL))
1318
    error ("Argument to complement operation not an integer or boolean.");
1319
 
1320
  /* Perform integral promotion for ANSI C/C++.
1321
     FIXME: What about FORTRAN ?  */
1322
  if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
1323
    result_type = builtin_type_int;
1324
 
1325
  return value_from_longest (result_type, ~value_as_long (arg1));
1326
}
1327
 
1328
/* The INDEX'th bit of SET value whose VALUE_TYPE is TYPE,
1329
   and whose VALUE_CONTENTS is valaddr.
1330
   Return -1 if out of range, -2 other error. */
1331
 
1332
int
1333
value_bit_index (struct type *type, char *valaddr, int index)
1334
{
1335
  LONGEST low_bound, high_bound;
1336
  LONGEST word;
1337
  unsigned rel_index;
1338
  struct type *range = TYPE_FIELD_TYPE (type, 0);
1339
  if (get_discrete_bounds (range, &low_bound, &high_bound) < 0)
1340
    return -2;
1341
  if (index < low_bound || index > high_bound)
1342
    return -1;
1343
  rel_index = index - low_bound;
1344
  word = unpack_long (builtin_type_unsigned_char,
1345
                      valaddr + (rel_index / TARGET_CHAR_BIT));
1346
  rel_index %= TARGET_CHAR_BIT;
1347
  if (BITS_BIG_ENDIAN)
1348
    rel_index = TARGET_CHAR_BIT - 1 - rel_index;
1349
  return (word >> rel_index) & 1;
1350
}
1351
 
1352
value_ptr
1353
value_in (value_ptr element, value_ptr set)
1354
{
1355
  int member;
1356
  struct type *settype = check_typedef (VALUE_TYPE (set));
1357
  struct type *eltype = check_typedef (VALUE_TYPE (element));
1358
  if (TYPE_CODE (eltype) == TYPE_CODE_RANGE)
1359
    eltype = TYPE_TARGET_TYPE (eltype);
1360
  if (TYPE_CODE (settype) != TYPE_CODE_SET)
1361
    error ("Second argument of 'IN' has wrong type");
1362
  if (TYPE_CODE (eltype) != TYPE_CODE_INT
1363
      && TYPE_CODE (eltype) != TYPE_CODE_CHAR
1364
      && TYPE_CODE (eltype) != TYPE_CODE_ENUM
1365
      && TYPE_CODE (eltype) != TYPE_CODE_BOOL)
1366
    error ("First argument of 'IN' has wrong type");
1367
  member = value_bit_index (settype, VALUE_CONTENTS (set),
1368
                            value_as_long (element));
1369
  if (member < 0)
1370
    error ("First argument of 'IN' not in range");
1371
  return value_from_longest (LA_BOOL_TYPE, member);
1372
}
1373
 
1374
void
1375
_initialize_valarith (void)
1376
{
1377
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.