/* __builtin_object_size (ptr, object_size_type) computation
|
/* __builtin_object_size (ptr, object_size_type) computation
|
Copyright (C) 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
|
Copyright (C) 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
|
Contributed by Jakub Jelinek <jakub@redhat.com>
|
Contributed by Jakub Jelinek <jakub@redhat.com>
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify
|
GCC is free software; you can redistribute it and/or modify
|
it under the terms of the GNU General Public License as published by
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3, or (at your option)
|
the Free Software Foundation; either version 3, or (at your option)
|
any later version.
|
any later version.
|
|
|
GCC is distributed in the hope that it will be useful,
|
GCC is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "diagnostic.h"
|
#include "diagnostic.h"
|
#include "tree-flow.h"
|
#include "tree-flow.h"
|
#include "tree-pass.h"
|
#include "tree-pass.h"
|
#include "tree-ssa-propagate.h"
|
#include "tree-ssa-propagate.h"
|
|
|
struct object_size_info
|
struct object_size_info
|
{
|
{
|
int object_size_type;
|
int object_size_type;
|
bitmap visited, reexamine;
|
bitmap visited, reexamine;
|
int pass;
|
int pass;
|
bool changed;
|
bool changed;
|
unsigned int *depths;
|
unsigned int *depths;
|
unsigned int *stack, *tos;
|
unsigned int *stack, *tos;
|
};
|
};
|
|
|
static unsigned HOST_WIDE_INT unknown[4] = { -1, -1, 0, 0 };
|
static unsigned HOST_WIDE_INT unknown[4] = { -1, -1, 0, 0 };
|
|
|
static tree compute_object_offset (tree, tree);
|
static tree compute_object_offset (tree, tree);
|
static unsigned HOST_WIDE_INT addr_object_size (tree, int);
|
static unsigned HOST_WIDE_INT addr_object_size (tree, int);
|
static unsigned HOST_WIDE_INT alloc_object_size (tree, int);
|
static unsigned HOST_WIDE_INT alloc_object_size (tree, int);
|
static tree pass_through_call (tree);
|
static tree pass_through_call (tree);
|
static void collect_object_sizes_for (struct object_size_info *, tree);
|
static void collect_object_sizes_for (struct object_size_info *, tree);
|
static void expr_object_size (struct object_size_info *, tree, tree);
|
static void expr_object_size (struct object_size_info *, tree, tree);
|
static bool merge_object_sizes (struct object_size_info *, tree, tree,
|
static bool merge_object_sizes (struct object_size_info *, tree, tree,
|
unsigned HOST_WIDE_INT);
|
unsigned HOST_WIDE_INT);
|
static bool plus_expr_object_size (struct object_size_info *, tree, tree);
|
static bool plus_expr_object_size (struct object_size_info *, tree, tree);
|
static unsigned int compute_object_sizes (void);
|
static unsigned int compute_object_sizes (void);
|
static void init_offset_limit (void);
|
static void init_offset_limit (void);
|
static void check_for_plus_in_loops (struct object_size_info *, tree);
|
static void check_for_plus_in_loops (struct object_size_info *, tree);
|
static void check_for_plus_in_loops_1 (struct object_size_info *, tree,
|
static void check_for_plus_in_loops_1 (struct object_size_info *, tree,
|
unsigned int);
|
unsigned int);
|
|
|
/* object_sizes[0] is upper bound for number of bytes till the end of
|
/* object_sizes[0] is upper bound for number of bytes till the end of
|
the object.
|
the object.
|
object_sizes[1] is upper bound for number of bytes till the end of
|
object_sizes[1] is upper bound for number of bytes till the end of
|
the subobject (innermost array or field with address taken).
|
the subobject (innermost array or field with address taken).
|
object_sizes[2] is lower bound for number of bytes till the end of
|
object_sizes[2] is lower bound for number of bytes till the end of
|
the object and object_sizes[3] lower bound for subobject. */
|
the object and object_sizes[3] lower bound for subobject. */
|
static unsigned HOST_WIDE_INT *object_sizes[4];
|
static unsigned HOST_WIDE_INT *object_sizes[4];
|
|
|
/* Bitmaps what object sizes have been computed already. */
|
/* Bitmaps what object sizes have been computed already. */
|
static bitmap computed[4];
|
static bitmap computed[4];
|
|
|
/* Maximum value of offset we consider to be addition. */
|
/* Maximum value of offset we consider to be addition. */
|
static unsigned HOST_WIDE_INT offset_limit;
|
static unsigned HOST_WIDE_INT offset_limit;
|
|
|
|
|
/* Initialize OFFSET_LIMIT variable. */
|
/* Initialize OFFSET_LIMIT variable. */
|
static void
|
static void
|
init_offset_limit (void)
|
init_offset_limit (void)
|
{
|
{
|
if (host_integerp (TYPE_MAX_VALUE (sizetype), 1))
|
if (host_integerp (TYPE_MAX_VALUE (sizetype), 1))
|
offset_limit = tree_low_cst (TYPE_MAX_VALUE (sizetype), 1);
|
offset_limit = tree_low_cst (TYPE_MAX_VALUE (sizetype), 1);
|
else
|
else
|
offset_limit = -1;
|
offset_limit = -1;
|
offset_limit /= 2;
|
offset_limit /= 2;
|
}
|
}
|
|
|
|
|
/* Compute offset of EXPR within VAR. Return error_mark_node
|
/* Compute offset of EXPR within VAR. Return error_mark_node
|
if unknown. */
|
if unknown. */
|
|
|
static tree
|
static tree
|
compute_object_offset (tree expr, tree var)
|
compute_object_offset (tree expr, tree var)
|
{
|
{
|
enum tree_code code = PLUS_EXPR;
|
enum tree_code code = PLUS_EXPR;
|
tree base, off, t;
|
tree base, off, t;
|
|
|
if (expr == var)
|
if (expr == var)
|
return size_zero_node;
|
return size_zero_node;
|
|
|
switch (TREE_CODE (expr))
|
switch (TREE_CODE (expr))
|
{
|
{
|
case COMPONENT_REF:
|
case COMPONENT_REF:
|
base = compute_object_offset (TREE_OPERAND (expr, 0), var);
|
base = compute_object_offset (TREE_OPERAND (expr, 0), var);
|
if (base == error_mark_node)
|
if (base == error_mark_node)
|
return base;
|
return base;
|
|
|
t = TREE_OPERAND (expr, 1);
|
t = TREE_OPERAND (expr, 1);
|
off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
|
off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
|
size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
|
size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
|
/ BITS_PER_UNIT));
|
/ BITS_PER_UNIT));
|
break;
|
break;
|
|
|
case REALPART_EXPR:
|
case REALPART_EXPR:
|
case NOP_EXPR:
|
case NOP_EXPR:
|
case CONVERT_EXPR:
|
case CONVERT_EXPR:
|
case VIEW_CONVERT_EXPR:
|
case VIEW_CONVERT_EXPR:
|
case NON_LVALUE_EXPR:
|
case NON_LVALUE_EXPR:
|
return compute_object_offset (TREE_OPERAND (expr, 0), var);
|
return compute_object_offset (TREE_OPERAND (expr, 0), var);
|
|
|
case IMAGPART_EXPR:
|
case IMAGPART_EXPR:
|
base = compute_object_offset (TREE_OPERAND (expr, 0), var);
|
base = compute_object_offset (TREE_OPERAND (expr, 0), var);
|
if (base == error_mark_node)
|
if (base == error_mark_node)
|
return base;
|
return base;
|
|
|
off = TYPE_SIZE_UNIT (TREE_TYPE (expr));
|
off = TYPE_SIZE_UNIT (TREE_TYPE (expr));
|
break;
|
break;
|
|
|
case ARRAY_REF:
|
case ARRAY_REF:
|
base = compute_object_offset (TREE_OPERAND (expr, 0), var);
|
base = compute_object_offset (TREE_OPERAND (expr, 0), var);
|
if (base == error_mark_node)
|
if (base == error_mark_node)
|
return base;
|
return base;
|
|
|
t = TREE_OPERAND (expr, 1);
|
t = TREE_OPERAND (expr, 1);
|
if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
|
if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
|
{
|
{
|
code = MINUS_EXPR;
|
code = MINUS_EXPR;
|
t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
|
t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
|
}
|
}
|
t = fold_convert (sizetype, t);
|
t = fold_convert (sizetype, t);
|
off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
|
off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
|
break;
|
break;
|
|
|
default:
|
default:
|
return error_mark_node;
|
return error_mark_node;
|
}
|
}
|
|
|
return size_binop (code, base, off);
|
return size_binop (code, base, off);
|
}
|
}
|
|
|
|
|
/* Compute __builtin_object_size for PTR, which is a ADDR_EXPR.
|
/* Compute __builtin_object_size for PTR, which is a ADDR_EXPR.
|
OBJECT_SIZE_TYPE is the second argument from __builtin_object_size.
|
OBJECT_SIZE_TYPE is the second argument from __builtin_object_size.
|
If unknown, return unknown[object_size_type]. */
|
If unknown, return unknown[object_size_type]. */
|
|
|
static unsigned HOST_WIDE_INT
|
static unsigned HOST_WIDE_INT
|
addr_object_size (tree ptr, int object_size_type)
|
addr_object_size (tree ptr, int object_size_type)
|
{
|
{
|
tree pt_var;
|
tree pt_var;
|
|
|
gcc_assert (TREE_CODE (ptr) == ADDR_EXPR);
|
gcc_assert (TREE_CODE (ptr) == ADDR_EXPR);
|
|
|
pt_var = TREE_OPERAND (ptr, 0);
|
pt_var = TREE_OPERAND (ptr, 0);
|
if (REFERENCE_CLASS_P (pt_var))
|
if (REFERENCE_CLASS_P (pt_var))
|
pt_var = get_base_address (pt_var);
|
pt_var = get_base_address (pt_var);
|
|
|
if (pt_var
|
if (pt_var
|
&& (SSA_VAR_P (pt_var) || TREE_CODE (pt_var) == STRING_CST)
|
&& (SSA_VAR_P (pt_var) || TREE_CODE (pt_var) == STRING_CST)
|
&& TYPE_SIZE_UNIT (TREE_TYPE (pt_var))
|
&& TYPE_SIZE_UNIT (TREE_TYPE (pt_var))
|
&& host_integerp (TYPE_SIZE_UNIT (TREE_TYPE (pt_var)), 1)
|
&& host_integerp (TYPE_SIZE_UNIT (TREE_TYPE (pt_var)), 1)
|
&& (unsigned HOST_WIDE_INT)
|
&& (unsigned HOST_WIDE_INT)
|
tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (pt_var)), 1) < offset_limit)
|
tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (pt_var)), 1) < offset_limit)
|
{
|
{
|
tree bytes;
|
tree bytes;
|
|
|
if (pt_var != TREE_OPERAND (ptr, 0))
|
if (pt_var != TREE_OPERAND (ptr, 0))
|
{
|
{
|
tree var;
|
tree var;
|
|
|
if (object_size_type & 1)
|
if (object_size_type & 1)
|
{
|
{
|
var = TREE_OPERAND (ptr, 0);
|
var = TREE_OPERAND (ptr, 0);
|
|
|
while (var != pt_var
|
while (var != pt_var
|
&& TREE_CODE (var) != BIT_FIELD_REF
|
&& TREE_CODE (var) != BIT_FIELD_REF
|
&& TREE_CODE (var) != COMPONENT_REF
|
&& TREE_CODE (var) != COMPONENT_REF
|
&& TREE_CODE (var) != ARRAY_REF
|
&& TREE_CODE (var) != ARRAY_REF
|
&& TREE_CODE (var) != ARRAY_RANGE_REF
|
&& TREE_CODE (var) != ARRAY_RANGE_REF
|
&& TREE_CODE (var) != REALPART_EXPR
|
&& TREE_CODE (var) != REALPART_EXPR
|
&& TREE_CODE (var) != IMAGPART_EXPR)
|
&& TREE_CODE (var) != IMAGPART_EXPR)
|
var = TREE_OPERAND (var, 0);
|
var = TREE_OPERAND (var, 0);
|
if (var != pt_var && TREE_CODE (var) == ARRAY_REF)
|
if (var != pt_var && TREE_CODE (var) == ARRAY_REF)
|
var = TREE_OPERAND (var, 0);
|
var = TREE_OPERAND (var, 0);
|
if (! TYPE_SIZE_UNIT (TREE_TYPE (var))
|
if (! TYPE_SIZE_UNIT (TREE_TYPE (var))
|
|| ! host_integerp (TYPE_SIZE_UNIT (TREE_TYPE (var)), 1)
|
|| ! host_integerp (TYPE_SIZE_UNIT (TREE_TYPE (var)), 1)
|
|| tree_int_cst_lt (TYPE_SIZE_UNIT (TREE_TYPE (pt_var)),
|
|| tree_int_cst_lt (TYPE_SIZE_UNIT (TREE_TYPE (pt_var)),
|
TYPE_SIZE_UNIT (TREE_TYPE (var))))
|
TYPE_SIZE_UNIT (TREE_TYPE (var))))
|
var = pt_var;
|
var = pt_var;
|
}
|
}
|
else
|
else
|
var = pt_var;
|
var = pt_var;
|
|
|
bytes = compute_object_offset (TREE_OPERAND (ptr, 0), var);
|
bytes = compute_object_offset (TREE_OPERAND (ptr, 0), var);
|
if (bytes != error_mark_node)
|
if (bytes != error_mark_node)
|
{
|
{
|
if (TREE_CODE (bytes) == INTEGER_CST
|
if (TREE_CODE (bytes) == INTEGER_CST
|
&& tree_int_cst_lt (TYPE_SIZE_UNIT (TREE_TYPE (var)), bytes))
|
&& tree_int_cst_lt (TYPE_SIZE_UNIT (TREE_TYPE (var)), bytes))
|
bytes = size_zero_node;
|
bytes = size_zero_node;
|
else
|
else
|
bytes = size_binop (MINUS_EXPR,
|
bytes = size_binop (MINUS_EXPR,
|
TYPE_SIZE_UNIT (TREE_TYPE (var)), bytes);
|
TYPE_SIZE_UNIT (TREE_TYPE (var)), bytes);
|
}
|
}
|
}
|
}
|
else
|
else
|
bytes = TYPE_SIZE_UNIT (TREE_TYPE (pt_var));
|
bytes = TYPE_SIZE_UNIT (TREE_TYPE (pt_var));
|
|
|
if (host_integerp (bytes, 1))
|
if (host_integerp (bytes, 1))
|
return tree_low_cst (bytes, 1);
|
return tree_low_cst (bytes, 1);
|
}
|
}
|
|
|
return unknown[object_size_type];
|
return unknown[object_size_type];
|
}
|
}
|
|
|
|
|
/* Compute __builtin_object_size for CALL, which is a CALL_EXPR.
|
/* Compute __builtin_object_size for CALL, which is a CALL_EXPR.
|
Handles various allocation calls. OBJECT_SIZE_TYPE is the second
|
Handles various allocation calls. OBJECT_SIZE_TYPE is the second
|
argument from __builtin_object_size. If unknown, return
|
argument from __builtin_object_size. If unknown, return
|
unknown[object_size_type]. */
|
unknown[object_size_type]. */
|
|
|
static unsigned HOST_WIDE_INT
|
static unsigned HOST_WIDE_INT
|
alloc_object_size (tree call, int object_size_type)
|
alloc_object_size (tree call, int object_size_type)
|
{
|
{
|
tree callee, arglist, a, bytes = NULL_TREE;
|
tree callee, arglist, a, bytes = NULL_TREE;
|
unsigned int arg_mask = 0;
|
unsigned int arg_mask = 0;
|
|
|
gcc_assert (TREE_CODE (call) == CALL_EXPR);
|
gcc_assert (TREE_CODE (call) == CALL_EXPR);
|
|
|
callee = get_callee_fndecl (call);
|
callee = get_callee_fndecl (call);
|
arglist = TREE_OPERAND (call, 1);
|
arglist = TREE_OPERAND (call, 1);
|
if (callee
|
if (callee
|
&& DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL)
|
&& DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL)
|
switch (DECL_FUNCTION_CODE (callee))
|
switch (DECL_FUNCTION_CODE (callee))
|
{
|
{
|
case BUILT_IN_MALLOC:
|
case BUILT_IN_MALLOC:
|
case BUILT_IN_ALLOCA:
|
case BUILT_IN_ALLOCA:
|
arg_mask = 1;
|
arg_mask = 1;
|
break;
|
break;
|
/*
|
/*
|
case BUILT_IN_REALLOC:
|
case BUILT_IN_REALLOC:
|
arg_mask = 2;
|
arg_mask = 2;
|
break;
|
break;
|
*/
|
*/
|
case BUILT_IN_CALLOC:
|
case BUILT_IN_CALLOC:
|
arg_mask = 3;
|
arg_mask = 3;
|
break;
|
break;
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
for (a = arglist; arg_mask && a; arg_mask >>= 1, a = TREE_CHAIN (a))
|
for (a = arglist; arg_mask && a; arg_mask >>= 1, a = TREE_CHAIN (a))
|
if (arg_mask & 1)
|
if (arg_mask & 1)
|
{
|
{
|
tree arg = TREE_VALUE (a);
|
tree arg = TREE_VALUE (a);
|
|
|
if (TREE_CODE (arg) != INTEGER_CST)
|
if (TREE_CODE (arg) != INTEGER_CST)
|
break;
|
break;
|
|
|
if (! bytes)
|
if (! bytes)
|
bytes = fold_convert (sizetype, arg);
|
bytes = fold_convert (sizetype, arg);
|
else
|
else
|
bytes = size_binop (MULT_EXPR, bytes,
|
bytes = size_binop (MULT_EXPR, bytes,
|
fold_convert (sizetype, arg));
|
fold_convert (sizetype, arg));
|
}
|
}
|
|
|
if (! arg_mask && bytes && host_integerp (bytes, 1))
|
if (! arg_mask && bytes && host_integerp (bytes, 1))
|
return tree_low_cst (bytes, 1);
|
return tree_low_cst (bytes, 1);
|
|
|
return unknown[object_size_type];
|
return unknown[object_size_type];
|
}
|
}
|
|
|
|
|
/* If object size is propagated from one of function's arguments directly
|
/* If object size is propagated from one of function's arguments directly
|
to its return value, return that argument for CALL_EXPR CALL.
|
to its return value, return that argument for CALL_EXPR CALL.
|
Otherwise return NULL. */
|
Otherwise return NULL. */
|
|
|
static tree
|
static tree
|
pass_through_call (tree call)
|
pass_through_call (tree call)
|
{
|
{
|
tree callee = get_callee_fndecl (call);
|
tree callee = get_callee_fndecl (call);
|
tree arglist = TREE_OPERAND (call, 1);
|
tree arglist = TREE_OPERAND (call, 1);
|
|
|
if (callee
|
if (callee
|
&& DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL)
|
&& DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL)
|
switch (DECL_FUNCTION_CODE (callee))
|
switch (DECL_FUNCTION_CODE (callee))
|
{
|
{
|
case BUILT_IN_MEMCPY:
|
case BUILT_IN_MEMCPY:
|
case BUILT_IN_MEMMOVE:
|
case BUILT_IN_MEMMOVE:
|
case BUILT_IN_MEMSET:
|
case BUILT_IN_MEMSET:
|
case BUILT_IN_STRCPY:
|
case BUILT_IN_STRCPY:
|
case BUILT_IN_STRNCPY:
|
case BUILT_IN_STRNCPY:
|
case BUILT_IN_STRCAT:
|
case BUILT_IN_STRCAT:
|
case BUILT_IN_STRNCAT:
|
case BUILT_IN_STRNCAT:
|
case BUILT_IN_MEMCPY_CHK:
|
case BUILT_IN_MEMCPY_CHK:
|
case BUILT_IN_MEMMOVE_CHK:
|
case BUILT_IN_MEMMOVE_CHK:
|
case BUILT_IN_MEMSET_CHK:
|
case BUILT_IN_MEMSET_CHK:
|
case BUILT_IN_STRCPY_CHK:
|
case BUILT_IN_STRCPY_CHK:
|
case BUILT_IN_STRNCPY_CHK:
|
case BUILT_IN_STRNCPY_CHK:
|
case BUILT_IN_STRCAT_CHK:
|
case BUILT_IN_STRCAT_CHK:
|
case BUILT_IN_STRNCAT_CHK:
|
case BUILT_IN_STRNCAT_CHK:
|
if (arglist)
|
if (arglist)
|
return TREE_VALUE (arglist);
|
return TREE_VALUE (arglist);
|
break;
|
break;
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
|
|
/* Compute __builtin_object_size value for PTR. OBJECT_SIZE_TYPE is the
|
/* Compute __builtin_object_size value for PTR. OBJECT_SIZE_TYPE is the
|
second argument from __builtin_object_size. */
|
second argument from __builtin_object_size. */
|
|
|
unsigned HOST_WIDE_INT
|
unsigned HOST_WIDE_INT
|
compute_builtin_object_size (tree ptr, int object_size_type)
|
compute_builtin_object_size (tree ptr, int object_size_type)
|
{
|
{
|
gcc_assert (object_size_type >= 0 && object_size_type <= 3);
|
gcc_assert (object_size_type >= 0 && object_size_type <= 3);
|
|
|
if (! offset_limit)
|
if (! offset_limit)
|
init_offset_limit ();
|
init_offset_limit ();
|
|
|
if (TREE_CODE (ptr) == ADDR_EXPR)
|
if (TREE_CODE (ptr) == ADDR_EXPR)
|
return addr_object_size (ptr, object_size_type);
|
return addr_object_size (ptr, object_size_type);
|
else if (TREE_CODE (ptr) == CALL_EXPR)
|
else if (TREE_CODE (ptr) == CALL_EXPR)
|
{
|
{
|
tree arg = pass_through_call (ptr);
|
tree arg = pass_through_call (ptr);
|
|
|
if (arg)
|
if (arg)
|
return compute_builtin_object_size (arg, object_size_type);
|
return compute_builtin_object_size (arg, object_size_type);
|
else
|
else
|
return alloc_object_size (ptr, object_size_type);
|
return alloc_object_size (ptr, object_size_type);
|
}
|
}
|
else if (TREE_CODE (ptr) == SSA_NAME
|
else if (TREE_CODE (ptr) == SSA_NAME
|
&& POINTER_TYPE_P (TREE_TYPE (ptr))
|
&& POINTER_TYPE_P (TREE_TYPE (ptr))
|
&& object_sizes[object_size_type] != NULL)
|
&& object_sizes[object_size_type] != NULL)
|
{
|
{
|
if (!bitmap_bit_p (computed[object_size_type], SSA_NAME_VERSION (ptr)))
|
if (!bitmap_bit_p (computed[object_size_type], SSA_NAME_VERSION (ptr)))
|
{
|
{
|
struct object_size_info osi;
|
struct object_size_info osi;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
unsigned int i;
|
unsigned int i;
|
|
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
fprintf (dump_file, "Computing %s %sobject size for ",
|
fprintf (dump_file, "Computing %s %sobject size for ",
|
(object_size_type & 2) ? "minimum" : "maximum",
|
(object_size_type & 2) ? "minimum" : "maximum",
|
(object_size_type & 1) ? "sub" : "");
|
(object_size_type & 1) ? "sub" : "");
|
print_generic_expr (dump_file, ptr, dump_flags);
|
print_generic_expr (dump_file, ptr, dump_flags);
|
fprintf (dump_file, ":\n");
|
fprintf (dump_file, ":\n");
|
}
|
}
|
|
|
osi.visited = BITMAP_ALLOC (NULL);
|
osi.visited = BITMAP_ALLOC (NULL);
|
osi.reexamine = BITMAP_ALLOC (NULL);
|
osi.reexamine = BITMAP_ALLOC (NULL);
|
osi.object_size_type = object_size_type;
|
osi.object_size_type = object_size_type;
|
osi.depths = NULL;
|
osi.depths = NULL;
|
osi.stack = NULL;
|
osi.stack = NULL;
|
osi.tos = NULL;
|
osi.tos = NULL;
|
|
|
/* First pass: walk UD chains, compute object sizes that
|
/* First pass: walk UD chains, compute object sizes that
|
can be computed. osi.reexamine bitmap at the end will
|
can be computed. osi.reexamine bitmap at the end will
|
contain what variables were found in dependency cycles
|
contain what variables were found in dependency cycles
|
and therefore need to be reexamined. */
|
and therefore need to be reexamined. */
|
osi.pass = 0;
|
osi.pass = 0;
|
osi.changed = false;
|
osi.changed = false;
|
collect_object_sizes_for (&osi, ptr);
|
collect_object_sizes_for (&osi, ptr);
|
|
|
/* Second pass: keep recomputing object sizes of variables
|
/* Second pass: keep recomputing object sizes of variables
|
that need reexamination, until no object sizes are
|
that need reexamination, until no object sizes are
|
increased or all object sizes are computed. */
|
increased or all object sizes are computed. */
|
if (! bitmap_empty_p (osi.reexamine))
|
if (! bitmap_empty_p (osi.reexamine))
|
{
|
{
|
bitmap reexamine = BITMAP_ALLOC (NULL);
|
bitmap reexamine = BITMAP_ALLOC (NULL);
|
|
|
/* If looking for minimum instead of maximum object size,
|
/* If looking for minimum instead of maximum object size,
|
detect cases where a pointer is increased in a loop.
|
detect cases where a pointer is increased in a loop.
|
Although even without this detection pass 2 would eventually
|
Although even without this detection pass 2 would eventually
|
terminate, it could take a long time. If a pointer is
|
terminate, it could take a long time. If a pointer is
|
increasing this way, we need to assume 0 object size.
|
increasing this way, we need to assume 0 object size.
|
E.g. p = &buf[0]; while (cond) p = p + 4; */
|
E.g. p = &buf[0]; while (cond) p = p + 4; */
|
if (object_size_type & 2)
|
if (object_size_type & 2)
|
{
|
{
|
osi.depths = XCNEWVEC (unsigned int, num_ssa_names);
|
osi.depths = XCNEWVEC (unsigned int, num_ssa_names);
|
osi.stack = XNEWVEC (unsigned int, num_ssa_names);
|
osi.stack = XNEWVEC (unsigned int, num_ssa_names);
|
osi.tos = osi.stack;
|
osi.tos = osi.stack;
|
osi.pass = 1;
|
osi.pass = 1;
|
/* collect_object_sizes_for is changing
|
/* collect_object_sizes_for is changing
|
osi.reexamine bitmap, so iterate over a copy. */
|
osi.reexamine bitmap, so iterate over a copy. */
|
bitmap_copy (reexamine, osi.reexamine);
|
bitmap_copy (reexamine, osi.reexamine);
|
EXECUTE_IF_SET_IN_BITMAP (reexamine, 0, i, bi)
|
EXECUTE_IF_SET_IN_BITMAP (reexamine, 0, i, bi)
|
if (bitmap_bit_p (osi.reexamine, i))
|
if (bitmap_bit_p (osi.reexamine, i))
|
check_for_plus_in_loops (&osi, ssa_name (i));
|
check_for_plus_in_loops (&osi, ssa_name (i));
|
|
|
free (osi.depths);
|
free (osi.depths);
|
osi.depths = NULL;
|
osi.depths = NULL;
|
free (osi.stack);
|
free (osi.stack);
|
osi.stack = NULL;
|
osi.stack = NULL;
|
osi.tos = NULL;
|
osi.tos = NULL;
|
}
|
}
|
|
|
do
|
do
|
{
|
{
|
osi.pass = 2;
|
osi.pass = 2;
|
osi.changed = false;
|
osi.changed = false;
|
/* collect_object_sizes_for is changing
|
/* collect_object_sizes_for is changing
|
osi.reexamine bitmap, so iterate over a copy. */
|
osi.reexamine bitmap, so iterate over a copy. */
|
bitmap_copy (reexamine, osi.reexamine);
|
bitmap_copy (reexamine, osi.reexamine);
|
EXECUTE_IF_SET_IN_BITMAP (reexamine, 0, i, bi)
|
EXECUTE_IF_SET_IN_BITMAP (reexamine, 0, i, bi)
|
if (bitmap_bit_p (osi.reexamine, i))
|
if (bitmap_bit_p (osi.reexamine, i))
|
{
|
{
|
collect_object_sizes_for (&osi, ssa_name (i));
|
collect_object_sizes_for (&osi, ssa_name (i));
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "Reexamining ");
|
fprintf (dump_file, "Reexamining ");
|
print_generic_expr (dump_file, ssa_name (i),
|
print_generic_expr (dump_file, ssa_name (i),
|
dump_flags);
|
dump_flags);
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
}
|
}
|
}
|
}
|
}
|
}
|
while (osi.changed);
|
while (osi.changed);
|
|
|
BITMAP_FREE (reexamine);
|
BITMAP_FREE (reexamine);
|
}
|
}
|
EXECUTE_IF_SET_IN_BITMAP (osi.reexamine, 0, i, bi)
|
EXECUTE_IF_SET_IN_BITMAP (osi.reexamine, 0, i, bi)
|
bitmap_set_bit (computed[object_size_type], i);
|
bitmap_set_bit (computed[object_size_type], i);
|
|
|
/* Debugging dumps. */
|
/* Debugging dumps. */
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
EXECUTE_IF_SET_IN_BITMAP (osi.visited, 0, i, bi)
|
EXECUTE_IF_SET_IN_BITMAP (osi.visited, 0, i, bi)
|
if (object_sizes[object_size_type][i]
|
if (object_sizes[object_size_type][i]
|
!= unknown[object_size_type])
|
!= unknown[object_size_type])
|
{
|
{
|
print_generic_expr (dump_file, ssa_name (i),
|
print_generic_expr (dump_file, ssa_name (i),
|
dump_flags);
|
dump_flags);
|
fprintf (dump_file,
|
fprintf (dump_file,
|
": %s %sobject size "
|
": %s %sobject size "
|
HOST_WIDE_INT_PRINT_UNSIGNED "\n",
|
HOST_WIDE_INT_PRINT_UNSIGNED "\n",
|
(object_size_type & 2) ? "minimum" : "maximum",
|
(object_size_type & 2) ? "minimum" : "maximum",
|
(object_size_type & 1) ? "sub" : "",
|
(object_size_type & 1) ? "sub" : "",
|
object_sizes[object_size_type][i]);
|
object_sizes[object_size_type][i]);
|
}
|
}
|
}
|
}
|
|
|
BITMAP_FREE (osi.reexamine);
|
BITMAP_FREE (osi.reexamine);
|
BITMAP_FREE (osi.visited);
|
BITMAP_FREE (osi.visited);
|
}
|
}
|
|
|
return object_sizes[object_size_type][SSA_NAME_VERSION (ptr)];
|
return object_sizes[object_size_type][SSA_NAME_VERSION (ptr)];
|
}
|
}
|
|
|
return unknown[object_size_type];
|
return unknown[object_size_type];
|
}
|
}
|
|
|
|
|
/* Compute object_sizes for PTR, defined to VALUE, which is not
|
/* Compute object_sizes for PTR, defined to VALUE, which is not
|
a SSA_NAME. */
|
a SSA_NAME. */
|
|
|
static void
|
static void
|
expr_object_size (struct object_size_info *osi, tree ptr, tree value)
|
expr_object_size (struct object_size_info *osi, tree ptr, tree value)
|
{
|
{
|
int object_size_type = osi->object_size_type;
|
int object_size_type = osi->object_size_type;
|
unsigned int varno = SSA_NAME_VERSION (ptr);
|
unsigned int varno = SSA_NAME_VERSION (ptr);
|
unsigned HOST_WIDE_INT bytes;
|
unsigned HOST_WIDE_INT bytes;
|
|
|
gcc_assert (object_sizes[object_size_type][varno]
|
gcc_assert (object_sizes[object_size_type][varno]
|
!= unknown[object_size_type]);
|
!= unknown[object_size_type]);
|
gcc_assert (osi->pass == 0);
|
gcc_assert (osi->pass == 0);
|
|
|
if (TREE_CODE (value) == WITH_SIZE_EXPR)
|
if (TREE_CODE (value) == WITH_SIZE_EXPR)
|
value = TREE_OPERAND (value, 0);
|
value = TREE_OPERAND (value, 0);
|
|
|
/* Pointer variables should have been handled by merge_object_sizes. */
|
/* Pointer variables should have been handled by merge_object_sizes. */
|
gcc_assert (TREE_CODE (value) != SSA_NAME
|
gcc_assert (TREE_CODE (value) != SSA_NAME
|
|| !POINTER_TYPE_P (TREE_TYPE (value)));
|
|| !POINTER_TYPE_P (TREE_TYPE (value)));
|
|
|
if (TREE_CODE (value) == ADDR_EXPR)
|
if (TREE_CODE (value) == ADDR_EXPR)
|
bytes = addr_object_size (value, object_size_type);
|
bytes = addr_object_size (value, object_size_type);
|
else if (TREE_CODE (value) == CALL_EXPR)
|
else if (TREE_CODE (value) == CALL_EXPR)
|
bytes = alloc_object_size (value, object_size_type);
|
bytes = alloc_object_size (value, object_size_type);
|
else
|
else
|
bytes = unknown[object_size_type];
|
bytes = unknown[object_size_type];
|
|
|
if ((object_size_type & 2) == 0)
|
if ((object_size_type & 2) == 0)
|
{
|
{
|
if (object_sizes[object_size_type][varno] < bytes)
|
if (object_sizes[object_size_type][varno] < bytes)
|
object_sizes[object_size_type][varno] = bytes;
|
object_sizes[object_size_type][varno] = bytes;
|
}
|
}
|
else
|
else
|
{
|
{
|
if (object_sizes[object_size_type][varno] > bytes)
|
if (object_sizes[object_size_type][varno] > bytes)
|
object_sizes[object_size_type][varno] = bytes;
|
object_sizes[object_size_type][varno] = bytes;
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Merge object sizes of ORIG + OFFSET into DEST. Return true if
|
/* Merge object sizes of ORIG + OFFSET into DEST. Return true if
|
the object size might need reexamination later. */
|
the object size might need reexamination later. */
|
|
|
static bool
|
static bool
|
merge_object_sizes (struct object_size_info *osi, tree dest, tree orig,
|
merge_object_sizes (struct object_size_info *osi, tree dest, tree orig,
|
unsigned HOST_WIDE_INT offset)
|
unsigned HOST_WIDE_INT offset)
|
{
|
{
|
int object_size_type = osi->object_size_type;
|
int object_size_type = osi->object_size_type;
|
unsigned int varno = SSA_NAME_VERSION (dest);
|
unsigned int varno = SSA_NAME_VERSION (dest);
|
unsigned HOST_WIDE_INT orig_bytes;
|
unsigned HOST_WIDE_INT orig_bytes;
|
|
|
if (object_sizes[object_size_type][varno] == unknown[object_size_type])
|
if (object_sizes[object_size_type][varno] == unknown[object_size_type])
|
return false;
|
return false;
|
if (offset >= offset_limit)
|
if (offset >= offset_limit)
|
{
|
{
|
object_sizes[object_size_type][varno] = unknown[object_size_type];
|
object_sizes[object_size_type][varno] = unknown[object_size_type];
|
return false;
|
return false;
|
}
|
}
|
|
|
if (osi->pass == 0)
|
if (osi->pass == 0)
|
collect_object_sizes_for (osi, orig);
|
collect_object_sizes_for (osi, orig);
|
|
|
orig_bytes = object_sizes[object_size_type][SSA_NAME_VERSION (orig)];
|
orig_bytes = object_sizes[object_size_type][SSA_NAME_VERSION (orig)];
|
if (orig_bytes != unknown[object_size_type])
|
if (orig_bytes != unknown[object_size_type])
|
orig_bytes = (offset > orig_bytes)
|
orig_bytes = (offset > orig_bytes)
|
? (unsigned HOST_WIDE_INT) 0 : orig_bytes - offset;
|
? (unsigned HOST_WIDE_INT) 0 : orig_bytes - offset;
|
|
|
if ((object_size_type & 2) == 0)
|
if ((object_size_type & 2) == 0)
|
{
|
{
|
if (object_sizes[object_size_type][varno] < orig_bytes)
|
if (object_sizes[object_size_type][varno] < orig_bytes)
|
{
|
{
|
object_sizes[object_size_type][varno] = orig_bytes;
|
object_sizes[object_size_type][varno] = orig_bytes;
|
osi->changed = true;
|
osi->changed = true;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
if (object_sizes[object_size_type][varno] > orig_bytes)
|
if (object_sizes[object_size_type][varno] > orig_bytes)
|
{
|
{
|
object_sizes[object_size_type][varno] = orig_bytes;
|
object_sizes[object_size_type][varno] = orig_bytes;
|
osi->changed = true;
|
osi->changed = true;
|
}
|
}
|
}
|
}
|
return bitmap_bit_p (osi->reexamine, SSA_NAME_VERSION (orig));
|
return bitmap_bit_p (osi->reexamine, SSA_NAME_VERSION (orig));
|
}
|
}
|
|
|
|
|
/* Compute object_sizes for PTR, defined to VALUE, which is
|
/* Compute object_sizes for PTR, defined to VALUE, which is
|
a PLUS_EXPR. Return true if the object size might need reexamination
|
a PLUS_EXPR. Return true if the object size might need reexamination
|
later. */
|
later. */
|
|
|
static bool
|
static bool
|
plus_expr_object_size (struct object_size_info *osi, tree var, tree value)
|
plus_expr_object_size (struct object_size_info *osi, tree var, tree value)
|
{
|
{
|
tree op0 = TREE_OPERAND (value, 0);
|
tree op0 = TREE_OPERAND (value, 0);
|
tree op1 = TREE_OPERAND (value, 1);
|
tree op1 = TREE_OPERAND (value, 1);
|
bool ptr1_p = POINTER_TYPE_P (TREE_TYPE (op0))
|
bool ptr1_p = POINTER_TYPE_P (TREE_TYPE (op0))
|
&& TREE_CODE (op0) != INTEGER_CST;
|
&& TREE_CODE (op0) != INTEGER_CST;
|
bool ptr2_p = POINTER_TYPE_P (TREE_TYPE (op1))
|
bool ptr2_p = POINTER_TYPE_P (TREE_TYPE (op1))
|
&& TREE_CODE (op1) != INTEGER_CST;
|
&& TREE_CODE (op1) != INTEGER_CST;
|
int object_size_type = osi->object_size_type;
|
int object_size_type = osi->object_size_type;
|
unsigned int varno = SSA_NAME_VERSION (var);
|
unsigned int varno = SSA_NAME_VERSION (var);
|
unsigned HOST_WIDE_INT bytes;
|
unsigned HOST_WIDE_INT bytes;
|
|
|
gcc_assert (TREE_CODE (value) == PLUS_EXPR);
|
gcc_assert (TREE_CODE (value) == PLUS_EXPR);
|
|
|
if (object_sizes[object_size_type][varno] == unknown[object_size_type])
|
if (object_sizes[object_size_type][varno] == unknown[object_size_type])
|
return false;
|
return false;
|
|
|
/* Swap operands if needed. */
|
/* Swap operands if needed. */
|
if (ptr2_p && !ptr1_p)
|
if (ptr2_p && !ptr1_p)
|
{
|
{
|
tree tem = op0;
|
tree tem = op0;
|
op0 = op1;
|
op0 = op1;
|
op1 = tem;
|
op1 = tem;
|
ptr1_p = true;
|
ptr1_p = true;
|
ptr2_p = false;
|
ptr2_p = false;
|
}
|
}
|
|
|
/* Handle PTR + OFFSET here. */
|
/* Handle PTR + OFFSET here. */
|
if (ptr1_p
|
if (ptr1_p
|
&& !ptr2_p
|
&& !ptr2_p
|
&& TREE_CODE (op1) == INTEGER_CST
|
&& TREE_CODE (op1) == INTEGER_CST
|
&& (TREE_CODE (op0) == SSA_NAME
|
&& (TREE_CODE (op0) == SSA_NAME
|
|| TREE_CODE (op0) == ADDR_EXPR))
|
|| TREE_CODE (op0) == ADDR_EXPR))
|
{
|
{
|
if (! host_integerp (op1, 1))
|
if (! host_integerp (op1, 1))
|
bytes = unknown[object_size_type];
|
bytes = unknown[object_size_type];
|
else if (TREE_CODE (op0) == SSA_NAME)
|
else if (TREE_CODE (op0) == SSA_NAME)
|
return merge_object_sizes (osi, var, op0, tree_low_cst (op1, 1));
|
return merge_object_sizes (osi, var, op0, tree_low_cst (op1, 1));
|
else
|
else
|
{
|
{
|
unsigned HOST_WIDE_INT off = tree_low_cst (op1, 1);
|
unsigned HOST_WIDE_INT off = tree_low_cst (op1, 1);
|
|
|
bytes = compute_builtin_object_size (op0, object_size_type);
|
bytes = compute_builtin_object_size (op0, object_size_type);
|
if (off > offset_limit)
|
if (off > offset_limit)
|
bytes = unknown[object_size_type];
|
bytes = unknown[object_size_type];
|
else if (off > bytes)
|
else if (off > bytes)
|
bytes = 0;
|
bytes = 0;
|
else
|
else
|
bytes -= off;
|
bytes -= off;
|
}
|
}
|
}
|
}
|
else
|
else
|
bytes = unknown[object_size_type];
|
bytes = unknown[object_size_type];
|
|
|
if ((object_size_type & 2) == 0)
|
if ((object_size_type & 2) == 0)
|
{
|
{
|
if (object_sizes[object_size_type][varno] < bytes)
|
if (object_sizes[object_size_type][varno] < bytes)
|
object_sizes[object_size_type][varno] = bytes;
|
object_sizes[object_size_type][varno] = bytes;
|
}
|
}
|
else
|
else
|
{
|
{
|
if (object_sizes[object_size_type][varno] > bytes)
|
if (object_sizes[object_size_type][varno] > bytes)
|
object_sizes[object_size_type][varno] = bytes;
|
object_sizes[object_size_type][varno] = bytes;
|
}
|
}
|
return false;
|
return false;
|
}
|
}
|
|
|
|
|
/* Compute object sizes for VAR.
|
/* Compute object sizes for VAR.
|
For ADDR_EXPR an object size is the number of remaining bytes
|
For ADDR_EXPR an object size is the number of remaining bytes
|
to the end of the object (where what is considered an object depends on
|
to the end of the object (where what is considered an object depends on
|
OSI->object_size_type).
|
OSI->object_size_type).
|
For allocation CALL_EXPR like malloc or calloc object size is the size
|
For allocation CALL_EXPR like malloc or calloc object size is the size
|
of the allocation.
|
of the allocation.
|
For pointer PLUS_EXPR where second operand is a constant integer,
|
For pointer PLUS_EXPR where second operand is a constant integer,
|
object size is object size of the first operand minus the constant.
|
object size is object size of the first operand minus the constant.
|
If the constant is bigger than the number of remaining bytes until the
|
If the constant is bigger than the number of remaining bytes until the
|
end of the object, object size is 0, but if it is instead a pointer
|
end of the object, object size is 0, but if it is instead a pointer
|
subtraction, object size is unknown[object_size_type].
|
subtraction, object size is unknown[object_size_type].
|
To differentiate addition from subtraction, ADDR_EXPR returns
|
To differentiate addition from subtraction, ADDR_EXPR returns
|
unknown[object_size_type] for all objects bigger than half of the address
|
unknown[object_size_type] for all objects bigger than half of the address
|
space, and constants less than half of the address space are considered
|
space, and constants less than half of the address space are considered
|
addition, while bigger constants subtraction.
|
addition, while bigger constants subtraction.
|
For a memcpy like CALL_EXPR that always returns one of its arguments, the
|
For a memcpy like CALL_EXPR that always returns one of its arguments, the
|
object size is object size of that argument.
|
object size is object size of that argument.
|
Otherwise, object size is the maximum of object sizes of variables
|
Otherwise, object size is the maximum of object sizes of variables
|
that it might be set to. */
|
that it might be set to. */
|
|
|
static void
|
static void
|
collect_object_sizes_for (struct object_size_info *osi, tree var)
|
collect_object_sizes_for (struct object_size_info *osi, tree var)
|
{
|
{
|
int object_size_type = osi->object_size_type;
|
int object_size_type = osi->object_size_type;
|
unsigned int varno = SSA_NAME_VERSION (var);
|
unsigned int varno = SSA_NAME_VERSION (var);
|
tree stmt;
|
tree stmt;
|
bool reexamine;
|
bool reexamine;
|
|
|
if (bitmap_bit_p (computed[object_size_type], varno))
|
if (bitmap_bit_p (computed[object_size_type], varno))
|
return;
|
return;
|
|
|
if (osi->pass == 0)
|
if (osi->pass == 0)
|
{
|
{
|
if (! bitmap_bit_p (osi->visited, varno))
|
if (! bitmap_bit_p (osi->visited, varno))
|
{
|
{
|
bitmap_set_bit (osi->visited, varno);
|
bitmap_set_bit (osi->visited, varno);
|
object_sizes[object_size_type][varno]
|
object_sizes[object_size_type][varno]
|
= (object_size_type & 2) ? -1 : 0;
|
= (object_size_type & 2) ? -1 : 0;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Found a dependency loop. Mark the variable for later
|
/* Found a dependency loop. Mark the variable for later
|
re-examination. */
|
re-examination. */
|
bitmap_set_bit (osi->reexamine, varno);
|
bitmap_set_bit (osi->reexamine, varno);
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "Found a dependency loop at ");
|
fprintf (dump_file, "Found a dependency loop at ");
|
print_generic_expr (dump_file, var, dump_flags);
|
print_generic_expr (dump_file, var, dump_flags);
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
}
|
}
|
return;
|
return;
|
}
|
}
|
}
|
}
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "Visiting use-def links for ");
|
fprintf (dump_file, "Visiting use-def links for ");
|
print_generic_expr (dump_file, var, dump_flags);
|
print_generic_expr (dump_file, var, dump_flags);
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
}
|
}
|
|
|
stmt = SSA_NAME_DEF_STMT (var);
|
stmt = SSA_NAME_DEF_STMT (var);
|
reexamine = false;
|
reexamine = false;
|
|
|
switch (TREE_CODE (stmt))
|
switch (TREE_CODE (stmt))
|
{
|
{
|
case RETURN_EXPR:
|
case RETURN_EXPR:
|
gcc_assert (TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR);
|
gcc_assert (TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR);
|
stmt = TREE_OPERAND (stmt, 0);
|
stmt = TREE_OPERAND (stmt, 0);
|
/* FALLTHRU */
|
/* FALLTHRU */
|
|
|
case MODIFY_EXPR:
|
case MODIFY_EXPR:
|
{
|
{
|
tree rhs = TREE_OPERAND (stmt, 1), arg;
|
tree rhs = TREE_OPERAND (stmt, 1), arg;
|
STRIP_NOPS (rhs);
|
STRIP_NOPS (rhs);
|
|
|
if (TREE_CODE (rhs) == CALL_EXPR)
|
if (TREE_CODE (rhs) == CALL_EXPR)
|
{
|
{
|
arg = pass_through_call (rhs);
|
arg = pass_through_call (rhs);
|
if (arg)
|
if (arg)
|
rhs = arg;
|
rhs = arg;
|
}
|
}
|
|
|
if (TREE_CODE (rhs) == SSA_NAME
|
if (TREE_CODE (rhs) == SSA_NAME
|
&& POINTER_TYPE_P (TREE_TYPE (rhs)))
|
&& POINTER_TYPE_P (TREE_TYPE (rhs)))
|
reexamine = merge_object_sizes (osi, var, rhs, 0);
|
reexamine = merge_object_sizes (osi, var, rhs, 0);
|
|
|
else if (TREE_CODE (rhs) == PLUS_EXPR)
|
else if (TREE_CODE (rhs) == PLUS_EXPR)
|
reexamine = plus_expr_object_size (osi, var, rhs);
|
reexamine = plus_expr_object_size (osi, var, rhs);
|
|
|
else
|
else
|
expr_object_size (osi, var, rhs);
|
expr_object_size (osi, var, rhs);
|
break;
|
break;
|
}
|
}
|
|
|
case ASM_EXPR:
|
case ASM_EXPR:
|
/* Pointers defined by __asm__ statements can point anywhere. */
|
/* Pointers defined by __asm__ statements can point anywhere. */
|
object_sizes[object_size_type][varno] = unknown[object_size_type];
|
object_sizes[object_size_type][varno] = unknown[object_size_type];
|
break;
|
break;
|
|
|
case NOP_EXPR:
|
case NOP_EXPR:
|
{
|
{
|
tree decl = SSA_NAME_VAR (var);
|
tree decl = SSA_NAME_VAR (var);
|
|
|
gcc_assert (IS_EMPTY_STMT (stmt));
|
gcc_assert (IS_EMPTY_STMT (stmt));
|
|
|
if (TREE_CODE (decl) != PARM_DECL && DECL_INITIAL (decl))
|
if (TREE_CODE (decl) != PARM_DECL && DECL_INITIAL (decl))
|
expr_object_size (osi, var, DECL_INITIAL (decl));
|
expr_object_size (osi, var, DECL_INITIAL (decl));
|
else
|
else
|
expr_object_size (osi, var, decl);
|
expr_object_size (osi, var, decl);
|
}
|
}
|
break;
|
break;
|
|
|
case PHI_NODE:
|
case PHI_NODE:
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = 0; i < PHI_NUM_ARGS (stmt); i++)
|
for (i = 0; i < PHI_NUM_ARGS (stmt); i++)
|
{
|
{
|
tree rhs = PHI_ARG_DEF (stmt, i);
|
tree rhs = PHI_ARG_DEF (stmt, i);
|
|
|
if (object_sizes[object_size_type][varno]
|
if (object_sizes[object_size_type][varno]
|
== unknown[object_size_type])
|
== unknown[object_size_type])
|
break;
|
break;
|
|
|
if (TREE_CODE (rhs) == SSA_NAME)
|
if (TREE_CODE (rhs) == SSA_NAME)
|
reexamine |= merge_object_sizes (osi, var, rhs, 0);
|
reexamine |= merge_object_sizes (osi, var, rhs, 0);
|
else if (osi->pass == 0)
|
else if (osi->pass == 0)
|
expr_object_size (osi, var, rhs);
|
expr_object_size (osi, var, rhs);
|
}
|
}
|
break;
|
break;
|
}
|
}
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
if (! reexamine
|
if (! reexamine
|
|| object_sizes[object_size_type][varno] == unknown[object_size_type])
|
|| object_sizes[object_size_type][varno] == unknown[object_size_type])
|
{
|
{
|
bitmap_set_bit (computed[object_size_type], varno);
|
bitmap_set_bit (computed[object_size_type], varno);
|
bitmap_clear_bit (osi->reexamine, varno);
|
bitmap_clear_bit (osi->reexamine, varno);
|
}
|
}
|
else
|
else
|
{
|
{
|
bitmap_set_bit (osi->reexamine, varno);
|
bitmap_set_bit (osi->reexamine, varno);
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "Need to reexamine ");
|
fprintf (dump_file, "Need to reexamine ");
|
print_generic_expr (dump_file, var, dump_flags);
|
print_generic_expr (dump_file, var, dump_flags);
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Helper function for check_for_plus_in_loops. Called recursively
|
/* Helper function for check_for_plus_in_loops. Called recursively
|
to detect loops. */
|
to detect loops. */
|
|
|
static void
|
static void
|
check_for_plus_in_loops_1 (struct object_size_info *osi, tree var,
|
check_for_plus_in_loops_1 (struct object_size_info *osi, tree var,
|
unsigned int depth)
|
unsigned int depth)
|
{
|
{
|
tree stmt = SSA_NAME_DEF_STMT (var);
|
tree stmt = SSA_NAME_DEF_STMT (var);
|
unsigned int varno = SSA_NAME_VERSION (var);
|
unsigned int varno = SSA_NAME_VERSION (var);
|
|
|
if (osi->depths[varno])
|
if (osi->depths[varno])
|
{
|
{
|
if (osi->depths[varno] != depth)
|
if (osi->depths[varno] != depth)
|
{
|
{
|
unsigned int *sp;
|
unsigned int *sp;
|
|
|
/* Found a loop involving pointer addition. */
|
/* Found a loop involving pointer addition. */
|
for (sp = osi->tos; sp > osi->stack; )
|
for (sp = osi->tos; sp > osi->stack; )
|
{
|
{
|
--sp;
|
--sp;
|
bitmap_clear_bit (osi->reexamine, *sp);
|
bitmap_clear_bit (osi->reexamine, *sp);
|
bitmap_set_bit (computed[osi->object_size_type], *sp);
|
bitmap_set_bit (computed[osi->object_size_type], *sp);
|
object_sizes[osi->object_size_type][*sp] = 0;
|
object_sizes[osi->object_size_type][*sp] = 0;
|
if (*sp == varno)
|
if (*sp == varno)
|
break;
|
break;
|
}
|
}
|
}
|
}
|
return;
|
return;
|
}
|
}
|
else if (! bitmap_bit_p (osi->reexamine, varno))
|
else if (! bitmap_bit_p (osi->reexamine, varno))
|
return;
|
return;
|
|
|
osi->depths[varno] = depth;
|
osi->depths[varno] = depth;
|
*osi->tos++ = varno;
|
*osi->tos++ = varno;
|
|
|
switch (TREE_CODE (stmt))
|
switch (TREE_CODE (stmt))
|
{
|
{
|
case RETURN_EXPR:
|
case RETURN_EXPR:
|
gcc_assert (TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR);
|
gcc_assert (TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR);
|
stmt = TREE_OPERAND (stmt, 0);
|
stmt = TREE_OPERAND (stmt, 0);
|
/* FALLTHRU */
|
/* FALLTHRU */
|
|
|
case MODIFY_EXPR:
|
case MODIFY_EXPR:
|
{
|
{
|
tree rhs = TREE_OPERAND (stmt, 1), arg;
|
tree rhs = TREE_OPERAND (stmt, 1), arg;
|
STRIP_NOPS (rhs);
|
STRIP_NOPS (rhs);
|
|
|
if (TREE_CODE (rhs) == CALL_EXPR)
|
if (TREE_CODE (rhs) == CALL_EXPR)
|
{
|
{
|
arg = pass_through_call (rhs);
|
arg = pass_through_call (rhs);
|
if (arg)
|
if (arg)
|
rhs = arg;
|
rhs = arg;
|
}
|
}
|
|
|
if (TREE_CODE (rhs) == SSA_NAME)
|
if (TREE_CODE (rhs) == SSA_NAME)
|
check_for_plus_in_loops_1 (osi, rhs, depth);
|
check_for_plus_in_loops_1 (osi, rhs, depth);
|
else if (TREE_CODE (rhs) == PLUS_EXPR)
|
else if (TREE_CODE (rhs) == PLUS_EXPR)
|
{
|
{
|
tree op0 = TREE_OPERAND (rhs, 0);
|
tree op0 = TREE_OPERAND (rhs, 0);
|
tree op1 = TREE_OPERAND (rhs, 1);
|
tree op1 = TREE_OPERAND (rhs, 1);
|
tree cst, basevar;
|
tree cst, basevar;
|
|
|
if (TREE_CODE (op0) == SSA_NAME)
|
if (TREE_CODE (op0) == SSA_NAME)
|
{
|
{
|
basevar = op0;
|
basevar = op0;
|
cst = op1;
|
cst = op1;
|
}
|
}
|
else
|
else
|
{
|
{
|
basevar = op1;
|
basevar = op1;
|
cst = op0;
|
cst = op0;
|
gcc_assert (TREE_CODE (basevar) == SSA_NAME);
|
gcc_assert (TREE_CODE (basevar) == SSA_NAME);
|
}
|
}
|
gcc_assert (TREE_CODE (cst) == INTEGER_CST);
|
gcc_assert (TREE_CODE (cst) == INTEGER_CST);
|
|
|
check_for_plus_in_loops_1 (osi, basevar,
|
check_for_plus_in_loops_1 (osi, basevar,
|
depth + !integer_zerop (cst));
|
depth + !integer_zerop (cst));
|
}
|
}
|
else
|
else
|
gcc_unreachable ();
|
gcc_unreachable ();
|
break;
|
break;
|
}
|
}
|
case PHI_NODE:
|
case PHI_NODE:
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = 0; i < PHI_NUM_ARGS (stmt); i++)
|
for (i = 0; i < PHI_NUM_ARGS (stmt); i++)
|
{
|
{
|
tree rhs = PHI_ARG_DEF (stmt, i);
|
tree rhs = PHI_ARG_DEF (stmt, i);
|
|
|
if (TREE_CODE (rhs) == SSA_NAME)
|
if (TREE_CODE (rhs) == SSA_NAME)
|
check_for_plus_in_loops_1 (osi, rhs, depth);
|
check_for_plus_in_loops_1 (osi, rhs, depth);
|
}
|
}
|
break;
|
break;
|
}
|
}
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
osi->depths[varno] = 0;
|
osi->depths[varno] = 0;
|
osi->tos--;
|
osi->tos--;
|
}
|
}
|
|
|
|
|
/* Check if some pointer we are computing object size of is being increased
|
/* Check if some pointer we are computing object size of is being increased
|
within a loop. If yes, assume all the SSA variables participating in
|
within a loop. If yes, assume all the SSA variables participating in
|
that loop have minimum object sizes 0. */
|
that loop have minimum object sizes 0. */
|
|
|
static void
|
static void
|
check_for_plus_in_loops (struct object_size_info *osi, tree var)
|
check_for_plus_in_loops (struct object_size_info *osi, tree var)
|
{
|
{
|
tree stmt = SSA_NAME_DEF_STMT (var);
|
tree stmt = SSA_NAME_DEF_STMT (var);
|
|
|
switch (TREE_CODE (stmt))
|
switch (TREE_CODE (stmt))
|
{
|
{
|
case RETURN_EXPR:
|
case RETURN_EXPR:
|
gcc_assert (TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR);
|
gcc_assert (TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR);
|
stmt = TREE_OPERAND (stmt, 0);
|
stmt = TREE_OPERAND (stmt, 0);
|
/* FALLTHRU */
|
/* FALLTHRU */
|
|
|
case MODIFY_EXPR:
|
case MODIFY_EXPR:
|
{
|
{
|
tree rhs = TREE_OPERAND (stmt, 1), arg;
|
tree rhs = TREE_OPERAND (stmt, 1), arg;
|
STRIP_NOPS (rhs);
|
STRIP_NOPS (rhs);
|
|
|
if (TREE_CODE (rhs) == CALL_EXPR)
|
if (TREE_CODE (rhs) == CALL_EXPR)
|
{
|
{
|
arg = pass_through_call (rhs);
|
arg = pass_through_call (rhs);
|
if (arg)
|
if (arg)
|
rhs = arg;
|
rhs = arg;
|
}
|
}
|
|
|
if (TREE_CODE (rhs) == PLUS_EXPR)
|
if (TREE_CODE (rhs) == PLUS_EXPR)
|
{
|
{
|
tree op0 = TREE_OPERAND (rhs, 0);
|
tree op0 = TREE_OPERAND (rhs, 0);
|
tree op1 = TREE_OPERAND (rhs, 1);
|
tree op1 = TREE_OPERAND (rhs, 1);
|
tree cst, basevar;
|
tree cst, basevar;
|
|
|
if (TREE_CODE (op0) == SSA_NAME)
|
if (TREE_CODE (op0) == SSA_NAME)
|
{
|
{
|
basevar = op0;
|
basevar = op0;
|
cst = op1;
|
cst = op1;
|
}
|
}
|
else
|
else
|
{
|
{
|
basevar = op1;
|
basevar = op1;
|
cst = op0;
|
cst = op0;
|
gcc_assert (TREE_CODE (basevar) == SSA_NAME);
|
gcc_assert (TREE_CODE (basevar) == SSA_NAME);
|
}
|
}
|
gcc_assert (TREE_CODE (cst) == INTEGER_CST);
|
gcc_assert (TREE_CODE (cst) == INTEGER_CST);
|
|
|
if (integer_zerop (cst))
|
if (integer_zerop (cst))
|
break;
|
break;
|
|
|
osi->depths[SSA_NAME_VERSION (basevar)] = 1;
|
osi->depths[SSA_NAME_VERSION (basevar)] = 1;
|
*osi->tos++ = SSA_NAME_VERSION (basevar);
|
*osi->tos++ = SSA_NAME_VERSION (basevar);
|
check_for_plus_in_loops_1 (osi, var, 2);
|
check_for_plus_in_loops_1 (osi, var, 2);
|
osi->depths[SSA_NAME_VERSION (basevar)] = 0;
|
osi->depths[SSA_NAME_VERSION (basevar)] = 0;
|
osi->tos--;
|
osi->tos--;
|
}
|
}
|
break;
|
break;
|
}
|
}
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Initialize data structures for the object size computation. */
|
/* Initialize data structures for the object size computation. */
|
|
|
void
|
void
|
init_object_sizes (void)
|
init_object_sizes (void)
|
{
|
{
|
int object_size_type;
|
int object_size_type;
|
|
|
if (object_sizes[0])
|
if (object_sizes[0])
|
return;
|
return;
|
|
|
for (object_size_type = 0; object_size_type <= 3; object_size_type++)
|
for (object_size_type = 0; object_size_type <= 3; object_size_type++)
|
{
|
{
|
object_sizes[object_size_type] = XNEWVEC (unsigned HOST_WIDE_INT, num_ssa_names);
|
object_sizes[object_size_type] = XNEWVEC (unsigned HOST_WIDE_INT, num_ssa_names);
|
computed[object_size_type] = BITMAP_ALLOC (NULL);
|
computed[object_size_type] = BITMAP_ALLOC (NULL);
|
}
|
}
|
|
|
init_offset_limit ();
|
init_offset_limit ();
|
}
|
}
|
|
|
|
|
/* Destroy data structures after the object size computation. */
|
/* Destroy data structures after the object size computation. */
|
|
|
void
|
void
|
fini_object_sizes (void)
|
fini_object_sizes (void)
|
{
|
{
|
int object_size_type;
|
int object_size_type;
|
|
|
for (object_size_type = 0; object_size_type <= 3; object_size_type++)
|
for (object_size_type = 0; object_size_type <= 3; object_size_type++)
|
{
|
{
|
free (object_sizes[object_size_type]);
|
free (object_sizes[object_size_type]);
|
BITMAP_FREE (computed[object_size_type]);
|
BITMAP_FREE (computed[object_size_type]);
|
object_sizes[object_size_type] = NULL;
|
object_sizes[object_size_type] = NULL;
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Simple pass to optimize all __builtin_object_size () builtins. */
|
/* Simple pass to optimize all __builtin_object_size () builtins. */
|
|
|
static unsigned int
|
static unsigned int
|
compute_object_sizes (void)
|
compute_object_sizes (void)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
block_stmt_iterator i;
|
block_stmt_iterator i;
|
for (i = bsi_start (bb); !bsi_end_p (i); bsi_next (&i))
|
for (i = bsi_start (bb); !bsi_end_p (i); bsi_next (&i))
|
{
|
{
|
tree *stmtp = bsi_stmt_ptr (i);
|
tree *stmtp = bsi_stmt_ptr (i);
|
tree call = get_rhs (*stmtp);
|
tree call = get_rhs (*stmtp);
|
tree callee, result;
|
tree callee, result;
|
|
|
if (!call || TREE_CODE (call) != CALL_EXPR)
|
if (!call || TREE_CODE (call) != CALL_EXPR)
|
continue;
|
continue;
|
|
|
callee = get_callee_fndecl (call);
|
callee = get_callee_fndecl (call);
|
if (!callee
|
if (!callee
|
|| DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL
|
|| DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL
|
|| DECL_FUNCTION_CODE (callee) != BUILT_IN_OBJECT_SIZE)
|
|| DECL_FUNCTION_CODE (callee) != BUILT_IN_OBJECT_SIZE)
|
continue;
|
continue;
|
|
|
init_object_sizes ();
|
init_object_sizes ();
|
result = fold_builtin (callee, TREE_OPERAND (call, 1), false);
|
result = fold_builtin (callee, TREE_OPERAND (call, 1), false);
|
if (!result)
|
if (!result)
|
{
|
{
|
tree arglist = TREE_OPERAND (call, 1);
|
tree arglist = TREE_OPERAND (call, 1);
|
|
|
if (arglist != NULL
|
if (arglist != NULL
|
&& POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist)))
|
&& POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist)))
|
&& TREE_CHAIN (arglist) != NULL
|
&& TREE_CHAIN (arglist) != NULL
|
&& TREE_CHAIN (TREE_CHAIN (arglist)) == NULL)
|
&& TREE_CHAIN (TREE_CHAIN (arglist)) == NULL)
|
{
|
{
|
tree ost = TREE_VALUE (TREE_CHAIN (arglist));
|
tree ost = TREE_VALUE (TREE_CHAIN (arglist));
|
|
|
if (host_integerp (ost, 1))
|
if (host_integerp (ost, 1))
|
{
|
{
|
unsigned HOST_WIDE_INT object_size_type
|
unsigned HOST_WIDE_INT object_size_type
|
= tree_low_cst (ost, 1);
|
= tree_low_cst (ost, 1);
|
|
|
if (object_size_type < 2)
|
if (object_size_type < 2)
|
result = fold_convert (size_type_node,
|
result = fold_convert (size_type_node,
|
integer_minus_one_node);
|
integer_minus_one_node);
|
else if (object_size_type < 4)
|
else if (object_size_type < 4)
|
result = size_zero_node;
|
result = size_zero_node;
|
}
|
}
|
}
|
}
|
|
|
if (!result)
|
if (!result)
|
continue;
|
continue;
|
}
|
}
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "Simplified\n ");
|
fprintf (dump_file, "Simplified\n ");
|
print_generic_stmt (dump_file, *stmtp, dump_flags);
|
print_generic_stmt (dump_file, *stmtp, dump_flags);
|
}
|
}
|
|
|
if (!set_rhs (stmtp, result))
|
if (!set_rhs (stmtp, result))
|
gcc_unreachable ();
|
gcc_unreachable ();
|
update_stmt (*stmtp);
|
update_stmt (*stmtp);
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "to\n ");
|
fprintf (dump_file, "to\n ");
|
print_generic_stmt (dump_file, *stmtp, dump_flags);
|
print_generic_stmt (dump_file, *stmtp, dump_flags);
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
fini_object_sizes ();
|
fini_object_sizes ();
|
return 0;
|
return 0;
|
}
|
}
|
|
|
struct tree_opt_pass pass_object_sizes =
|
struct tree_opt_pass pass_object_sizes =
|
{
|
{
|
"objsz", /* name */
|
"objsz", /* name */
|
NULL, /* gate */
|
NULL, /* gate */
|
compute_object_sizes, /* execute */
|
compute_object_sizes, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
0, /* tv_id */
|
0, /* tv_id */
|
PROP_cfg | PROP_ssa | PROP_alias, /* properties_required */
|
PROP_cfg | PROP_ssa | PROP_alias, /* properties_required */
|
0, /* properties_provided */
|
0, /* properties_provided */
|
0, /* properties_destroyed */
|
0, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
TODO_dump_func | TODO_verify_ssa, /* todo_flags_finish */
|
TODO_dump_func | TODO_verify_ssa, /* todo_flags_finish */
|
0 /* letter */
|
0 /* letter */
|
};
|
};
|
|
|
