1 /* Simulate storage of variables into target memory.
2 Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012
3 Free Software Foundation, Inc.
4 Contributed by Paul Thomas and Brooks Moses
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
30 #include "constructor.h"
32 #include "trans-const.h"
33 #include "trans-types.h"
34 #include "target-memory.h"
36 /* --------------------------------------------------------------- */
37 /* Calculate the size of an expression. */
40 size_array (gfc_expr
*e
)
43 gfc_constructor
*c
= gfc_constructor_first (e
->value
.constructor
);
44 size_t elt_size
= gfc_target_expr_size (c
->expr
);
46 gfc_array_size (e
, &array_size
);
47 return (size_t)mpz_get_ui (array_size
) * elt_size
;
51 size_integer (int kind
)
53 return GET_MODE_SIZE (TYPE_MODE (gfc_get_int_type (kind
)));;
60 return GET_MODE_SIZE (TYPE_MODE (gfc_get_real_type (kind
)));;
65 size_complex (int kind
)
67 return 2 * size_float (kind
);
72 size_logical (int kind
)
74 return GET_MODE_SIZE (TYPE_MODE (gfc_get_logical_type (kind
)));;
79 size_character (int length
, int kind
)
81 int i
= gfc_validate_kind (BT_CHARACTER
, kind
, false);
82 return length
* gfc_character_kinds
[i
].bit_size
/ 8;
87 gfc_target_expr_size (gfc_expr
*e
)
91 gcc_assert (e
!= NULL
);
93 if (e
->expr_type
== EXPR_ARRAY
)
94 return size_array (e
);
99 return size_integer (e
->ts
.kind
);
101 return size_float (e
->ts
.kind
);
103 return size_complex (e
->ts
.kind
);
105 return size_logical (e
->ts
.kind
);
107 if (e
->expr_type
== EXPR_CONSTANT
)
108 return size_character (e
->value
.character
.length
, e
->ts
.kind
);
109 else if (e
->ts
.u
.cl
!= NULL
&& e
->ts
.u
.cl
->length
!= NULL
110 && e
->ts
.u
.cl
->length
->expr_type
== EXPR_CONSTANT
111 && e
->ts
.u
.cl
->length
->ts
.type
== BT_INTEGER
)
115 gfc_extract_int (e
->ts
.u
.cl
->length
, &length
);
116 return size_character (length
, e
->ts
.kind
);
122 return e
->representation
.length
;
126 /* Determine type size without clobbering the typespec for ISO C
131 type
= gfc_typenode_for_spec (&ts
);
132 size
= int_size_in_bytes (type
);
133 gcc_assert (size
>= 0);
137 gfc_internal_error ("Invalid expression in gfc_target_expr_size.");
143 /* The encode_* functions export a value into a buffer, and
144 return the number of bytes of the buffer that have been
147 static unsigned HOST_WIDE_INT
148 encode_array (gfc_expr
*expr
, unsigned char *buffer
, size_t buffer_size
)
154 gfc_constructor_base ctor
= expr
->value
.constructor
;
156 gfc_array_size (expr
, &array_size
);
157 for (i
= 0; i
< (int)mpz_get_ui (array_size
); i
++)
159 ptr
+= gfc_target_encode_expr (gfc_constructor_lookup_expr (ctor
, i
),
160 &buffer
[ptr
], buffer_size
- ptr
);
163 mpz_clear (array_size
);
169 encode_integer (int kind
, mpz_t integer
, unsigned char *buffer
,
172 return native_encode_expr (gfc_conv_mpz_to_tree (integer
, kind
),
173 buffer
, buffer_size
);
178 encode_float (int kind
, mpfr_t real
, unsigned char *buffer
, size_t buffer_size
)
180 return native_encode_expr (gfc_conv_mpfr_to_tree (real
, kind
, 0), buffer
,
186 encode_complex (int kind
, mpc_t cmplx
,
187 unsigned char *buffer
, size_t buffer_size
)
190 size
= encode_float (kind
, mpc_realref (cmplx
), &buffer
[0], buffer_size
);
191 size
+= encode_float (kind
, mpc_imagref (cmplx
),
192 &buffer
[size
], buffer_size
- size
);
198 encode_logical (int kind
, int logical
, unsigned char *buffer
, size_t buffer_size
)
200 return native_encode_expr (build_int_cst (gfc_get_logical_type (kind
),
202 buffer
, buffer_size
);
207 gfc_encode_character (int kind
, int length
, const gfc_char_t
*string
,
208 unsigned char *buffer
, size_t buffer_size
)
210 size_t elsize
= size_character (1, kind
);
211 tree type
= gfc_get_char_type (kind
);
214 gcc_assert (buffer_size
>= size_character (length
, kind
));
216 for (i
= 0; i
< length
; i
++)
217 native_encode_expr (build_int_cst (type
, string
[i
]), &buffer
[i
*elsize
],
224 static unsigned HOST_WIDE_INT
225 encode_derived (gfc_expr
*source
, unsigned char *buffer
, size_t buffer_size
)
233 type
= gfc_typenode_for_spec (&source
->ts
);
235 for (c
= gfc_constructor_first (source
->value
.constructor
),
236 cmp
= source
->ts
.u
.derived
->components
;
238 c
= gfc_constructor_next (c
), cmp
= cmp
->next
)
243 ptr
= TREE_INT_CST_LOW(DECL_FIELD_OFFSET(cmp
->backend_decl
))
244 + TREE_INT_CST_LOW(DECL_FIELD_BIT_OFFSET(cmp
->backend_decl
))/8;
246 if (c
->expr
->expr_type
== EXPR_NULL
)
248 size
= int_size_in_bytes (TREE_TYPE (cmp
->backend_decl
));
249 gcc_assert (size
>= 0);
250 memset (&buffer
[ptr
], 0, size
);
253 gfc_target_encode_expr (c
->expr
, &buffer
[ptr
],
257 size
= int_size_in_bytes (type
);
258 gcc_assert (size
>= 0);
263 /* Write a constant expression in binary form to a buffer. */
264 unsigned HOST_WIDE_INT
265 gfc_target_encode_expr (gfc_expr
*source
, unsigned char *buffer
,
271 if (source
->expr_type
== EXPR_ARRAY
)
272 return encode_array (source
, buffer
, buffer_size
);
274 gcc_assert (source
->expr_type
== EXPR_CONSTANT
275 || source
->expr_type
== EXPR_STRUCTURE
276 || source
->expr_type
== EXPR_SUBSTRING
);
278 /* If we already have a target-memory representation, we use that rather
279 than recreating one. */
280 if (source
->representation
.string
)
282 memcpy (buffer
, source
->representation
.string
,
283 source
->representation
.length
);
284 return source
->representation
.length
;
287 switch (source
->ts
.type
)
290 return encode_integer (source
->ts
.kind
, source
->value
.integer
, buffer
,
293 return encode_float (source
->ts
.kind
, source
->value
.real
, buffer
,
296 return encode_complex (source
->ts
.kind
, source
->value
.complex,
297 buffer
, buffer_size
);
299 return encode_logical (source
->ts
.kind
, source
->value
.logical
, buffer
,
302 if (source
->expr_type
== EXPR_CONSTANT
|| source
->ref
== NULL
)
303 return gfc_encode_character (source
->ts
.kind
,
304 source
->value
.character
.length
,
305 source
->value
.character
.string
,
306 buffer
, buffer_size
);
311 gcc_assert (source
->expr_type
== EXPR_SUBSTRING
);
312 gfc_extract_int (source
->ref
->u
.ss
.start
, &start
);
313 gfc_extract_int (source
->ref
->u
.ss
.end
, &end
);
314 return gfc_encode_character (source
->ts
.kind
, MAX(end
- start
+ 1, 0),
315 &source
->value
.character
.string
[start
-1],
316 buffer
, buffer_size
);
320 return encode_derived (source
, buffer
, buffer_size
);
322 gfc_internal_error ("Invalid expression in gfc_target_encode_expr.");
329 interpret_array (unsigned char *buffer
, size_t buffer_size
, gfc_expr
*result
)
331 gfc_constructor_base base
= NULL
;
336 /* Calculate array size from its shape and rank. */
337 gcc_assert (result
->rank
> 0 && result
->shape
);
339 for (i
= 0; i
< result
->rank
; i
++)
340 array_size
*= (int)mpz_get_ui (result
->shape
[i
]);
342 /* Iterate over array elements, producing constructors. */
343 for (i
= 0; i
< array_size
; i
++)
345 gfc_expr
*e
= gfc_get_constant_expr (result
->ts
.type
, result
->ts
.kind
,
349 if (e
->ts
.type
== BT_CHARACTER
)
350 e
->value
.character
.length
= result
->value
.character
.length
;
352 gfc_constructor_append_expr (&base
, e
, &result
->where
);
354 ptr
+= gfc_target_interpret_expr (&buffer
[ptr
], buffer_size
- ptr
, e
,
358 result
->value
.constructor
= base
;
364 gfc_interpret_integer (int kind
, unsigned char *buffer
, size_t buffer_size
,
368 gfc_conv_tree_to_mpz (integer
,
369 native_interpret_expr (gfc_get_int_type (kind
),
370 buffer
, buffer_size
));
371 return size_integer (kind
);
376 gfc_interpret_float (int kind
, unsigned char *buffer
, size_t buffer_size
,
379 gfc_set_model_kind (kind
);
381 gfc_conv_tree_to_mpfr (real
,
382 native_interpret_expr (gfc_get_real_type (kind
),
383 buffer
, buffer_size
));
385 return size_float (kind
);
390 gfc_interpret_complex (int kind
, unsigned char *buffer
, size_t buffer_size
,
394 size
= gfc_interpret_float (kind
, &buffer
[0], buffer_size
,
395 mpc_realref (complex));
396 size
+= gfc_interpret_float (kind
, &buffer
[size
], buffer_size
- size
,
397 mpc_imagref (complex));
403 gfc_interpret_logical (int kind
, unsigned char *buffer
, size_t buffer_size
,
406 tree t
= native_interpret_expr (gfc_get_logical_type (kind
), buffer
,
408 *logical
= tree_to_double_int (t
).is_zero () ? 0 : 1;
409 return size_logical (kind
);
414 gfc_interpret_character (unsigned char *buffer
, size_t buffer_size
,
419 if (result
->ts
.u
.cl
&& result
->ts
.u
.cl
->length
)
420 result
->value
.character
.length
=
421 (int) mpz_get_ui (result
->ts
.u
.cl
->length
->value
.integer
);
423 gcc_assert (buffer_size
>= size_character (result
->value
.character
.length
,
425 result
->value
.character
.string
=
426 gfc_get_wide_string (result
->value
.character
.length
+ 1);
428 if (result
->ts
.kind
== gfc_default_character_kind
)
429 for (i
= 0; i
< result
->value
.character
.length
; i
++)
430 result
->value
.character
.string
[i
] = (gfc_char_t
) buffer
[i
];
434 unsigned bytes
= size_character (1, result
->ts
.kind
);
436 gcc_assert (bytes
<= sizeof (unsigned long));
438 for (i
= 0; i
< result
->value
.character
.length
; i
++)
440 gfc_conv_tree_to_mpz (integer
,
441 native_interpret_expr (gfc_get_char_type (result
->ts
.kind
),
442 &buffer
[bytes
*i
], buffer_size
-bytes
*i
));
443 result
->value
.character
.string
[i
]
444 = (gfc_char_t
) mpz_get_ui (integer
);
450 result
->value
.character
.string
[result
->value
.character
.length
] = '\0';
452 return result
->value
.character
.length
;
457 gfc_interpret_derived (unsigned char *buffer
, size_t buffer_size
, gfc_expr
*result
)
463 /* The attributes of the derived type need to be bolted to the floor. */
464 result
->expr_type
= EXPR_STRUCTURE
;
466 cmp
= result
->ts
.u
.derived
->components
;
468 if (result
->ts
.u
.derived
->from_intmod
== INTMOD_ISO_C_BINDING
469 && (result
->ts
.u
.derived
->intmod_sym_id
== ISOCBINDING_PTR
470 || result
->ts
.u
.derived
->intmod_sym_id
== ISOCBINDING_FUNPTR
))
474 /* Needed as gfc_typenode_for_spec as gfc_typenode_for_spec
475 sets this to BT_INTEGER. */
476 result
->ts
.type
= BT_DERIVED
;
477 e
= gfc_get_constant_expr (cmp
->ts
.type
, cmp
->ts
.kind
, &result
->where
);
478 c
= gfc_constructor_append_expr (&result
->value
.constructor
, e
, NULL
);
479 c
->n
.component
= cmp
;
480 gfc_target_interpret_expr (buffer
, buffer_size
, e
, true);
482 return int_size_in_bytes (ptr_type_node
);
485 type
= gfc_typenode_for_spec (&result
->ts
);
487 /* Run through the derived type components. */
488 for (;cmp
; cmp
= cmp
->next
)
491 gfc_expr
*e
= gfc_get_constant_expr (cmp
->ts
.type
, cmp
->ts
.kind
,
495 /* Copy shape, if needed. */
496 if (cmp
->as
&& cmp
->as
->rank
)
500 e
->expr_type
= EXPR_ARRAY
;
501 e
->rank
= cmp
->as
->rank
;
503 e
->shape
= gfc_get_shape (e
->rank
);
504 for (n
= 0; n
< e
->rank
; n
++)
506 mpz_init_set_ui (e
->shape
[n
], 1);
507 mpz_add (e
->shape
[n
], e
->shape
[n
],
508 cmp
->as
->upper
[n
]->value
.integer
);
509 mpz_sub (e
->shape
[n
], e
->shape
[n
],
510 cmp
->as
->lower
[n
]->value
.integer
);
514 c
= gfc_constructor_append_expr (&result
->value
.constructor
, e
, NULL
);
516 /* The constructor points to the component. */
517 c
->n
.component
= cmp
;
519 /* Calculate the offset, which consists of the FIELD_OFFSET in
520 bytes, which appears in multiples of DECL_OFFSET_ALIGN-bit-sized,
521 and additional bits of FIELD_BIT_OFFSET. The code assumes that all
522 sizes of the components are multiples of BITS_PER_UNIT,
523 i.e. there are, e.g., no bit fields. */
525 gcc_assert (cmp
->backend_decl
);
526 ptr
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (cmp
->backend_decl
));
527 gcc_assert (ptr
% 8 == 0);
528 ptr
= ptr
/8 + TREE_INT_CST_LOW (DECL_FIELD_OFFSET (cmp
->backend_decl
));
530 gfc_target_interpret_expr (&buffer
[ptr
], buffer_size
- ptr
, e
, true);
533 return int_size_in_bytes (type
);
537 /* Read a binary buffer to a constant expression. */
539 gfc_target_interpret_expr (unsigned char *buffer
, size_t buffer_size
,
540 gfc_expr
*result
, bool convert_widechar
)
542 if (result
->expr_type
== EXPR_ARRAY
)
543 return interpret_array (buffer
, buffer_size
, result
);
545 switch (result
->ts
.type
)
548 result
->representation
.length
=
549 gfc_interpret_integer (result
->ts
.kind
, buffer
, buffer_size
,
550 result
->value
.integer
);
554 result
->representation
.length
=
555 gfc_interpret_float (result
->ts
.kind
, buffer
, buffer_size
,
560 result
->representation
.length
=
561 gfc_interpret_complex (result
->ts
.kind
, buffer
, buffer_size
,
562 result
->value
.complex);
566 result
->representation
.length
=
567 gfc_interpret_logical (result
->ts
.kind
, buffer
, buffer_size
,
568 &result
->value
.logical
);
572 result
->representation
.length
=
573 gfc_interpret_character (buffer
, buffer_size
, result
);
577 result
->ts
= CLASS_DATA (result
)->ts
;
580 result
->representation
.length
=
581 gfc_interpret_derived (buffer
, buffer_size
, result
);
582 gcc_assert (result
->representation
.length
>= 0);
586 gfc_internal_error ("Invalid expression in gfc_target_interpret_expr.");
590 if (result
->ts
.type
== BT_CHARACTER
&& convert_widechar
)
591 result
->representation
.string
592 = gfc_widechar_to_char (result
->value
.character
.string
,
593 result
->value
.character
.length
);
596 result
->representation
.string
=
597 XCNEWVEC (char, result
->representation
.length
+ 1);
598 memcpy (result
->representation
.string
, buffer
,
599 result
->representation
.length
);
600 result
->representation
.string
[result
->representation
.length
] = '\0';
603 return result
->representation
.length
;
607 /* --------------------------------------------------------------- */
608 /* Two functions used by trans-common.c to write overlapping
609 equivalence initializers to a buffer. This is added to the union
610 and the original initializers freed. */
613 /* Writes the values of a constant expression to a char buffer. If another
614 unequal initializer has already been written to the buffer, this is an
618 expr_to_char (gfc_expr
*e
, unsigned char *data
, unsigned char *chk
, size_t len
)
624 unsigned char *buffer
;
629 /* Take a derived type, one component at a time, using the offsets from the backend
631 if (e
->ts
.type
== BT_DERIVED
)
633 for (c
= gfc_constructor_first (e
->value
.constructor
),
634 cmp
= e
->ts
.u
.derived
->components
;
635 c
; c
= gfc_constructor_next (c
), cmp
= cmp
->next
)
637 gcc_assert (cmp
&& cmp
->backend_decl
);
640 ptr
= TREE_INT_CST_LOW(DECL_FIELD_OFFSET(cmp
->backend_decl
))
641 + TREE_INT_CST_LOW(DECL_FIELD_BIT_OFFSET(cmp
->backend_decl
))/8;
642 expr_to_char (c
->expr
, &data
[ptr
], &chk
[ptr
], len
);
647 /* Otherwise, use the target-memory machinery to write a bitwise image, appropriate
648 to the target, in a buffer and check off the initialized part of the buffer. */
649 len
= gfc_target_expr_size (e
);
650 buffer
= (unsigned char*)alloca (len
);
651 len
= gfc_target_encode_expr (e
, buffer
, len
);
653 for (i
= 0; i
< (int)len
; i
++)
655 if (chk
[i
] && (buffer
[i
] != data
[i
]))
657 gfc_error ("Overlapping unequal initializers in EQUIVALENCE "
664 memcpy (data
, buffer
, len
);
669 /* Writes the values from the equivalence initializers to a char* array
670 that will be written to the constructor to make the initializer for
671 the union declaration. */
674 gfc_merge_initializers (gfc_typespec ts
, gfc_expr
*e
, unsigned char *data
,
675 unsigned char *chk
, size_t length
)
680 switch (e
->expr_type
)
684 len
= expr_to_char (e
, &data
[0], &chk
[0], length
);
689 for (c
= gfc_constructor_first (e
->value
.constructor
);
690 c
; c
= gfc_constructor_next (c
))
692 size_t elt_size
= gfc_target_expr_size (c
->expr
);
694 if (mpz_cmp_si (c
->offset
, 0) != 0)
695 len
= elt_size
* (size_t)mpz_get_si (c
->offset
);
697 len
= len
+ gfc_merge_initializers (ts
, c
->expr
, &data
[len
],
698 &chk
[len
], length
- len
);
710 /* Transfer the bitpattern of a (integer) BOZ to real or complex variables.
711 When successful, no BOZ or nothing to do, true is returned. */
714 gfc_convert_boz (gfc_expr
*expr
, gfc_typespec
*ts
)
716 size_t buffer_size
, boz_bit_size
, ts_bit_size
;
718 unsigned char *buffer
;
723 gcc_assert (expr
->expr_type
== EXPR_CONSTANT
724 && expr
->ts
.type
== BT_INTEGER
);
726 /* Don't convert BOZ to logical, character, derived etc. */
727 if (ts
->type
== BT_REAL
)
729 buffer_size
= size_float (ts
->kind
);
730 ts_bit_size
= buffer_size
* 8;
732 else if (ts
->type
== BT_COMPLEX
)
734 buffer_size
= size_complex (ts
->kind
);
735 ts_bit_size
= buffer_size
* 8 / 2;
740 /* Convert BOZ to the smallest possible integer kind. */
741 boz_bit_size
= mpz_sizeinbase (expr
->value
.integer
, 2);
743 if (boz_bit_size
> ts_bit_size
)
745 gfc_error_now ("BOZ constant at %L is too large (%ld vs %ld bits)",
746 &expr
->where
, (long) boz_bit_size
, (long) ts_bit_size
);
750 for (index
= 0; gfc_integer_kinds
[index
].kind
!= 0; ++index
)
751 if ((unsigned) gfc_integer_kinds
[index
].bit_size
>= ts_bit_size
)
754 expr
->ts
.kind
= gfc_integer_kinds
[index
].kind
;
755 buffer_size
= MAX (buffer_size
, size_integer (expr
->ts
.kind
));
757 buffer
= (unsigned char*)alloca (buffer_size
);
758 encode_integer (expr
->ts
.kind
, expr
->value
.integer
, buffer
, buffer_size
);
759 mpz_clear (expr
->value
.integer
);
761 if (ts
->type
== BT_REAL
)
763 mpfr_init (expr
->value
.real
);
764 gfc_interpret_float (ts
->kind
, buffer
, buffer_size
, expr
->value
.real
);
768 mpc_init2 (expr
->value
.complex, mpfr_get_default_prec());
769 gfc_interpret_complex (ts
->kind
, buffer
, buffer_size
,
770 expr
->value
.complex);
773 expr
->ts
.type
= ts
->type
;
774 expr
->ts
.kind
= ts
->kind
;