/* __builtin_object_size (ptr, object_size_type) computation
|
/* __builtin_object_size (ptr, object_size_type) computation
|
Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009
|
Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009
|
Free Software Foundation, Inc.
|
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 "toplev.h"
|
#include "toplev.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 (const_tree, const_tree);
|
static tree compute_object_offset (const_tree, const_tree);
|
static unsigned HOST_WIDE_INT addr_object_size (struct object_size_info *,
|
static unsigned HOST_WIDE_INT addr_object_size (struct object_size_info *,
|
const_tree, int);
|
const_tree, int);
|
static unsigned HOST_WIDE_INT alloc_object_size (const_gimple, int);
|
static unsigned HOST_WIDE_INT alloc_object_size (const_gimple, int);
|
static tree pass_through_call (const_gimple);
|
static tree pass_through_call (const_gimple);
|
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_stmt_object_size (struct object_size_info *, tree, gimple);
|
static bool plus_stmt_object_size (struct object_size_info *, tree, gimple);
|
static bool cond_expr_object_size (struct object_size_info *, tree, tree);
|
static bool cond_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 (const_tree expr, const_tree var)
|
compute_object_offset (const_tree expr, const_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_CONVERT:
|
CASE_CONVERT:
|
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 (struct object_size_info *osi, const_tree ptr,
|
addr_object_size (struct object_size_info *osi, const_tree ptr,
|
int object_size_type)
|
int object_size_type)
|
{
|
{
|
tree pt_var, pt_var_size = NULL_TREE, var_size, bytes;
|
tree pt_var, pt_var_size = NULL_TREE, var_size, bytes;
|
|
|
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
|
&& TREE_CODE (pt_var) == INDIRECT_REF
|
&& TREE_CODE (pt_var) == INDIRECT_REF
|
&& TREE_CODE (TREE_OPERAND (pt_var, 0)) == SSA_NAME
|
&& TREE_CODE (TREE_OPERAND (pt_var, 0)) == SSA_NAME
|
&& POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (pt_var, 0))))
|
&& POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (pt_var, 0))))
|
{
|
{
|
unsigned HOST_WIDE_INT sz;
|
unsigned HOST_WIDE_INT sz;
|
|
|
if (!osi || (object_size_type & 1) != 0)
|
if (!osi || (object_size_type & 1) != 0)
|
sz = compute_builtin_object_size (TREE_OPERAND (pt_var, 0),
|
sz = compute_builtin_object_size (TREE_OPERAND (pt_var, 0),
|
object_size_type & ~1);
|
object_size_type & ~1);
|
else
|
else
|
{
|
{
|
tree var = TREE_OPERAND (pt_var, 0);
|
tree var = TREE_OPERAND (pt_var, 0);
|
if (osi->pass == 0)
|
if (osi->pass == 0)
|
collect_object_sizes_for (osi, var);
|
collect_object_sizes_for (osi, var);
|
if (bitmap_bit_p (computed[object_size_type],
|
if (bitmap_bit_p (computed[object_size_type],
|
SSA_NAME_VERSION (var)))
|
SSA_NAME_VERSION (var)))
|
sz = object_sizes[object_size_type][SSA_NAME_VERSION (var)];
|
sz = object_sizes[object_size_type][SSA_NAME_VERSION (var)];
|
else
|
else
|
sz = unknown[object_size_type];
|
sz = unknown[object_size_type];
|
}
|
}
|
|
|
if (sz != unknown[object_size_type] && sz < offset_limit)
|
if (sz != unknown[object_size_type] && sz < offset_limit)
|
pt_var_size = size_int (sz);
|
pt_var_size = size_int (sz);
|
}
|
}
|
else if (pt_var
|
else 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)
|
tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (pt_var)), 1)
|
< offset_limit)
|
< offset_limit)
|
pt_var_size = TYPE_SIZE_UNIT (TREE_TYPE (pt_var));
|
pt_var_size = TYPE_SIZE_UNIT (TREE_TYPE (pt_var));
|
else
|
else
|
return unknown[object_size_type];
|
return unknown[object_size_type];
|
|
|
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)
|
|| (pt_var_size
|
|| (pt_var_size
|
&& tree_int_cst_lt (pt_var_size,
|
&& tree_int_cst_lt (pt_var_size,
|
TYPE_SIZE_UNIT (TREE_TYPE (var)))))
|
TYPE_SIZE_UNIT (TREE_TYPE (var)))))
|
var = pt_var;
|
var = pt_var;
|
else if (var != pt_var && TREE_CODE (pt_var) == INDIRECT_REF)
|
else if (var != pt_var && TREE_CODE (pt_var) == INDIRECT_REF)
|
{
|
{
|
tree v = var;
|
tree v = var;
|
/* For &X->fld, compute object size only if fld isn't the last
|
/* For &X->fld, compute object size only if fld isn't the last
|
field, as struct { int i; char c[1]; } is often used instead
|
field, as struct { int i; char c[1]; } is often used instead
|
of flexible array member. */
|
of flexible array member. */
|
while (v && v != pt_var)
|
while (v && v != pt_var)
|
switch (TREE_CODE (v))
|
switch (TREE_CODE (v))
|
{
|
{
|
case ARRAY_REF:
|
case ARRAY_REF:
|
if (TYPE_SIZE_UNIT (TREE_TYPE (TREE_OPERAND (v, 0)))
|
if (TYPE_SIZE_UNIT (TREE_TYPE (TREE_OPERAND (v, 0)))
|
&& TREE_CODE (TREE_OPERAND (v, 1)) == INTEGER_CST)
|
&& TREE_CODE (TREE_OPERAND (v, 1)) == INTEGER_CST)
|
{
|
{
|
tree domain
|
tree domain
|
= TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (v, 0)));
|
= TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (v, 0)));
|
if (domain
|
if (domain
|
&& TYPE_MAX_VALUE (domain)
|
&& TYPE_MAX_VALUE (domain)
|
&& TREE_CODE (TYPE_MAX_VALUE (domain))
|
&& TREE_CODE (TYPE_MAX_VALUE (domain))
|
== INTEGER_CST
|
== INTEGER_CST
|
&& tree_int_cst_lt (TREE_OPERAND (v, 1),
|
&& tree_int_cst_lt (TREE_OPERAND (v, 1),
|
TYPE_MAX_VALUE (domain)))
|
TYPE_MAX_VALUE (domain)))
|
{
|
{
|
v = NULL_TREE;
|
v = NULL_TREE;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
v = TREE_OPERAND (v, 0);
|
v = TREE_OPERAND (v, 0);
|
break;
|
break;
|
case REALPART_EXPR:
|
case REALPART_EXPR:
|
case IMAGPART_EXPR:
|
case IMAGPART_EXPR:
|
v = NULL_TREE;
|
v = NULL_TREE;
|
break;
|
break;
|
case COMPONENT_REF:
|
case COMPONENT_REF:
|
if (TREE_CODE (TREE_TYPE (v)) != ARRAY_TYPE)
|
if (TREE_CODE (TREE_TYPE (v)) != ARRAY_TYPE)
|
{
|
{
|
v = NULL_TREE;
|
v = NULL_TREE;
|
break;
|
break;
|
}
|
}
|
while (v != pt_var && TREE_CODE (v) == COMPONENT_REF)
|
while (v != pt_var && TREE_CODE (v) == COMPONENT_REF)
|
if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
|
if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
|
!= UNION_TYPE
|
!= UNION_TYPE
|
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
|
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
|
!= QUAL_UNION_TYPE)
|
!= QUAL_UNION_TYPE)
|
break;
|
break;
|
else
|
else
|
v = TREE_OPERAND (v, 0);
|
v = TREE_OPERAND (v, 0);
|
if (TREE_CODE (v) == COMPONENT_REF
|
if (TREE_CODE (v) == COMPONENT_REF
|
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
|
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
|
== RECORD_TYPE)
|
== RECORD_TYPE)
|
{
|
{
|
tree fld_chain = TREE_CHAIN (TREE_OPERAND (v, 1));
|
tree fld_chain = TREE_CHAIN (TREE_OPERAND (v, 1));
|
for (; fld_chain; fld_chain = TREE_CHAIN (fld_chain))
|
for (; fld_chain; fld_chain = TREE_CHAIN (fld_chain))
|
if (TREE_CODE (fld_chain) == FIELD_DECL)
|
if (TREE_CODE (fld_chain) == FIELD_DECL)
|
break;
|
break;
|
|
|
if (fld_chain)
|
if (fld_chain)
|
{
|
{
|
v = NULL_TREE;
|
v = NULL_TREE;
|
break;
|
break;
|
}
|
}
|
v = TREE_OPERAND (v, 0);
|
v = TREE_OPERAND (v, 0);
|
}
|
}
|
while (v != pt_var && TREE_CODE (v) == COMPONENT_REF)
|
while (v != pt_var && TREE_CODE (v) == COMPONENT_REF)
|
if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
|
if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
|
!= UNION_TYPE
|
!= UNION_TYPE
|
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
|
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
|
!= QUAL_UNION_TYPE)
|
!= QUAL_UNION_TYPE)
|
break;
|
break;
|
else
|
else
|
v = TREE_OPERAND (v, 0);
|
v = TREE_OPERAND (v, 0);
|
if (v != pt_var)
|
if (v != pt_var)
|
v = NULL_TREE;
|
v = NULL_TREE;
|
else
|
else
|
v = pt_var;
|
v = pt_var;
|
break;
|
break;
|
default:
|
default:
|
v = pt_var;
|
v = pt_var;
|
break;
|
break;
|
}
|
}
|
if (v == pt_var)
|
if (v == pt_var)
|
var = pt_var;
|
var = pt_var;
|
}
|
}
|
}
|
}
|
else
|
else
|
var = pt_var;
|
var = pt_var;
|
|
|
if (var != pt_var)
|
if (var != pt_var)
|
var_size = TYPE_SIZE_UNIT (TREE_TYPE (var));
|
var_size = TYPE_SIZE_UNIT (TREE_TYPE (var));
|
else if (!pt_var_size)
|
else if (!pt_var_size)
|
return unknown[object_size_type];
|
return unknown[object_size_type];
|
else
|
else
|
var_size = pt_var_size;
|
var_size = pt_var_size;
|
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 (var_size, bytes))
|
&& tree_int_cst_lt (var_size, bytes))
|
bytes = size_zero_node;
|
bytes = size_zero_node;
|
else
|
else
|
bytes = size_binop (MINUS_EXPR, var_size, bytes);
|
bytes = size_binop (MINUS_EXPR, var_size, bytes);
|
}
|
}
|
if (var != pt_var
|
if (var != pt_var
|
&& pt_var_size
|
&& pt_var_size
|
&& TREE_CODE (pt_var) == INDIRECT_REF
|
&& TREE_CODE (pt_var) == INDIRECT_REF
|
&& bytes != error_mark_node)
|
&& bytes != error_mark_node)
|
{
|
{
|
tree bytes2 = compute_object_offset (TREE_OPERAND (ptr, 0), pt_var);
|
tree bytes2 = compute_object_offset (TREE_OPERAND (ptr, 0), pt_var);
|
if (bytes2 != error_mark_node)
|
if (bytes2 != error_mark_node)
|
{
|
{
|
if (TREE_CODE (bytes2) == INTEGER_CST
|
if (TREE_CODE (bytes2) == INTEGER_CST
|
&& tree_int_cst_lt (pt_var_size, bytes2))
|
&& tree_int_cst_lt (pt_var_size, bytes2))
|
bytes2 = size_zero_node;
|
bytes2 = size_zero_node;
|
else
|
else
|
bytes2 = size_binop (MINUS_EXPR, pt_var_size, bytes2);
|
bytes2 = size_binop (MINUS_EXPR, pt_var_size, bytes2);
|
bytes = size_binop (MIN_EXPR, bytes, bytes2);
|
bytes = size_binop (MIN_EXPR, bytes, bytes2);
|
}
|
}
|
}
|
}
|
}
|
}
|
else if (!pt_var_size)
|
else if (!pt_var_size)
|
return unknown[object_size_type];
|
return unknown[object_size_type];
|
else
|
else
|
bytes = pt_var_size;
|
bytes = pt_var_size;
|
|
|
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 GIMPLE_CALL.
|
/* Compute __builtin_object_size for CALL, which is a GIMPLE_CALL.
|
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 (const_gimple call, int object_size_type)
|
alloc_object_size (const_gimple call, int object_size_type)
|
{
|
{
|
tree callee, bytes = NULL_TREE;
|
tree callee, bytes = NULL_TREE;
|
tree alloc_size;
|
tree alloc_size;
|
int arg1 = -1, arg2 = -1;
|
int arg1 = -1, arg2 = -1;
|
|
|
gcc_assert (is_gimple_call (call));
|
gcc_assert (is_gimple_call (call));
|
|
|
callee = gimple_call_fndecl (call);
|
callee = gimple_call_fndecl (call);
|
if (!callee)
|
if (!callee)
|
return unknown[object_size_type];
|
return unknown[object_size_type];
|
|
|
alloc_size = lookup_attribute ("alloc_size", TYPE_ATTRIBUTES (TREE_TYPE(callee)));
|
alloc_size = lookup_attribute ("alloc_size", TYPE_ATTRIBUTES (TREE_TYPE(callee)));
|
if (alloc_size && TREE_VALUE (alloc_size))
|
if (alloc_size && TREE_VALUE (alloc_size))
|
{
|
{
|
tree p = TREE_VALUE (alloc_size);
|
tree p = TREE_VALUE (alloc_size);
|
|
|
arg1 = TREE_INT_CST_LOW (TREE_VALUE (p))-1;
|
arg1 = TREE_INT_CST_LOW (TREE_VALUE (p))-1;
|
if (TREE_CHAIN (p))
|
if (TREE_CHAIN (p))
|
arg2 = TREE_INT_CST_LOW (TREE_VALUE (TREE_CHAIN (p)))-1;
|
arg2 = TREE_INT_CST_LOW (TREE_VALUE (TREE_CHAIN (p)))-1;
|
}
|
}
|
|
|
if (DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL)
|
if (DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL)
|
switch (DECL_FUNCTION_CODE (callee))
|
switch (DECL_FUNCTION_CODE (callee))
|
{
|
{
|
case BUILT_IN_CALLOC:
|
case BUILT_IN_CALLOC:
|
arg2 = 1;
|
arg2 = 1;
|
/* fall through */
|
/* fall through */
|
case BUILT_IN_MALLOC:
|
case BUILT_IN_MALLOC:
|
case BUILT_IN_ALLOCA:
|
case BUILT_IN_ALLOCA:
|
arg1 = 0;
|
arg1 = 0;
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
if (arg1 < 0 || arg1 >= (int)gimple_call_num_args (call)
|
if (arg1 < 0 || arg1 >= (int)gimple_call_num_args (call)
|
|| TREE_CODE (gimple_call_arg (call, arg1)) != INTEGER_CST
|
|| TREE_CODE (gimple_call_arg (call, arg1)) != INTEGER_CST
|
|| (arg2 >= 0
|
|| (arg2 >= 0
|
&& (arg2 >= (int)gimple_call_num_args (call)
|
&& (arg2 >= (int)gimple_call_num_args (call)
|
|| TREE_CODE (gimple_call_arg (call, arg2)) != INTEGER_CST)))
|
|| TREE_CODE (gimple_call_arg (call, arg2)) != INTEGER_CST)))
|
return unknown[object_size_type];
|
return unknown[object_size_type];
|
|
|
if (arg2 >= 0)
|
if (arg2 >= 0)
|
bytes = size_binop (MULT_EXPR,
|
bytes = size_binop (MULT_EXPR,
|
fold_convert (sizetype, gimple_call_arg (call, arg1)),
|
fold_convert (sizetype, gimple_call_arg (call, arg1)),
|
fold_convert (sizetype, gimple_call_arg (call, arg2)));
|
fold_convert (sizetype, gimple_call_arg (call, arg2)));
|
else if (arg1 >= 0)
|
else if (arg1 >= 0)
|
bytes = fold_convert (sizetype, gimple_call_arg (call, arg1));
|
bytes = fold_convert (sizetype, gimple_call_arg (call, arg1));
|
|
|
if (bytes && host_integerp (bytes, 1))
|
if (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 GIMPLE_CALL statement CALL.
|
to its return value, return that argument for GIMPLE_CALL statement CALL.
|
Otherwise return NULL. */
|
Otherwise return NULL. */
|
|
|
static tree
|
static tree
|
pass_through_call (const_gimple call)
|
pass_through_call (const_gimple call)
|
{
|
{
|
tree callee = gimple_call_fndecl (call);
|
tree callee = gimple_call_fndecl (call);
|
|
|
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 (gimple_call_num_args (call) >= 1)
|
if (gimple_call_num_args (call) >= 1)
|
return gimple_call_arg (call, 0);
|
return gimple_call_arg (call, 0);
|
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 (NULL, ptr, object_size_type);
|
return addr_object_size (NULL, ptr, object_size_type);
|
|
|
if (TREE_CODE (ptr) == SSA_NAME
|
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 an SSA_NAME. */
|
/* Compute object_sizes for PTR, defined to VALUE, which is not an 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 (osi, value, object_size_type);
|
bytes = addr_object_size (osi, 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;
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Compute object_sizes for PTR, defined to the result of a call. */
|
/* Compute object_sizes for PTR, defined to the result of a call. */
|
|
|
static void
|
static void
|
call_object_size (struct object_size_info *osi, tree ptr, gimple call)
|
call_object_size (struct object_size_info *osi, tree ptr, gimple call)
|
{
|
{
|
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 (is_gimple_call (call));
|
gcc_assert (is_gimple_call (call));
|
|
|
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);
|
|
|
bytes = alloc_object_size (call, object_size_type);
|
bytes = alloc_object_size (call, 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;
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Compute object_sizes for PTR, defined to an unknown value. */
|
/* Compute object_sizes for PTR, defined to an unknown value. */
|
|
|
static void
|
static void
|
unknown_object_size (struct object_size_info *osi, tree ptr)
|
unknown_object_size (struct object_size_info *osi, tree ptr)
|
{
|
{
|
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);
|
|
|
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 VAR, defined to the result of an assignment
|
/* Compute object_sizes for VAR, defined to the result of an assignment
|
with operator POINTER_PLUS_EXPR. Return true if the object size might
|
with operator POINTER_PLUS_EXPR. Return true if the object size might
|
need reexamination later. */
|
need reexamination later. */
|
|
|
static bool
|
static bool
|
plus_stmt_object_size (struct object_size_info *osi, tree var, gimple stmt)
|
plus_stmt_object_size (struct object_size_info *osi, tree var, gimple stmt)
|
{
|
{
|
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;
|
tree op0, op1;
|
tree op0, op1;
|
|
|
gcc_assert (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR);
|
gcc_assert (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR);
|
|
|
op0 = gimple_assign_rhs1 (stmt);
|
op0 = gimple_assign_rhs1 (stmt);
|
op1 = gimple_assign_rhs2 (stmt);
|
op1 = gimple_assign_rhs2 (stmt);
|
|
|
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;
|
|
|
/* Handle PTR + OFFSET here. */
|
/* Handle PTR + OFFSET here. */
|
if (TREE_CODE (op1) == INTEGER_CST
|
if (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);
|
|
|
/* op0 will be ADDR_EXPR here. */
|
/* op0 will be ADDR_EXPR here. */
|
bytes = addr_object_size (osi, op0, object_size_type);
|
bytes = addr_object_size (osi, op0, object_size_type);
|
if (bytes == unknown[object_size_type])
|
if (bytes == unknown[object_size_type])
|
;
|
;
|
else if (off > offset_limit)
|
else 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, defined to VALUE, which is
|
/* Compute object_sizes for VAR, defined to VALUE, which is
|
a COND_EXPR. Return true if the object size might need reexamination
|
a COND_EXPR. Return true if the object size might need reexamination
|
later. */
|
later. */
|
|
|
static bool
|
static bool
|
cond_expr_object_size (struct object_size_info *osi, tree var, tree value)
|
cond_expr_object_size (struct object_size_info *osi, tree var, tree value)
|
{
|
{
|
tree then_, else_;
|
tree then_, else_;
|
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);
|
bool reexamine = false;
|
bool reexamine = false;
|
|
|
gcc_assert (TREE_CODE (value) == COND_EXPR);
|
gcc_assert (TREE_CODE (value) == COND_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;
|
|
|
then_ = COND_EXPR_THEN (value);
|
then_ = COND_EXPR_THEN (value);
|
else_ = COND_EXPR_ELSE (value);
|
else_ = COND_EXPR_ELSE (value);
|
|
|
if (TREE_CODE (then_) == SSA_NAME)
|
if (TREE_CODE (then_) == SSA_NAME)
|
reexamine |= merge_object_sizes (osi, var, then_, 0);
|
reexamine |= merge_object_sizes (osi, var, then_, 0);
|
else
|
else
|
expr_object_size (osi, var, then_);
|
expr_object_size (osi, var, then_);
|
|
|
if (TREE_CODE (else_) == SSA_NAME)
|
if (TREE_CODE (else_) == SSA_NAME)
|
reexamine |= merge_object_sizes (osi, var, else_, 0);
|
reexamine |= merge_object_sizes (osi, var, else_, 0);
|
else
|
else
|
expr_object_size (osi, var, else_);
|
expr_object_size (osi, var, else_);
|
|
|
return reexamine;
|
return reexamine;
|
}
|
}
|
|
|
/* 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 GIMPLE_CALL like malloc or calloc object size is the size
|
For allocation GIMPLE_CALL 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 GIMPLE_CALL that always returns one of its arguments, the
|
For a memcpy like GIMPLE_CALL 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);
|
gimple stmt;
|
gimple 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 (gimple_code (stmt))
|
switch (gimple_code (stmt))
|
{
|
{
|
case GIMPLE_ASSIGN:
|
case GIMPLE_ASSIGN:
|
{
|
{
|
if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR)
|
if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR)
|
reexamine = plus_stmt_object_size (osi, var, stmt);
|
reexamine = plus_stmt_object_size (osi, var, stmt);
|
else if (gimple_assign_single_p (stmt)
|
else if (gimple_assign_single_p (stmt)
|
|| gimple_assign_unary_nop_p (stmt))
|
|| gimple_assign_unary_nop_p (stmt))
|
{
|
{
|
tree rhs = gimple_assign_rhs1 (stmt);
|
tree rhs = gimple_assign_rhs1 (stmt);
|
|
|
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) == COND_EXPR)
|
else if (TREE_CODE (rhs) == COND_EXPR)
|
reexamine = cond_expr_object_size (osi, var, rhs);
|
reexamine = cond_expr_object_size (osi, var, rhs);
|
else
|
else
|
expr_object_size (osi, var, rhs);
|
expr_object_size (osi, var, rhs);
|
}
|
}
|
else
|
else
|
unknown_object_size (osi, var);
|
unknown_object_size (osi, var);
|
break;
|
break;
|
}
|
}
|
|
|
case GIMPLE_CALL:
|
case GIMPLE_CALL:
|
{
|
{
|
tree arg = pass_through_call (stmt);
|
tree arg = pass_through_call (stmt);
|
if (arg)
|
if (arg)
|
{
|
{
|
if (TREE_CODE (arg) == SSA_NAME
|
if (TREE_CODE (arg) == SSA_NAME
|
&& POINTER_TYPE_P (TREE_TYPE (arg)))
|
&& POINTER_TYPE_P (TREE_TYPE (arg)))
|
reexamine = merge_object_sizes (osi, var, arg, 0);
|
reexamine = merge_object_sizes (osi, var, arg, 0);
|
else if (TREE_CODE (arg) == COND_EXPR)
|
else if (TREE_CODE (arg) == COND_EXPR)
|
reexamine = cond_expr_object_size (osi, var, arg);
|
reexamine = cond_expr_object_size (osi, var, arg);
|
else
|
else
|
expr_object_size (osi, var, arg);
|
expr_object_size (osi, var, arg);
|
}
|
}
|
else
|
else
|
call_object_size (osi, var, stmt);
|
call_object_size (osi, var, stmt);
|
break;
|
break;
|
}
|
}
|
|
|
case GIMPLE_ASM:
|
case GIMPLE_ASM:
|
/* 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 GIMPLE_NOP:
|
case GIMPLE_NOP:
|
{
|
{
|
tree decl = SSA_NAME_VAR (var);
|
tree decl = SSA_NAME_VAR (var);
|
|
|
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 GIMPLE_PHI:
|
case GIMPLE_PHI:
|
{
|
{
|
unsigned i;
|
unsigned i;
|
|
|
for (i = 0; i < gimple_phi_num_args (stmt); i++)
|
for (i = 0; i < gimple_phi_num_args (stmt); i++)
|
{
|
{
|
tree rhs = gimple_phi_arg (stmt, i)->def;
|
tree rhs = gimple_phi_arg (stmt, i)->def;
|
|
|
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)
|
{
|
{
|
gimple stmt = SSA_NAME_DEF_STMT (var);
|
gimple 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 (gimple_code (stmt))
|
switch (gimple_code (stmt))
|
{
|
{
|
|
|
case GIMPLE_ASSIGN:
|
case GIMPLE_ASSIGN:
|
{
|
{
|
if ((gimple_assign_single_p (stmt)
|
if ((gimple_assign_single_p (stmt)
|
|| gimple_assign_unary_nop_p (stmt))
|
|| gimple_assign_unary_nop_p (stmt))
|
&& TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME)
|
&& TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME)
|
{
|
{
|
tree rhs = gimple_assign_rhs1 (stmt);
|
tree rhs = gimple_assign_rhs1 (stmt);
|
|
|
check_for_plus_in_loops_1 (osi, rhs, depth);
|
check_for_plus_in_loops_1 (osi, rhs, depth);
|
}
|
}
|
else if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR)
|
else if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR)
|
{
|
{
|
tree basevar = gimple_assign_rhs1 (stmt);
|
tree basevar = gimple_assign_rhs1 (stmt);
|
tree cst = gimple_assign_rhs2 (stmt);
|
tree cst = gimple_assign_rhs2 (stmt);
|
|
|
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 GIMPLE_CALL:
|
case GIMPLE_CALL:
|
{
|
{
|
tree arg = pass_through_call (stmt);
|
tree arg = pass_through_call (stmt);
|
if (arg)
|
if (arg)
|
{
|
{
|
if (TREE_CODE (arg) == SSA_NAME)
|
if (TREE_CODE (arg) == SSA_NAME)
|
check_for_plus_in_loops_1 (osi, arg, depth);
|
check_for_plus_in_loops_1 (osi, arg, depth);
|
else
|
else
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
break;
|
break;
|
}
|
}
|
|
|
case GIMPLE_PHI:
|
case GIMPLE_PHI:
|
{
|
{
|
unsigned i;
|
unsigned i;
|
|
|
for (i = 0; i < gimple_phi_num_args (stmt); i++)
|
for (i = 0; i < gimple_phi_num_args (stmt); i++)
|
{
|
{
|
tree rhs = gimple_phi_arg (stmt, i)->def;
|
tree rhs = gimple_phi_arg (stmt, i)->def;
|
|
|
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)
|
{
|
{
|
gimple stmt = SSA_NAME_DEF_STMT (var);
|
gimple stmt = SSA_NAME_DEF_STMT (var);
|
|
|
/* NOTE: In the pre-tuples code, we handled a CALL_EXPR here,
|
/* NOTE: In the pre-tuples code, we handled a CALL_EXPR here,
|
and looked for a POINTER_PLUS_EXPR in the pass-through
|
and looked for a POINTER_PLUS_EXPR in the pass-through
|
argument, if any. In GIMPLE, however, such an expression
|
argument, if any. In GIMPLE, however, such an expression
|
is not a valid call operand. */
|
is not a valid call operand. */
|
|
|
if (is_gimple_assign (stmt)
|
if (is_gimple_assign (stmt)
|
&& gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR)
|
&& gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR)
|
{
|
{
|
tree basevar = gimple_assign_rhs1 (stmt);
|
tree basevar = gimple_assign_rhs1 (stmt);
|
tree cst = gimple_assign_rhs2 (stmt);
|
tree cst = gimple_assign_rhs2 (stmt);
|
|
|
gcc_assert (TREE_CODE (cst) == INTEGER_CST);
|
gcc_assert (TREE_CODE (cst) == INTEGER_CST);
|
|
|
if (integer_zerop (cst))
|
if (integer_zerop (cst))
|
return;
|
return;
|
|
|
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--;
|
}
|
}
|
}
|
}
|
|
|
|
|
/* 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)
|
{
|
{
|
gimple_stmt_iterator i;
|
gimple_stmt_iterator i;
|
for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
|
for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
|
{
|
{
|
tree callee, result;
|
tree callee, result;
|
gimple call = gsi_stmt (i);
|
gimple call = gsi_stmt (i);
|
|
|
if (gimple_code (call) != GIMPLE_CALL)
|
if (gimple_code (call) != GIMPLE_CALL)
|
continue;
|
continue;
|
|
|
callee = gimple_call_fndecl (call);
|
callee = gimple_call_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_call_stmt (call, false);
|
result = fold_call_stmt (call, false);
|
if (!result)
|
if (!result)
|
{
|
{
|
if (gimple_call_num_args (call) == 2
|
if (gimple_call_num_args (call) == 2
|
&& POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (call, 0))))
|
&& POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (call, 0))))
|
{
|
{
|
tree ost = gimple_call_arg (call, 1);
|
tree ost = gimple_call_arg (call, 1);
|
|
|
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_gimple_stmt (dump_file, call, 0, dump_flags);
|
print_gimple_stmt (dump_file, call, 0, dump_flags);
|
}
|
}
|
|
|
if (!update_call_from_tree (&i, result))
|
if (!update_call_from_tree (&i, result))
|
gcc_unreachable ();
|
gcc_unreachable ();
|
|
|
/* NOTE: In the pre-tuples code, we called update_stmt here. This is
|
/* NOTE: In the pre-tuples code, we called update_stmt here. This is
|
now handled by gsi_replace, called from update_call_from_tree. */
|
now handled by gsi_replace, called from update_call_from_tree. */
|
|
|
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_gimple_stmt (dump_file, call, 0, dump_flags);
|
print_gimple_stmt (dump_file, call, 0, dump_flags);
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
fini_object_sizes ();
|
fini_object_sizes ();
|
return 0;
|
return 0;
|
}
|
}
|
|
|
struct gimple_opt_pass pass_object_sizes =
|
struct gimple_opt_pass pass_object_sizes =
|
{
|
{
|
{
|
{
|
GIMPLE_PASS,
|
GIMPLE_PASS,
|
"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 */
|
TV_NONE, /* tv_id */
|
TV_NONE, /* tv_id */
|
PROP_cfg | PROP_ssa, /* properties_required */
|
PROP_cfg | PROP_ssa, /* 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 */
|
}
|
}
|
};
|
};
|
|
|
