/* Allocate a block of memory, then clear it. */
void *
ggc_internal_cleared_alloc (size_t size, void (*f)(void *), size_t s, size_t n
MEM_STAT_DECL)
{
void *buf = ggc_internal_alloc (size, f, s, n PASS_MEM_STAT);
memset (buf, 0, size);
return buf;
}
/* Resize a block of memory, possibly re-allocating it. */
void *
ggc_realloc (void *x, size_t size MEM_STAT_DECL)
{
void *r;
size_t old_size;
if (x == NULL)
return ggc_internal_alloc (size PASS_MEM_STAT);
old_size = ggc_get_size (x);
if (size <= old_size)
{
/* Mark the unwanted memory as unaccessible. We also need to make
the "new" size accessible, since ggc_get_size returns the size of
the pool, not the size of the individually allocated object, the
size which was previously made accessible. Unfortunately, we
don't know that previously allocated size. Without that
knowledge we have to lose some initialization-tracking for the
old parts of the object. An alternative is to mark the whole
old_size as reachable, but that would lose tracking of writes
after the end of the object (by small offsets). Discard the
handle to avoid handle leak. */
VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS ((char *) x + size,
old_size - size));
VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (x, size));
return x;
}
r = ggc_internal_alloc (size PASS_MEM_STAT);
/* Since ggc_get_size returns the size of the pool, not the size of the
individually allocated object, we'd access parts of the old object
that were marked invalid with the memcpy below. We lose a bit of the
initialization-tracking since some of it may be uninitialized. */
VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (x, old_size));
memcpy (r, x, old_size);
/* The old object is not supposed to be used anymore. */
ggc_free (x);
return r;
}
static inline void *
ssa_operand_alloc (struct function *fn, unsigned size)
{
char *ptr;
gcc_assert (size == sizeof (struct use_optype_d));
if (gimple_ssa_operands (fn)->operand_memory_index + size
>= gimple_ssa_operands (fn)->ssa_operand_mem_size)
{
struct ssa_operand_memory_d *ptr;
switch (gimple_ssa_operands (fn)->ssa_operand_mem_size)
{
case OP_SIZE_INIT:
gimple_ssa_operands (fn)->ssa_operand_mem_size = OP_SIZE_1;
break;
case OP_SIZE_1:
gimple_ssa_operands (fn)->ssa_operand_mem_size = OP_SIZE_2;
break;
case OP_SIZE_2:
case OP_SIZE_3:
gimple_ssa_operands (fn)->ssa_operand_mem_size = OP_SIZE_3;
break;
default:
gcc_unreachable ();
}
ptr = (ssa_operand_memory_d *) ggc_internal_alloc
(sizeof (void *) + gimple_ssa_operands (fn)->ssa_operand_mem_size);
ptr->next = gimple_ssa_operands (fn)->operand_memory;
gimple_ssa_operands (fn)->operand_memory = ptr;
gimple_ssa_operands (fn)->operand_memory_index = 0;
}
ptr = &(gimple_ssa_operands (fn)->operand_memory
->mem[gimple_ssa_operands (fn)->operand_memory_index]);
gimple_ssa_operands (fn)->operand_memory_index += size;
return ptr;
}
/* Creates a duplicate of the range_info_def at RANGE_INFO of type
RANGE_TYPE for use by the SSA name NAME. */
void
duplicate_ssa_name_range_info (tree name, enum value_range_type range_type,
struct range_info_def *range_info)
{
struct range_info_def *new_range_info;
gcc_assert (!POINTER_TYPE_P (TREE_TYPE (name)));
gcc_assert (!SSA_NAME_RANGE_INFO (name));
gcc_assert (!SSA_NAME_ANTI_RANGE_P (name));
if (!range_info)
return;
unsigned int precision = TYPE_PRECISION (TREE_TYPE (name));
size_t size = (sizeof (range_info_def)
+ trailing_wide_ints <3>::extra_size (precision));
new_range_info = static_cast<range_info_def *> (ggc_internal_alloc (size));
memcpy (new_range_info, range_info, size);
gcc_assert (range_type == VR_RANGE || range_type == VR_ANTI_RANGE);
SSA_NAME_ANTI_RANGE_P (name) = (range_type == VR_ANTI_RANGE);
SSA_NAME_RANGE_INFO (name) = new_range_info;
}
void
set_range_info (tree name, enum value_range_type range_type,
const wide_int_ref &min, const wide_int_ref &max)
{
gcc_assert (!POINTER_TYPE_P (TREE_TYPE (name)));
gcc_assert (range_type == VR_RANGE || range_type == VR_ANTI_RANGE);
range_info_def *ri = SSA_NAME_RANGE_INFO (name);
unsigned int precision = TYPE_PRECISION (TREE_TYPE (name));
/* Allocate if not available. */
if (ri == NULL)
{
size_t size = (sizeof (range_info_def)
+ trailing_wide_ints <3>::extra_size (precision));
ri = static_cast<range_info_def *> (ggc_internal_alloc (size));
ri->ints.set_precision (precision);
SSA_NAME_RANGE_INFO (name) = ri;
ri->set_nonzero_bits (wi::shwi (-1, precision));
}
/* Record the range type. */
if (SSA_NAME_RANGE_TYPE (name) != range_type)
SSA_NAME_ANTI_RANGE_P (name) = (range_type == VR_ANTI_RANGE);
/* Set the values. */
ri->set_min (min);
ri->set_max (max);
/* If it is a range, try to improve nonzero_bits from the min/max. */
if (range_type == VR_RANGE)
{
wide_int xorv = ri->get_min () ^ ri->get_max ();
if (xorv != 0)
xorv = wi::mask (precision - wi::clz (xorv), false, precision);
ri->set_nonzero_bits (ri->get_nonzero_bits () & (ri->get_min () | xorv));
}
}
/* These are for splay_tree_new_ggc. */
void *
ggc_splay_alloc (int sz, void *nl)
{
gcc_assert (!nl);
return ggc_internal_alloc (sz);
}
