===================================================================
@@ -1362,4 +1362,23 @@
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
+/* Return the size of a pointer. This function might be used when
+ ptr_type_node is not / is not known to be set up, like in the
+ preprocessor. */
+unsigned
+pointer_size (void)
+{
+ enum machine_mode
+ mode = targetm.addr_space.pointer_mode (ADDR_SPACE_GENERIC);
+
+ /* If the hook definition uses ptr_mode, and we are called before
+ init_emit_once, e.g. from the preprocessor, we might see VOIDmode. */
+ if (mode == VOIDmode)
+ {
+ gcc_assert (mode == ptr_mode);
+ return POINTER_SIZE;
+ }
+ return GET_MODE_BITSIZE (mode);
+}
+
#include "gt-targhooks.h"
===================================================================
@@ -106,7 +106,7 @@
define_builtin_macros_for_lp64 (cpp_reader *pfile)
{
if (TYPE_PRECISION (long_integer_type_node) == 64
- && POINTER_SIZE == 64
+ && pointer_size () == 64
&& TYPE_PRECISION (integer_type_node) == 32)
{
cpp_define (pfile, "_LP64");
@@ -164,9 +164,13 @@
: "__ORDER_LITTLE_ENDIAN__"));
/* ptr_type_node can't be used here since ptr_mode is only set when
- toplev calls backend_init which is not done with -E switch. */
+ toplev calls backend_init which is not done with -E switch.
+ In principle we could use
+ targetm.addr_space.pointer_mode (ADDR_SPACE_GENERIC), but we don't really
+ want the prepocessor to have to know about machine modes, and most
+ definitions of the hook also use ptr_mode. */
cpp_define_formatted (pfile, "__SIZEOF_POINTER__=%d",
- POINTER_SIZE / BITS_PER_UNIT);
+ pointer_size () / TYPE_PRECISION (char_type_node));
}
===================================================================
@@ -4944,7 +4944,7 @@
/* Create the built-in __null node. It is important that this is
not shared. */
null_node = make_node (INTEGER_CST);
- TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
+ TREE_TYPE (null_node) = c_common_type_for_size (pointer_size (), 0);
/* Since builtin_types isn't gc'ed, don't export these nodes. */
memset (builtin_types, 0, sizeof (builtin_types));
===================================================================
@@ -1793,7 +1793,7 @@
tree id_class = get_identifier("java.lang.Class");
/** Offset from start of virtual function table declaration
to where objects actually point at, following new g++ ABI. */
- tree dtable_start_offset = size_int (2 * POINTER_SIZE / BITS_PER_UNIT);
+ tree dtable_start_offset = size_int (2 * JAVA_POINTER_SIZE / BITS_PER_UNIT);
VEC(int, heap) *field_indexes;
tree first_real_field;
VEC(constructor_elt,gc) *v1 = NULL, *v2 = NULL;
@@ -2234,7 +2234,7 @@
DECL_INITIAL (decl) = cons;
/* Hash synchronization requires at least 64-bit alignment. */
- if (flag_hash_synchronization && POINTER_SIZE < 64)
+ if (flag_hash_synchronization && JAVA_POINTER_SIZE < 64)
DECL_ALIGN (decl) = 64;
if (flag_indirect_classes)
@@ -2831,12 +2831,13 @@
but doesn't have a JCR_SECTION_NAME. */
gcc_unreachable ();
#endif
- assemble_align (POINTER_SIZE);
+ assemble_align (JAVA_POINTER_SIZE);
FOR_EACH_VEC_ELT (tree, registered_class, i, klass)
{
t = build_fold_addr_expr (klass);
- output_constant (t, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE);
+ output_constant (t, JAVA_POINTER_SIZE / BITS_PER_UNIT,
+ JAVA_POINTER_SIZE);
}
}
else
===================================================================
@@ -606,8 +606,10 @@
/* This is not a java type, however tree-dfa requires a definition for
size_type_node. */
- size_type_node = make_unsigned_type (POINTER_SIZE);
+ size_type_node = make_unsigned_type (pointer_size ());
set_sizetype (size_type_node);
+ /* Henceforth, we can use TYPE_PRECISION (size_type_node) when we mean
+ pointer_size () for the current target, to avoid unnecessary overhead. */
/* Define these next since types below may used them. */
integer_type_node = java_type_for_size (INT_TYPE_SIZE, 0);
===================================================================
@@ -475,7 +475,7 @@
{
/* If we're on a 64-bit platform we can fit a long or double
into the same space as a jword. */
- if (POINTER_SIZE >= 64)
+ if (JAVA_POINTER_SIZE >= 64)
index = find_constant1 (cpool, kind, JPOOL_LONG (jcf, index));
/* In a compiled program the constant pool is in native word
===================================================================
@@ -541,7 +541,7 @@
not a scalar but a union, and that's how we should
represent it in the compiler. We should fix this. */
if (BYTES_BIG_ENDIAN)
- temp <<= ((POINTER_SIZE > 32) ? POINTER_SIZE - 32 : 0);
+ temp <<= ((JAVA_POINTER_SIZE > 32) ? JAVA_POINTER_SIZE - 32 : 0);
CONSTRUCTOR_PREPEND_VALUE (t, get_tag_node (outgoing_cpool->tags[i]));
CONSTRUCTOR_PREPEND_VALUE (d,
===================================================================
@@ -244,7 +244,7 @@
tree orig_method_call = METHOD_CALL; \
this_arg = CALL_EXPR_ARG (orig_method_call, 0); \
obj_arg = CALL_EXPR_ARG (orig_method_call, 1); \
- offset_arg = fold_convert (java_type_for_size (POINTER_SIZE, 0), \
+ offset_arg = fold_convert (java_type_for_size (JAVA_POINTER_SIZE, 0), \
CALL_EXPR_ARG (orig_method_call, 2)); \
} \
while (0)
@@ -256,7 +256,7 @@
tree orig_method_call = METHOD_CALL; \
this_arg = CALL_EXPR_ARG (orig_method_call, 0); \
obj_arg = CALL_EXPR_ARG (orig_method_call, 1); \
- offset_arg = fold_convert (java_type_for_size (POINTER_SIZE, 0), \
+ offset_arg = fold_convert (java_type_for_size (JAVA_POINTER_SIZE, 0), \
CALL_EXPR_ARG (orig_method_call, 2)); \
value_arg = CALL_EXPR_ARG (orig_method_call, 3); \
value_type = TREE_TYPE (value_arg); \
@@ -270,7 +270,7 @@
tree orig_method_call = METHOD_CALL; \
this_arg = CALL_EXPR_ARG (orig_method_call, 0); \
obj_arg = CALL_EXPR_ARG (orig_method_call, 1); \
- offset_arg = fold_convert (java_type_for_size (POINTER_SIZE, 0), \
+ offset_arg = fold_convert (java_type_for_size (JAVA_POINTER_SIZE, 0), \
CALL_EXPR_ARG (orig_method_call, 2)); \
expected_arg = CALL_EXPR_ARG (orig_method_call, 3); \
value_arg = CALL_EXPR_ARG (orig_method_call, 4); \
@@ -378,7 +378,7 @@
int builtin;
UNMARSHAL5 (orig_call);
- builtin = (POINTER_SIZE == 32
+ builtin = (JAVA_POINTER_SIZE == 32
? BUILT_IN_BOOL_COMPARE_AND_SWAP_4
: BUILT_IN_BOOL_COMPARE_AND_SWAP_8);
===================================================================
@@ -1516,4 +1516,12 @@
extern FILE *finput;
+/* Frontends shouldn't use POINTER_SIZE, since that is a target macro.
+ We can't use TYPE_PRECISION (ptr_type_node), since that node isn't
+ available for java.
+ Luckily, sizetype is set with the precision of pointer_size (),
+ so we don't have to call pointer_size all the time once sizetype
+ has been set up. */
+#define JAVA_POINTER_SIZE (TYPE_PRECISION (sizetype))
+
#endif /* ! GCC_JAVA_TREE_H */
===================================================================
@@ -36,7 +36,8 @@
#include "toplev.h"
static void mark_reference_fields (tree, double_int *, unsigned int,
- int *, int *, int *, HOST_WIDE_INT *);
+ int *, int *, int *, HOST_WIDE_INT *,
+ unsigned int);
/* A procedure-based object descriptor. We know that our
`kind' is 0, and `env' is likewise 0, so we have a simple
@@ -54,7 +55,8 @@
int *pointer_after_end,
int *all_bits_set,
int *last_set_index,
- HOST_WIDE_INT *last_view_index)
+ HOST_WIDE_INT *last_view_index,
+ unsigned int log2_size)
{
/* See if we have fields from our superclass. */
if (DECL_NAME (field) == NULL_TREE)
@@ -62,7 +64,7 @@
mark_reference_fields (TYPE_FIELDS (TREE_TYPE (field)),
mask, ubit,
pointer_after_end, all_bits_set,
- last_set_index, last_view_index);
+ last_set_index, last_view_index, log2_size);
field = DECL_CHAIN (field);
}
@@ -90,15 +92,15 @@
we already covered, then we are doomed. */
gcc_assert (offset > *last_view_index);
- if (offset % (HOST_WIDE_INT) (POINTER_SIZE / BITS_PER_UNIT))
+ if (offset & ((1 << log2_size) - 1))
{
*all_bits_set = -1;
*pointer_after_end = 1;
break;
}
- count = offset * BITS_PER_UNIT / POINTER_SIZE;
- size_words = size_bytes * BITS_PER_UNIT / POINTER_SIZE;
+ count = offset >> log2_size;
+ size_words = size_bytes >> log2_size;
*last_set_index = count;
@@ -152,7 +154,7 @@
if (int_size_in_bytes (type) == -1)
goto procedure_object_descriptor;
- bit = POINTER_SIZE / BITS_PER_UNIT;
+ bit = JAVA_POINTER_SIZE / BITS_PER_UNIT;
/* The size of this node has to be known. And, we only support 32
and 64 bit targets, so we need to know that the log2 is one of
our values. */
@@ -175,7 +177,7 @@
field = TYPE_FIELDS (type);
mark_reference_fields (field, &mask, ubit,
&pointer_after_end, &all_bits_set,
- &last_set_index, &last_view_index);
+ &last_set_index, &last_view_index, log2_size);
/* If the object is all pointers, or if the part with pointers fits
in our bitmap, then we are ok. Otherwise we have to allocate it
===================================================================
@@ -176,4 +176,8 @@
/* Each target can provide their own. */
extern struct gcc_targetcm targetcm;
+/* Functions defined in targhooks.c that use target hooks and/or target
+ macros that make these values available to frontends / tree optimizers. */
+extern unsigned pointer_size (void);
+
#endif /* GCC_TARGET_H */
===================================================================
@@ -221,9 +221,12 @@
if (INTEGRAL_CODE_P (form))
{
- if (TYPE_PRECISION (intype) == POINTER_SIZE)
+ if (TYPE_PRECISION (intype) == TYPE_PRECISION (ptr_type_node))
return build1 (CONVERT_EXPR, type, expr);
- expr = cp_convert (c_common_type_for_size (POINTER_SIZE, 0), expr);
+ expr
+ = cp_convert (c_common_type_for_size (TYPE_PRECISION (ptr_type_node),
+ 0),
+ expr);
/* Modes may be different but sizes should be the same. There
is supposed to be some integral type that is the same width
as a pointer. */
===================================================================
@@ -396,7 +396,7 @@
if (IN (kind, Float_Kind))
max_esize = fp_prec_to_size (LONG_DOUBLE_TYPE_SIZE);
else if (IN (kind, Access_Kind))
- max_esize = POINTER_SIZE * 2;
+ max_esize = pointer_size () * 2;
else
max_esize = LONG_LONG_TYPE_SIZE;
@@ -3714,7 +3714,7 @@
= TYPE_IS_FAT_POINTER_P (gnu_type)
? TYPE_UNCONSTRAINED_ARRAY (gnu_type) : TREE_TYPE (gnu_type);
- if (esize == POINTER_SIZE
+ if (esize == pointer_size ()
&& (got_fat_p || TYPE_IS_FAT_POINTER_P (gnu_type)))
gnu_type
= build_pointer_type
@@ -4853,7 +4853,7 @@
{
/* In this mode, the tag and the parent components are not
generated by the front-end so the sizes must be adjusted. */
- tree pointer_size = bitsize_int (POINTER_SIZE), offset;
+ tree pointer_size_t = bitsize_int (pointer_size ()), offset;
Uint uint_size;
if (Is_Derived_Type (gnat_entity))
@@ -4864,13 +4864,13 @@
Alignment (Etype (Base_Type (gnat_entity))));
}
else
- offset = pointer_size;
+ offset = pointer_size_t;
gnu_size = size_binop (PLUS_EXPR, gnu_size, offset);
- gnu_size = size_binop (MULT_EXPR, pointer_size,
+ gnu_size = size_binop (MULT_EXPR, pointer_size_t,
size_binop (CEIL_DIV_EXPR,
gnu_size,
- pointer_size));
+ pointer_size_t));
uint_size = annotate_value (gnu_size);
Set_Esize (gnat_entity, uint_size);
Set_RM_Size (gnat_entity, uint_size);
@@ -5107,7 +5107,7 @@
finish_fat_pointer_type (tree record_type, tree field_list)
{
/* Make sure we can put it into a register. */
- TYPE_ALIGN (record_type) = MIN (BIGGEST_ALIGNMENT, 2 * POINTER_SIZE);
+ TYPE_ALIGN (record_type) = MIN (BIGGEST_ALIGNMENT, 2 * pointer_size ());
/* Show what it really is. */
TYPE_FAT_POINTER_P (record_type) = 1;
@@ -5393,7 +5393,7 @@
/* Fat pointers are passed as thin pointers for foreign conventions. */
else if (foreign && TYPE_IS_FAT_POINTER_P (gnu_param_type))
gnu_param_type
- = make_type_from_size (gnu_param_type, size_int (POINTER_SIZE), 0);
+ = make_type_from_size (gnu_param_type, size_int (pointer_size ()), 0);
/* If we must pass or were requested to pass by reference, do so.
If we were requested to pass by copy, do so.
@@ -7520,7 +7520,7 @@
= UI_To_gnu (Esize (Etype (Base_Type (gnat_entity))),
bitsizetype);
else
- parent_offset = bitsize_int (POINTER_SIZE);
+ parent_offset = bitsize_int (pointer_size ());
}
else
parent_offset = bitsize_zero_node;
@@ -7959,7 +7959,7 @@
case RECORD_TYPE:
/* Do something if this is a fat pointer, in which case we
may need to return the thin pointer. */
- if (TYPE_FAT_POINTER_P (type) && size < POINTER_SIZE * 2)
+ if (TYPE_FAT_POINTER_P (type) && size < pointer_size () * 2)
{
enum machine_mode p_mode = mode_for_size (size, MODE_INT, 0);
if (!targetm.valid_pointer_mode (p_mode))
@@ -7974,7 +7974,7 @@
case POINTER_TYPE:
/* Only do something if this is a thin pointer, in which case we
may need to return the fat pointer. */
- if (TYPE_IS_THIN_POINTER_P (type) && size >= POINTER_SIZE * 2)
+ if (TYPE_IS_THIN_POINTER_P (type) && size >= pointer_size () * 2)
return
build_pointer_type (TYPE_UNCONSTRAINED_ARRAY (TREE_TYPE (type)));
break;
===================================================================
@@ -31,6 +31,7 @@
#include "tree.h"
#include "tm.h"
#include "tm_p.h"
+#include "target.h"
#include "ada.h"
#include "types.h"
@@ -131,7 +132,7 @@
Pos
get_target_pointer_size (void)
{
- return POINTER_SIZE;
+ return pointer_size ();
}
/* Alignment related values, mapped to attributes for functional and
===================================================================
@@ -32,6 +32,7 @@
#include "ggc.h"
#include "output.h"
#include "tree-inline.h"
+#include "target.h"
#include "ada.h"
#include "types.h"
@@ -1941,7 +1942,7 @@
= ((data_align > default_allocator_alignment)
? make_aligning_type (data_type, data_align, data_size,
default_allocator_alignment,
- POINTER_SIZE / BITS_PER_UNIT)
+ pointer_size () / BITS_PER_UNIT)
: NULL_TREE);
tree size_to_malloc
@@ -1952,7 +1953,7 @@
/* On VMS, if pointers are 64-bit and the allocator size is 32-bit or
Convention C, allocate 32-bit memory. */
if (TARGET_ABI_OPEN_VMS
- && POINTER_SIZE == 64
+ && pointer_size () == 64
&& Nkind (gnat_node) == N_Allocator
&& (UI_To_Int (Esize (Etype (gnat_node))) == 32
|| Convention (Etype (gnat_node)) == Convention_C))
@@ -1984,7 +1985,7 @@
tree storage_ptr_slot_addr
= build_binary_op (POINTER_PLUS_EXPR, ptr_void_type_node,
convert (ptr_void_type_node, aligning_field_addr),
- size_int (-(HOST_WIDE_INT) POINTER_SIZE
+ size_int (-(HOST_WIDE_INT) pointer_size ()
/ BITS_PER_UNIT));
tree storage_ptr_slot
@@ -2026,7 +2027,7 @@
= build_binary_op
(POINTER_PLUS_EXPR, ptr_void_type_node,
convert (ptr_void_type_node, data_ptr),
- size_int (-(HOST_WIDE_INT) POINTER_SIZE / BITS_PER_UNIT));
+ size_int (-(HOST_WIDE_INT) pointer_size () / BITS_PER_UNIT));
/* FREE_PTR (void *) = *(void **)DATA_FRONT_PTR */
free_ptr
===================================================================
@@ -566,7 +566,7 @@
gfc_character_storage_size = gfc_default_character_kind * 8;
/* Choose the integer kind the same size as "void*" for our index kind. */
- gfc_index_integer_kind = POINTER_SIZE / 8;
+ gfc_index_integer_kind = pointer_size () / 8;
/* Pick a kind the same size as the C "int" type. */
gfc_c_int_kind = INT_TYPE_SIZE / 8;
===================================================================
@@ -583,7 +583,7 @@
want double_type_node to actually have double precision. */
build_common_tree_nodes (false);
- size_type_node = gfc_build_uint_type (POINTER_SIZE);
+ size_type_node = gfc_build_uint_type (pointer_size ());
set_sizetype (size_type_node);
build_common_tree_nodes_2 (0);
===================================================================
@@ -325,7 +325,7 @@
&& lo->sobj_w != NULL
&& lo->section == NULL);
- align = exact_log2 (POINTER_SIZE / BITS_PER_UNIT);
+ align = exact_log2 (pointer_size () / BITS_PER_UNIT);
lo->section = simple_object_write_create_section (lo->sobj_w, name, align,
&errmsg, &err);
if (lo->section == NULL)