/* A pass for lowering trees to RTL.
|
/* A pass for lowering trees to RTL.
|
Copyright (C) 2004, 2005, 2007 Free Software Foundation, Inc.
|
Copyright (C) 2004, 2005, 2007 Free Software Foundation, Inc.
|
|
|
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 "rtl.h"
|
#include "rtl.h"
|
#include "tm_p.h"
|
#include "tm_p.h"
|
#include "basic-block.h"
|
#include "basic-block.h"
|
#include "function.h"
|
#include "function.h"
|
#include "expr.h"
|
#include "expr.h"
|
#include "langhooks.h"
|
#include "langhooks.h"
|
#include "tree-flow.h"
|
#include "tree-flow.h"
|
#include "timevar.h"
|
#include "timevar.h"
|
#include "tree-dump.h"
|
#include "tree-dump.h"
|
#include "tree-pass.h"
|
#include "tree-pass.h"
|
#include "except.h"
|
#include "except.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "diagnostic.h"
|
#include "diagnostic.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
#include "debug.h"
|
#include "debug.h"
|
#include "params.h"
|
#include "params.h"
|
|
|
/* Verify that there is exactly single jump instruction since last and attach
|
/* Verify that there is exactly single jump instruction since last and attach
|
REG_BR_PROB note specifying probability.
|
REG_BR_PROB note specifying probability.
|
??? We really ought to pass the probability down to RTL expanders and let it
|
??? We really ought to pass the probability down to RTL expanders and let it
|
re-distribute it when the conditional expands into multiple conditionals.
|
re-distribute it when the conditional expands into multiple conditionals.
|
This is however difficult to do. */
|
This is however difficult to do. */
|
static void
|
static void
|
add_reg_br_prob_note (rtx last, int probability)
|
add_reg_br_prob_note (rtx last, int probability)
|
{
|
{
|
if (profile_status == PROFILE_ABSENT)
|
if (profile_status == PROFILE_ABSENT)
|
return;
|
return;
|
for (last = NEXT_INSN (last); last && NEXT_INSN (last); last = NEXT_INSN (last))
|
for (last = NEXT_INSN (last); last && NEXT_INSN (last); last = NEXT_INSN (last))
|
if (JUMP_P (last))
|
if (JUMP_P (last))
|
{
|
{
|
/* It is common to emit condjump-around-jump sequence when we don't know
|
/* It is common to emit condjump-around-jump sequence when we don't know
|
how to reverse the conditional. Special case this. */
|
how to reverse the conditional. Special case this. */
|
if (!any_condjump_p (last)
|
if (!any_condjump_p (last)
|
|| !JUMP_P (NEXT_INSN (last))
|
|| !JUMP_P (NEXT_INSN (last))
|
|| !simplejump_p (NEXT_INSN (last))
|
|| !simplejump_p (NEXT_INSN (last))
|
|| !NEXT_INSN (NEXT_INSN (last))
|
|| !NEXT_INSN (NEXT_INSN (last))
|
|| !BARRIER_P (NEXT_INSN (NEXT_INSN (last)))
|
|| !BARRIER_P (NEXT_INSN (NEXT_INSN (last)))
|
|| !NEXT_INSN (NEXT_INSN (NEXT_INSN (last)))
|
|| !NEXT_INSN (NEXT_INSN (NEXT_INSN (last)))
|
|| !LABEL_P (NEXT_INSN (NEXT_INSN (NEXT_INSN (last))))
|
|| !LABEL_P (NEXT_INSN (NEXT_INSN (NEXT_INSN (last))))
|
|| NEXT_INSN (NEXT_INSN (NEXT_INSN (NEXT_INSN (last)))))
|
|| NEXT_INSN (NEXT_INSN (NEXT_INSN (NEXT_INSN (last)))))
|
goto failed;
|
goto failed;
|
gcc_assert (!find_reg_note (last, REG_BR_PROB, 0));
|
gcc_assert (!find_reg_note (last, REG_BR_PROB, 0));
|
REG_NOTES (last)
|
REG_NOTES (last)
|
= gen_rtx_EXPR_LIST (REG_BR_PROB,
|
= gen_rtx_EXPR_LIST (REG_BR_PROB,
|
GEN_INT (REG_BR_PROB_BASE - probability),
|
GEN_INT (REG_BR_PROB_BASE - probability),
|
REG_NOTES (last));
|
REG_NOTES (last));
|
return;
|
return;
|
}
|
}
|
if (!last || !JUMP_P (last) || !any_condjump_p (last))
|
if (!last || !JUMP_P (last) || !any_condjump_p (last))
|
goto failed;
|
goto failed;
|
gcc_assert (!find_reg_note (last, REG_BR_PROB, 0));
|
gcc_assert (!find_reg_note (last, REG_BR_PROB, 0));
|
REG_NOTES (last)
|
REG_NOTES (last)
|
= gen_rtx_EXPR_LIST (REG_BR_PROB,
|
= gen_rtx_EXPR_LIST (REG_BR_PROB,
|
GEN_INT (probability), REG_NOTES (last));
|
GEN_INT (probability), REG_NOTES (last));
|
return;
|
return;
|
failed:
|
failed:
|
if (dump_file)
|
if (dump_file)
|
fprintf (dump_file, "Failed to add probability note\n");
|
fprintf (dump_file, "Failed to add probability note\n");
|
}
|
}
|
|
|
|
|
#ifndef LOCAL_ALIGNMENT
|
#ifndef LOCAL_ALIGNMENT
|
#define LOCAL_ALIGNMENT(TYPE, ALIGNMENT) ALIGNMENT
|
#define LOCAL_ALIGNMENT(TYPE, ALIGNMENT) ALIGNMENT
|
#endif
|
#endif
|
|
|
#ifndef STACK_ALIGNMENT_NEEDED
|
#ifndef STACK_ALIGNMENT_NEEDED
|
#define STACK_ALIGNMENT_NEEDED 1
|
#define STACK_ALIGNMENT_NEEDED 1
|
#endif
|
#endif
|
|
|
|
|
/* This structure holds data relevant to one variable that will be
|
/* This structure holds data relevant to one variable that will be
|
placed in a stack slot. */
|
placed in a stack slot. */
|
struct stack_var
|
struct stack_var
|
{
|
{
|
/* The Variable. */
|
/* The Variable. */
|
tree decl;
|
tree decl;
|
|
|
/* The offset of the variable. During partitioning, this is the
|
/* The offset of the variable. During partitioning, this is the
|
offset relative to the partition. After partitioning, this
|
offset relative to the partition. After partitioning, this
|
is relative to the stack frame. */
|
is relative to the stack frame. */
|
HOST_WIDE_INT offset;
|
HOST_WIDE_INT offset;
|
|
|
/* Initially, the size of the variable. Later, the size of the partition,
|
/* Initially, the size of the variable. Later, the size of the partition,
|
if this variable becomes it's partition's representative. */
|
if this variable becomes it's partition's representative. */
|
HOST_WIDE_INT size;
|
HOST_WIDE_INT size;
|
|
|
/* The *byte* alignment required for this variable. Or as, with the
|
/* The *byte* alignment required for this variable. Or as, with the
|
size, the alignment for this partition. */
|
size, the alignment for this partition. */
|
unsigned int alignb;
|
unsigned int alignb;
|
|
|
/* The partition representative. */
|
/* The partition representative. */
|
size_t representative;
|
size_t representative;
|
|
|
/* The next stack variable in the partition, or EOC. */
|
/* The next stack variable in the partition, or EOC. */
|
size_t next;
|
size_t next;
|
};
|
};
|
|
|
#define EOC ((size_t)-1)
|
#define EOC ((size_t)-1)
|
|
|
/* We have an array of such objects while deciding allocation. */
|
/* We have an array of such objects while deciding allocation. */
|
static struct stack_var *stack_vars;
|
static struct stack_var *stack_vars;
|
static size_t stack_vars_alloc;
|
static size_t stack_vars_alloc;
|
static size_t stack_vars_num;
|
static size_t stack_vars_num;
|
|
|
/* An array of indicies such that stack_vars[stack_vars_sorted[i]].size
|
/* An array of indicies such that stack_vars[stack_vars_sorted[i]].size
|
is non-decreasing. */
|
is non-decreasing. */
|
static size_t *stack_vars_sorted;
|
static size_t *stack_vars_sorted;
|
|
|
/* We have an interference graph between such objects. This graph
|
/* We have an interference graph between such objects. This graph
|
is lower triangular. */
|
is lower triangular. */
|
static bool *stack_vars_conflict;
|
static bool *stack_vars_conflict;
|
static size_t stack_vars_conflict_alloc;
|
static size_t stack_vars_conflict_alloc;
|
|
|
/* The phase of the stack frame. This is the known misalignment of
|
/* The phase of the stack frame. This is the known misalignment of
|
virtual_stack_vars_rtx from PREFERRED_STACK_BOUNDARY. That is,
|
virtual_stack_vars_rtx from PREFERRED_STACK_BOUNDARY. That is,
|
(frame_offset+frame_phase) % PREFERRED_STACK_BOUNDARY == 0. */
|
(frame_offset+frame_phase) % PREFERRED_STACK_BOUNDARY == 0. */
|
static int frame_phase;
|
static int frame_phase;
|
|
|
/* Used during expand_used_vars to remember if we saw any decls for
|
/* Used during expand_used_vars to remember if we saw any decls for
|
which we'd like to enable stack smashing protection. */
|
which we'd like to enable stack smashing protection. */
|
static bool has_protected_decls;
|
static bool has_protected_decls;
|
|
|
/* Used during expand_used_vars. Remember if we say a character buffer
|
/* Used during expand_used_vars. Remember if we say a character buffer
|
smaller than our cutoff threshold. Used for -Wstack-protector. */
|
smaller than our cutoff threshold. Used for -Wstack-protector. */
|
static bool has_short_buffer;
|
static bool has_short_buffer;
|
|
|
/* Discover the byte alignment to use for DECL. Ignore alignment
|
/* Discover the byte alignment to use for DECL. Ignore alignment
|
we can't do with expected alignment of the stack boundary. */
|
we can't do with expected alignment of the stack boundary. */
|
|
|
static unsigned int
|
static unsigned int
|
get_decl_align_unit (tree decl)
|
get_decl_align_unit (tree decl)
|
{
|
{
|
unsigned int align;
|
unsigned int align;
|
|
|
align = DECL_ALIGN (decl);
|
align = DECL_ALIGN (decl);
|
align = LOCAL_ALIGNMENT (TREE_TYPE (decl), align);
|
align = LOCAL_ALIGNMENT (TREE_TYPE (decl), align);
|
if (align > PREFERRED_STACK_BOUNDARY)
|
if (align > PREFERRED_STACK_BOUNDARY)
|
align = PREFERRED_STACK_BOUNDARY;
|
align = PREFERRED_STACK_BOUNDARY;
|
if (cfun->stack_alignment_needed < align)
|
if (cfun->stack_alignment_needed < align)
|
cfun->stack_alignment_needed = align;
|
cfun->stack_alignment_needed = align;
|
|
|
return align / BITS_PER_UNIT;
|
return align / BITS_PER_UNIT;
|
}
|
}
|
|
|
/* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
|
/* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
|
Return the frame offset. */
|
Return the frame offset. */
|
|
|
static HOST_WIDE_INT
|
static HOST_WIDE_INT
|
alloc_stack_frame_space (HOST_WIDE_INT size, HOST_WIDE_INT align)
|
alloc_stack_frame_space (HOST_WIDE_INT size, HOST_WIDE_INT align)
|
{
|
{
|
HOST_WIDE_INT offset, new_frame_offset;
|
HOST_WIDE_INT offset, new_frame_offset;
|
|
|
new_frame_offset = frame_offset;
|
new_frame_offset = frame_offset;
|
if (FRAME_GROWS_DOWNWARD)
|
if (FRAME_GROWS_DOWNWARD)
|
{
|
{
|
new_frame_offset -= size + frame_phase;
|
new_frame_offset -= size + frame_phase;
|
new_frame_offset &= -align;
|
new_frame_offset &= -align;
|
new_frame_offset += frame_phase;
|
new_frame_offset += frame_phase;
|
offset = new_frame_offset;
|
offset = new_frame_offset;
|
}
|
}
|
else
|
else
|
{
|
{
|
new_frame_offset -= frame_phase;
|
new_frame_offset -= frame_phase;
|
new_frame_offset += align - 1;
|
new_frame_offset += align - 1;
|
new_frame_offset &= -align;
|
new_frame_offset &= -align;
|
new_frame_offset += frame_phase;
|
new_frame_offset += frame_phase;
|
offset = new_frame_offset;
|
offset = new_frame_offset;
|
new_frame_offset += size;
|
new_frame_offset += size;
|
}
|
}
|
frame_offset = new_frame_offset;
|
frame_offset = new_frame_offset;
|
|
|
if (frame_offset_overflow (frame_offset, cfun->decl))
|
if (frame_offset_overflow (frame_offset, cfun->decl))
|
frame_offset = offset = 0;
|
frame_offset = offset = 0;
|
|
|
return offset;
|
return offset;
|
}
|
}
|
|
|
/* Accumulate DECL into STACK_VARS. */
|
/* Accumulate DECL into STACK_VARS. */
|
|
|
static void
|
static void
|
add_stack_var (tree decl)
|
add_stack_var (tree decl)
|
{
|
{
|
if (stack_vars_num >= stack_vars_alloc)
|
if (stack_vars_num >= stack_vars_alloc)
|
{
|
{
|
if (stack_vars_alloc)
|
if (stack_vars_alloc)
|
stack_vars_alloc = stack_vars_alloc * 3 / 2;
|
stack_vars_alloc = stack_vars_alloc * 3 / 2;
|
else
|
else
|
stack_vars_alloc = 32;
|
stack_vars_alloc = 32;
|
stack_vars
|
stack_vars
|
= XRESIZEVEC (struct stack_var, stack_vars, stack_vars_alloc);
|
= XRESIZEVEC (struct stack_var, stack_vars, stack_vars_alloc);
|
}
|
}
|
stack_vars[stack_vars_num].decl = decl;
|
stack_vars[stack_vars_num].decl = decl;
|
stack_vars[stack_vars_num].offset = 0;
|
stack_vars[stack_vars_num].offset = 0;
|
stack_vars[stack_vars_num].size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
|
stack_vars[stack_vars_num].size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
|
stack_vars[stack_vars_num].alignb = get_decl_align_unit (decl);
|
stack_vars[stack_vars_num].alignb = get_decl_align_unit (decl);
|
|
|
/* All variables are initially in their own partition. */
|
/* All variables are initially in their own partition. */
|
stack_vars[stack_vars_num].representative = stack_vars_num;
|
stack_vars[stack_vars_num].representative = stack_vars_num;
|
stack_vars[stack_vars_num].next = EOC;
|
stack_vars[stack_vars_num].next = EOC;
|
|
|
/* Ensure that this decl doesn't get put onto the list twice. */
|
/* Ensure that this decl doesn't get put onto the list twice. */
|
SET_DECL_RTL (decl, pc_rtx);
|
SET_DECL_RTL (decl, pc_rtx);
|
|
|
stack_vars_num++;
|
stack_vars_num++;
|
}
|
}
|
|
|
/* Compute the linear index of a lower-triangular coordinate (I, J). */
|
/* Compute the linear index of a lower-triangular coordinate (I, J). */
|
|
|
static size_t
|
static size_t
|
triangular_index (size_t i, size_t j)
|
triangular_index (size_t i, size_t j)
|
{
|
{
|
if (i < j)
|
if (i < j)
|
{
|
{
|
size_t t;
|
size_t t;
|
t = i, i = j, j = t;
|
t = i, i = j, j = t;
|
}
|
}
|
return (i * (i + 1)) / 2 + j;
|
return (i * (i + 1)) / 2 + j;
|
}
|
}
|
|
|
/* Ensure that STACK_VARS_CONFLICT is large enough for N objects. */
|
/* Ensure that STACK_VARS_CONFLICT is large enough for N objects. */
|
|
|
static void
|
static void
|
resize_stack_vars_conflict (size_t n)
|
resize_stack_vars_conflict (size_t n)
|
{
|
{
|
size_t size = triangular_index (n-1, n-1) + 1;
|
size_t size = triangular_index (n-1, n-1) + 1;
|
|
|
if (size <= stack_vars_conflict_alloc)
|
if (size <= stack_vars_conflict_alloc)
|
return;
|
return;
|
|
|
stack_vars_conflict = XRESIZEVEC (bool, stack_vars_conflict, size);
|
stack_vars_conflict = XRESIZEVEC (bool, stack_vars_conflict, size);
|
memset (stack_vars_conflict + stack_vars_conflict_alloc, 0,
|
memset (stack_vars_conflict + stack_vars_conflict_alloc, 0,
|
(size - stack_vars_conflict_alloc) * sizeof (bool));
|
(size - stack_vars_conflict_alloc) * sizeof (bool));
|
stack_vars_conflict_alloc = size;
|
stack_vars_conflict_alloc = size;
|
}
|
}
|
|
|
/* Make the decls associated with luid's X and Y conflict. */
|
/* Make the decls associated with luid's X and Y conflict. */
|
|
|
static void
|
static void
|
add_stack_var_conflict (size_t x, size_t y)
|
add_stack_var_conflict (size_t x, size_t y)
|
{
|
{
|
size_t index = triangular_index (x, y);
|
size_t index = triangular_index (x, y);
|
gcc_assert (index < stack_vars_conflict_alloc);
|
gcc_assert (index < stack_vars_conflict_alloc);
|
stack_vars_conflict[index] = true;
|
stack_vars_conflict[index] = true;
|
}
|
}
|
|
|
/* Check whether the decls associated with luid's X and Y conflict. */
|
/* Check whether the decls associated with luid's X and Y conflict. */
|
|
|
static bool
|
static bool
|
stack_var_conflict_p (size_t x, size_t y)
|
stack_var_conflict_p (size_t x, size_t y)
|
{
|
{
|
size_t index = triangular_index (x, y);
|
size_t index = triangular_index (x, y);
|
gcc_assert (index < stack_vars_conflict_alloc);
|
gcc_assert (index < stack_vars_conflict_alloc);
|
return stack_vars_conflict[index];
|
return stack_vars_conflict[index];
|
}
|
}
|
|
|
/* Returns true if TYPE is or contains a union type. */
|
/* Returns true if TYPE is or contains a union type. */
|
|
|
static bool
|
static bool
|
aggregate_contains_union_type (tree type)
|
aggregate_contains_union_type (tree type)
|
{
|
{
|
tree field;
|
tree field;
|
|
|
if (TREE_CODE (type) == UNION_TYPE
|
if (TREE_CODE (type) == UNION_TYPE
|
|| TREE_CODE (type) == QUAL_UNION_TYPE)
|
|| TREE_CODE (type) == QUAL_UNION_TYPE)
|
return true;
|
return true;
|
if (TREE_CODE (type) == ARRAY_TYPE)
|
if (TREE_CODE (type) == ARRAY_TYPE)
|
return aggregate_contains_union_type (TREE_TYPE (type));
|
return aggregate_contains_union_type (TREE_TYPE (type));
|
if (TREE_CODE (type) != RECORD_TYPE)
|
if (TREE_CODE (type) != RECORD_TYPE)
|
return false;
|
return false;
|
|
|
for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
|
for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
|
if (TREE_CODE (field) == FIELD_DECL)
|
if (TREE_CODE (field) == FIELD_DECL)
|
if (aggregate_contains_union_type (TREE_TYPE (field)))
|
if (aggregate_contains_union_type (TREE_TYPE (field)))
|
return true;
|
return true;
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
/* A subroutine of expand_used_vars. If two variables X and Y have alias
|
/* A subroutine of expand_used_vars. If two variables X and Y have alias
|
sets that do not conflict, then do add a conflict for these variables
|
sets that do not conflict, then do add a conflict for these variables
|
in the interference graph. We also need to make sure to add conflicts
|
in the interference graph. We also need to make sure to add conflicts
|
for union containing structures. Else RTL alias analysis comes along
|
for union containing structures. Else RTL alias analysis comes along
|
and due to type based aliasing rules decides that for two overlapping
|
and due to type based aliasing rules decides that for two overlapping
|
union temporaries { short s; int i; } accesses to the same mem through
|
union temporaries { short s; int i; } accesses to the same mem through
|
different types may not alias and happily reorders stores across
|
different types may not alias and happily reorders stores across
|
life-time boundaries of the temporaries (See PR25654).
|
life-time boundaries of the temporaries (See PR25654).
|
We also have to mind MEM_IN_STRUCT_P and MEM_SCALAR_P. */
|
We also have to mind MEM_IN_STRUCT_P and MEM_SCALAR_P. */
|
|
|
static void
|
static void
|
add_alias_set_conflicts (void)
|
add_alias_set_conflicts (void)
|
{
|
{
|
size_t i, j, n = stack_vars_num;
|
size_t i, j, n = stack_vars_num;
|
|
|
for (i = 0; i < n; ++i)
|
for (i = 0; i < n; ++i)
|
{
|
{
|
tree type_i = TREE_TYPE (stack_vars[i].decl);
|
tree type_i = TREE_TYPE (stack_vars[i].decl);
|
bool aggr_i = AGGREGATE_TYPE_P (type_i);
|
bool aggr_i = AGGREGATE_TYPE_P (type_i);
|
bool contains_union;
|
bool contains_union;
|
|
|
contains_union = aggregate_contains_union_type (type_i);
|
contains_union = aggregate_contains_union_type (type_i);
|
for (j = 0; j < i; ++j)
|
for (j = 0; j < i; ++j)
|
{
|
{
|
tree type_j = TREE_TYPE (stack_vars[j].decl);
|
tree type_j = TREE_TYPE (stack_vars[j].decl);
|
bool aggr_j = AGGREGATE_TYPE_P (type_j);
|
bool aggr_j = AGGREGATE_TYPE_P (type_j);
|
if (aggr_i != aggr_j
|
if (aggr_i != aggr_j
|
/* Either the objects conflict by means of type based
|
/* Either the objects conflict by means of type based
|
aliasing rules, or we need to add a conflict. */
|
aliasing rules, or we need to add a conflict. */
|
|| !objects_must_conflict_p (type_i, type_j)
|
|| !objects_must_conflict_p (type_i, type_j)
|
/* In case the types do not conflict ensure that access
|
/* In case the types do not conflict ensure that access
|
to elements will conflict. In case of unions we have
|
to elements will conflict. In case of unions we have
|
to be careful as type based aliasing rules may say
|
to be careful as type based aliasing rules may say
|
access to the same memory does not conflict. So play
|
access to the same memory does not conflict. So play
|
safe and add a conflict in this case. */
|
safe and add a conflict in this case. */
|
|| contains_union)
|
|| contains_union)
|
add_stack_var_conflict (i, j);
|
add_stack_var_conflict (i, j);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* A subroutine of partition_stack_vars. A comparison function for qsort,
|
/* A subroutine of partition_stack_vars. A comparison function for qsort,
|
sorting an array of indicies by the size of the object. */
|
sorting an array of indicies by the size of the object. */
|
|
|
static int
|
static int
|
stack_var_size_cmp (const void *a, const void *b)
|
stack_var_size_cmp (const void *a, const void *b)
|
{
|
{
|
HOST_WIDE_INT sa = stack_vars[*(const size_t *)a].size;
|
HOST_WIDE_INT sa = stack_vars[*(const size_t *)a].size;
|
HOST_WIDE_INT sb = stack_vars[*(const size_t *)b].size;
|
HOST_WIDE_INT sb = stack_vars[*(const size_t *)b].size;
|
unsigned int uida = DECL_UID (stack_vars[*(const size_t *)a].decl);
|
unsigned int uida = DECL_UID (stack_vars[*(const size_t *)a].decl);
|
unsigned int uidb = DECL_UID (stack_vars[*(const size_t *)b].decl);
|
unsigned int uidb = DECL_UID (stack_vars[*(const size_t *)b].decl);
|
|
|
if (sa < sb)
|
if (sa < sb)
|
return -1;
|
return -1;
|
if (sa > sb)
|
if (sa > sb)
|
return 1;
|
return 1;
|
/* For stack variables of the same size use the uid of the decl
|
/* For stack variables of the same size use the uid of the decl
|
to make the sort stable. */
|
to make the sort stable. */
|
if (uida < uidb)
|
if (uida < uidb)
|
return -1;
|
return -1;
|
if (uida > uidb)
|
if (uida > uidb)
|
return 1;
|
return 1;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* A subroutine of partition_stack_vars. The UNION portion of a UNION/FIND
|
/* A subroutine of partition_stack_vars. The UNION portion of a UNION/FIND
|
partitioning algorithm. Partitions A and B are known to be non-conflicting.
|
partitioning algorithm. Partitions A and B are known to be non-conflicting.
|
Merge them into a single partition A.
|
Merge them into a single partition A.
|
|
|
At the same time, add OFFSET to all variables in partition B. At the end
|
At the same time, add OFFSET to all variables in partition B. At the end
|
of the partitioning process we've have a nice block easy to lay out within
|
of the partitioning process we've have a nice block easy to lay out within
|
the stack frame. */
|
the stack frame. */
|
|
|
static void
|
static void
|
union_stack_vars (size_t a, size_t b, HOST_WIDE_INT offset)
|
union_stack_vars (size_t a, size_t b, HOST_WIDE_INT offset)
|
{
|
{
|
size_t i, last;
|
size_t i, last;
|
|
|
/* Update each element of partition B with the given offset,
|
/* Update each element of partition B with the given offset,
|
and merge them into partition A. */
|
and merge them into partition A. */
|
for (last = i = b; i != EOC; last = i, i = stack_vars[i].next)
|
for (last = i = b; i != EOC; last = i, i = stack_vars[i].next)
|
{
|
{
|
stack_vars[i].offset += offset;
|
stack_vars[i].offset += offset;
|
stack_vars[i].representative = a;
|
stack_vars[i].representative = a;
|
}
|
}
|
stack_vars[last].next = stack_vars[a].next;
|
stack_vars[last].next = stack_vars[a].next;
|
stack_vars[a].next = b;
|
stack_vars[a].next = b;
|
|
|
/* Update the required alignment of partition A to account for B. */
|
/* Update the required alignment of partition A to account for B. */
|
if (stack_vars[a].alignb < stack_vars[b].alignb)
|
if (stack_vars[a].alignb < stack_vars[b].alignb)
|
stack_vars[a].alignb = stack_vars[b].alignb;
|
stack_vars[a].alignb = stack_vars[b].alignb;
|
|
|
/* Update the interference graph and merge the conflicts. */
|
/* Update the interference graph and merge the conflicts. */
|
for (last = stack_vars_num, i = 0; i < last; ++i)
|
for (last = stack_vars_num, i = 0; i < last; ++i)
|
if (stack_var_conflict_p (b, i))
|
if (stack_var_conflict_p (b, i))
|
add_stack_var_conflict (a, i);
|
add_stack_var_conflict (a, i);
|
}
|
}
|
|
|
/* A subroutine of expand_used_vars. Binpack the variables into
|
/* A subroutine of expand_used_vars. Binpack the variables into
|
partitions constrained by the interference graph. The overall
|
partitions constrained by the interference graph. The overall
|
algorithm used is as follows:
|
algorithm used is as follows:
|
|
|
Sort the objects by size.
|
Sort the objects by size.
|
For each object A {
|
For each object A {
|
S = size(A)
|
S = size(A)
|
O = 0
|
O = 0
|
loop {
|
loop {
|
Look for the largest non-conflicting object B with size <= S.
|
Look for the largest non-conflicting object B with size <= S.
|
UNION (A, B)
|
UNION (A, B)
|
offset(B) = O
|
offset(B) = O
|
O += size(B)
|
O += size(B)
|
S -= size(B)
|
S -= size(B)
|
}
|
}
|
}
|
}
|
*/
|
*/
|
|
|
static void
|
static void
|
partition_stack_vars (void)
|
partition_stack_vars (void)
|
{
|
{
|
size_t si, sj, n = stack_vars_num;
|
size_t si, sj, n = stack_vars_num;
|
|
|
stack_vars_sorted = XNEWVEC (size_t, stack_vars_num);
|
stack_vars_sorted = XNEWVEC (size_t, stack_vars_num);
|
for (si = 0; si < n; ++si)
|
for (si = 0; si < n; ++si)
|
stack_vars_sorted[si] = si;
|
stack_vars_sorted[si] = si;
|
|
|
if (n == 1)
|
if (n == 1)
|
return;
|
return;
|
|
|
qsort (stack_vars_sorted, n, sizeof (size_t), stack_var_size_cmp);
|
qsort (stack_vars_sorted, n, sizeof (size_t), stack_var_size_cmp);
|
|
|
/* Special case: detect when all variables conflict, and thus we can't
|
/* Special case: detect when all variables conflict, and thus we can't
|
do anything during the partitioning loop. It isn't uncommon (with
|
do anything during the partitioning loop. It isn't uncommon (with
|
C code at least) to declare all variables at the top of the function,
|
C code at least) to declare all variables at the top of the function,
|
and if we're not inlining, then all variables will be in the same scope.
|
and if we're not inlining, then all variables will be in the same scope.
|
Take advantage of very fast libc routines for this scan. */
|
Take advantage of very fast libc routines for this scan. */
|
gcc_assert (sizeof(bool) == sizeof(char));
|
gcc_assert (sizeof(bool) == sizeof(char));
|
if (memchr (stack_vars_conflict, false, stack_vars_conflict_alloc) == NULL)
|
if (memchr (stack_vars_conflict, false, stack_vars_conflict_alloc) == NULL)
|
return;
|
return;
|
|
|
for (si = 0; si < n; ++si)
|
for (si = 0; si < n; ++si)
|
{
|
{
|
size_t i = stack_vars_sorted[si];
|
size_t i = stack_vars_sorted[si];
|
HOST_WIDE_INT isize = stack_vars[i].size;
|
HOST_WIDE_INT isize = stack_vars[i].size;
|
HOST_WIDE_INT offset = 0;
|
HOST_WIDE_INT offset = 0;
|
|
|
for (sj = si; sj-- > 0; )
|
for (sj = si; sj-- > 0; )
|
{
|
{
|
size_t j = stack_vars_sorted[sj];
|
size_t j = stack_vars_sorted[sj];
|
HOST_WIDE_INT jsize = stack_vars[j].size;
|
HOST_WIDE_INT jsize = stack_vars[j].size;
|
unsigned int jalign = stack_vars[j].alignb;
|
unsigned int jalign = stack_vars[j].alignb;
|
|
|
/* Ignore objects that aren't partition representatives. */
|
/* Ignore objects that aren't partition representatives. */
|
if (stack_vars[j].representative != j)
|
if (stack_vars[j].representative != j)
|
continue;
|
continue;
|
|
|
/* Ignore objects too large for the remaining space. */
|
/* Ignore objects too large for the remaining space. */
|
if (isize < jsize)
|
if (isize < jsize)
|
continue;
|
continue;
|
|
|
/* Ignore conflicting objects. */
|
/* Ignore conflicting objects. */
|
if (stack_var_conflict_p (i, j))
|
if (stack_var_conflict_p (i, j))
|
continue;
|
continue;
|
|
|
/* Refine the remaining space check to include alignment. */
|
/* Refine the remaining space check to include alignment. */
|
if (offset & (jalign - 1))
|
if (offset & (jalign - 1))
|
{
|
{
|
HOST_WIDE_INT toff = offset;
|
HOST_WIDE_INT toff = offset;
|
toff += jalign - 1;
|
toff += jalign - 1;
|
toff &= -(HOST_WIDE_INT)jalign;
|
toff &= -(HOST_WIDE_INT)jalign;
|
if (isize - (toff - offset) < jsize)
|
if (isize - (toff - offset) < jsize)
|
continue;
|
continue;
|
|
|
isize -= toff - offset;
|
isize -= toff - offset;
|
offset = toff;
|
offset = toff;
|
}
|
}
|
|
|
/* UNION the objects, placing J at OFFSET. */
|
/* UNION the objects, placing J at OFFSET. */
|
union_stack_vars (i, j, offset);
|
union_stack_vars (i, j, offset);
|
|
|
isize -= jsize;
|
isize -= jsize;
|
if (isize == 0)
|
if (isize == 0)
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* A debugging aid for expand_used_vars. Dump the generated partitions. */
|
/* A debugging aid for expand_used_vars. Dump the generated partitions. */
|
|
|
static void
|
static void
|
dump_stack_var_partition (void)
|
dump_stack_var_partition (void)
|
{
|
{
|
size_t si, i, j, n = stack_vars_num;
|
size_t si, i, j, n = stack_vars_num;
|
|
|
for (si = 0; si < n; ++si)
|
for (si = 0; si < n; ++si)
|
{
|
{
|
i = stack_vars_sorted[si];
|
i = stack_vars_sorted[si];
|
|
|
/* Skip variables that aren't partition representatives, for now. */
|
/* Skip variables that aren't partition representatives, for now. */
|
if (stack_vars[i].representative != i)
|
if (stack_vars[i].representative != i)
|
continue;
|
continue;
|
|
|
fprintf (dump_file, "Partition %lu: size " HOST_WIDE_INT_PRINT_DEC
|
fprintf (dump_file, "Partition %lu: size " HOST_WIDE_INT_PRINT_DEC
|
" align %u\n", (unsigned long) i, stack_vars[i].size,
|
" align %u\n", (unsigned long) i, stack_vars[i].size,
|
stack_vars[i].alignb);
|
stack_vars[i].alignb);
|
|
|
for (j = i; j != EOC; j = stack_vars[j].next)
|
for (j = i; j != EOC; j = stack_vars[j].next)
|
{
|
{
|
fputc ('\t', dump_file);
|
fputc ('\t', dump_file);
|
print_generic_expr (dump_file, stack_vars[j].decl, dump_flags);
|
print_generic_expr (dump_file, stack_vars[j].decl, dump_flags);
|
fprintf (dump_file, ", offset " HOST_WIDE_INT_PRINT_DEC "\n",
|
fprintf (dump_file, ", offset " HOST_WIDE_INT_PRINT_DEC "\n",
|
stack_vars[i].offset);
|
stack_vars[i].offset);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Assign rtl to DECL at frame offset OFFSET. */
|
/* Assign rtl to DECL at frame offset OFFSET. */
|
|
|
static void
|
static void
|
expand_one_stack_var_at (tree decl, HOST_WIDE_INT offset)
|
expand_one_stack_var_at (tree decl, HOST_WIDE_INT offset)
|
{
|
{
|
HOST_WIDE_INT align;
|
HOST_WIDE_INT align;
|
rtx x;
|
rtx x;
|
|
|
/* If this fails, we've overflowed the stack frame. Error nicely? */
|
/* If this fails, we've overflowed the stack frame. Error nicely? */
|
gcc_assert (offset == trunc_int_for_mode (offset, Pmode));
|
gcc_assert (offset == trunc_int_for_mode (offset, Pmode));
|
|
|
x = plus_constant (virtual_stack_vars_rtx, offset);
|
x = plus_constant (virtual_stack_vars_rtx, offset);
|
x = gen_rtx_MEM (DECL_MODE (decl), x);
|
x = gen_rtx_MEM (DECL_MODE (decl), x);
|
|
|
/* Set alignment we actually gave this decl. */
|
/* Set alignment we actually gave this decl. */
|
offset -= frame_phase;
|
offset -= frame_phase;
|
align = offset & -offset;
|
align = offset & -offset;
|
align *= BITS_PER_UNIT;
|
align *= BITS_PER_UNIT;
|
if (align > STACK_BOUNDARY || align == 0)
|
if (align > STACK_BOUNDARY || align == 0)
|
align = STACK_BOUNDARY;
|
align = STACK_BOUNDARY;
|
DECL_ALIGN (decl) = align;
|
DECL_ALIGN (decl) = align;
|
DECL_USER_ALIGN (decl) = 0;
|
DECL_USER_ALIGN (decl) = 0;
|
|
|
set_mem_attributes (x, decl, true);
|
set_mem_attributes (x, decl, true);
|
SET_DECL_RTL (decl, x);
|
SET_DECL_RTL (decl, x);
|
}
|
}
|
|
|
/* A subroutine of expand_used_vars. Give each partition representative
|
/* A subroutine of expand_used_vars. Give each partition representative
|
a unique location within the stack frame. Update each partition member
|
a unique location within the stack frame. Update each partition member
|
with that location. */
|
with that location. */
|
|
|
static void
|
static void
|
expand_stack_vars (bool (*pred) (tree))
|
expand_stack_vars (bool (*pred) (tree))
|
{
|
{
|
size_t si, i, j, n = stack_vars_num;
|
size_t si, i, j, n = stack_vars_num;
|
|
|
for (si = 0; si < n; ++si)
|
for (si = 0; si < n; ++si)
|
{
|
{
|
HOST_WIDE_INT offset;
|
HOST_WIDE_INT offset;
|
|
|
i = stack_vars_sorted[si];
|
i = stack_vars_sorted[si];
|
|
|
/* Skip variables that aren't partition representatives, for now. */
|
/* Skip variables that aren't partition representatives, for now. */
|
if (stack_vars[i].representative != i)
|
if (stack_vars[i].representative != i)
|
continue;
|
continue;
|
|
|
/* Skip variables that have already had rtl assigned. See also
|
/* Skip variables that have already had rtl assigned. See also
|
add_stack_var where we perpetrate this pc_rtx hack. */
|
add_stack_var where we perpetrate this pc_rtx hack. */
|
if (DECL_RTL (stack_vars[i].decl) != pc_rtx)
|
if (DECL_RTL (stack_vars[i].decl) != pc_rtx)
|
continue;
|
continue;
|
|
|
/* Check the predicate to see whether this variable should be
|
/* Check the predicate to see whether this variable should be
|
allocated in this pass. */
|
allocated in this pass. */
|
if (pred && !pred (stack_vars[i].decl))
|
if (pred && !pred (stack_vars[i].decl))
|
continue;
|
continue;
|
|
|
offset = alloc_stack_frame_space (stack_vars[i].size,
|
offset = alloc_stack_frame_space (stack_vars[i].size,
|
stack_vars[i].alignb);
|
stack_vars[i].alignb);
|
|
|
/* Create rtl for each variable based on their location within the
|
/* Create rtl for each variable based on their location within the
|
partition. */
|
partition. */
|
for (j = i; j != EOC; j = stack_vars[j].next)
|
for (j = i; j != EOC; j = stack_vars[j].next)
|
expand_one_stack_var_at (stack_vars[j].decl,
|
expand_one_stack_var_at (stack_vars[j].decl,
|
stack_vars[j].offset + offset);
|
stack_vars[j].offset + offset);
|
}
|
}
|
}
|
}
|
|
|
/* A subroutine of expand_one_var. Called to immediately assign rtl
|
/* A subroutine of expand_one_var. Called to immediately assign rtl
|
to a variable to be allocated in the stack frame. */
|
to a variable to be allocated in the stack frame. */
|
|
|
static void
|
static void
|
expand_one_stack_var (tree var)
|
expand_one_stack_var (tree var)
|
{
|
{
|
HOST_WIDE_INT size, offset, align;
|
HOST_WIDE_INT size, offset, align;
|
|
|
size = tree_low_cst (DECL_SIZE_UNIT (var), 1);
|
size = tree_low_cst (DECL_SIZE_UNIT (var), 1);
|
align = get_decl_align_unit (var);
|
align = get_decl_align_unit (var);
|
offset = alloc_stack_frame_space (size, align);
|
offset = alloc_stack_frame_space (size, align);
|
|
|
expand_one_stack_var_at (var, offset);
|
expand_one_stack_var_at (var, offset);
|
}
|
}
|
|
|
/* A subroutine of expand_one_var. Called to assign rtl
|
/* A subroutine of expand_one_var. Called to assign rtl
|
to a TREE_STATIC VAR_DECL. */
|
to a TREE_STATIC VAR_DECL. */
|
|
|
static void
|
static void
|
expand_one_static_var (tree var)
|
expand_one_static_var (tree var)
|
{
|
{
|
/* In unit-at-a-time all the static variables are expanded at the end
|
/* In unit-at-a-time all the static variables are expanded at the end
|
of compilation process. */
|
of compilation process. */
|
if (flag_unit_at_a_time)
|
if (flag_unit_at_a_time)
|
return;
|
return;
|
/* If this is an inlined copy of a static local variable,
|
/* If this is an inlined copy of a static local variable,
|
look up the original. */
|
look up the original. */
|
var = DECL_ORIGIN (var);
|
var = DECL_ORIGIN (var);
|
|
|
/* If we've already processed this variable because of that, do nothing. */
|
/* If we've already processed this variable because of that, do nothing. */
|
if (TREE_ASM_WRITTEN (var))
|
if (TREE_ASM_WRITTEN (var))
|
return;
|
return;
|
|
|
/* Give the front end a chance to do whatever. In practice, this is
|
/* Give the front end a chance to do whatever. In practice, this is
|
resolving duplicate names for IMA in C. */
|
resolving duplicate names for IMA in C. */
|
if (lang_hooks.expand_decl (var))
|
if (lang_hooks.expand_decl (var))
|
return;
|
return;
|
|
|
/* Otherwise, just emit the variable. */
|
/* Otherwise, just emit the variable. */
|
rest_of_decl_compilation (var, 0, 0);
|
rest_of_decl_compilation (var, 0, 0);
|
}
|
}
|
|
|
/* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
|
/* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
|
that will reside in a hard register. */
|
that will reside in a hard register. */
|
|
|
static void
|
static void
|
expand_one_hard_reg_var (tree var)
|
expand_one_hard_reg_var (tree var)
|
{
|
{
|
rest_of_decl_compilation (var, 0, 0);
|
rest_of_decl_compilation (var, 0, 0);
|
}
|
}
|
|
|
/* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
|
/* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
|
that will reside in a pseudo register. */
|
that will reside in a pseudo register. */
|
|
|
static void
|
static void
|
expand_one_register_var (tree var)
|
expand_one_register_var (tree var)
|
{
|
{
|
tree type = TREE_TYPE (var);
|
tree type = TREE_TYPE (var);
|
int unsignedp = TYPE_UNSIGNED (type);
|
int unsignedp = TYPE_UNSIGNED (type);
|
enum machine_mode reg_mode
|
enum machine_mode reg_mode
|
= promote_mode (type, DECL_MODE (var), &unsignedp, 0);
|
= promote_mode (type, DECL_MODE (var), &unsignedp, 0);
|
rtx x = gen_reg_rtx (reg_mode);
|
rtx x = gen_reg_rtx (reg_mode);
|
|
|
SET_DECL_RTL (var, x);
|
SET_DECL_RTL (var, x);
|
|
|
/* Note if the object is a user variable. */
|
/* Note if the object is a user variable. */
|
if (!DECL_ARTIFICIAL (var))
|
if (!DECL_ARTIFICIAL (var))
|
{
|
{
|
mark_user_reg (x);
|
mark_user_reg (x);
|
|
|
/* Trust user variables which have a pointer type to really
|
/* Trust user variables which have a pointer type to really
|
be pointers. Do not trust compiler generated temporaries
|
be pointers. Do not trust compiler generated temporaries
|
as our type system is totally busted as it relates to
|
as our type system is totally busted as it relates to
|
pointer arithmetic which translates into lots of compiler
|
pointer arithmetic which translates into lots of compiler
|
generated objects with pointer types, but which are not really
|
generated objects with pointer types, but which are not really
|
pointers. */
|
pointers. */
|
if (POINTER_TYPE_P (type))
|
if (POINTER_TYPE_P (type))
|
mark_reg_pointer (x, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (var))));
|
mark_reg_pointer (x, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (var))));
|
}
|
}
|
}
|
}
|
|
|
/* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
|
/* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
|
has some associated error, e.g. its type is error-mark. We just need
|
has some associated error, e.g. its type is error-mark. We just need
|
to pick something that won't crash the rest of the compiler. */
|
to pick something that won't crash the rest of the compiler. */
|
|
|
static void
|
static void
|
expand_one_error_var (tree var)
|
expand_one_error_var (tree var)
|
{
|
{
|
enum machine_mode mode = DECL_MODE (var);
|
enum machine_mode mode = DECL_MODE (var);
|
rtx x;
|
rtx x;
|
|
|
if (mode == BLKmode)
|
if (mode == BLKmode)
|
x = gen_rtx_MEM (BLKmode, const0_rtx);
|
x = gen_rtx_MEM (BLKmode, const0_rtx);
|
else if (mode == VOIDmode)
|
else if (mode == VOIDmode)
|
x = const0_rtx;
|
x = const0_rtx;
|
else
|
else
|
x = gen_reg_rtx (mode);
|
x = gen_reg_rtx (mode);
|
|
|
SET_DECL_RTL (var, x);
|
SET_DECL_RTL (var, x);
|
}
|
}
|
|
|
/* A subroutine of expand_one_var. VAR is a variable that will be
|
/* A subroutine of expand_one_var. VAR is a variable that will be
|
allocated to the local stack frame. Return true if we wish to
|
allocated to the local stack frame. Return true if we wish to
|
add VAR to STACK_VARS so that it will be coalesced with other
|
add VAR to STACK_VARS so that it will be coalesced with other
|
variables. Return false to allocate VAR immediately.
|
variables. Return false to allocate VAR immediately.
|
|
|
This function is used to reduce the number of variables considered
|
This function is used to reduce the number of variables considered
|
for coalescing, which reduces the size of the quadratic problem. */
|
for coalescing, which reduces the size of the quadratic problem. */
|
|
|
static bool
|
static bool
|
defer_stack_allocation (tree var, bool toplevel)
|
defer_stack_allocation (tree var, bool toplevel)
|
{
|
{
|
/* If stack protection is enabled, *all* stack variables must be deferred,
|
/* If stack protection is enabled, *all* stack variables must be deferred,
|
so that we can re-order the strings to the top of the frame. */
|
so that we can re-order the strings to the top of the frame. */
|
if (flag_stack_protect)
|
if (flag_stack_protect)
|
return true;
|
return true;
|
|
|
/* Variables in the outermost scope automatically conflict with
|
/* Variables in the outermost scope automatically conflict with
|
every other variable. The only reason to want to defer them
|
every other variable. The only reason to want to defer them
|
at all is that, after sorting, we can more efficiently pack
|
at all is that, after sorting, we can more efficiently pack
|
small variables in the stack frame. Continue to defer at -O2. */
|
small variables in the stack frame. Continue to defer at -O2. */
|
if (toplevel && optimize < 2)
|
if (toplevel && optimize < 2)
|
return false;
|
return false;
|
|
|
/* Without optimization, *most* variables are allocated from the
|
/* Without optimization, *most* variables are allocated from the
|
stack, which makes the quadratic problem large exactly when we
|
stack, which makes the quadratic problem large exactly when we
|
want compilation to proceed as quickly as possible. On the
|
want compilation to proceed as quickly as possible. On the
|
other hand, we don't want the function's stack frame size to
|
other hand, we don't want the function's stack frame size to
|
get completely out of hand. So we avoid adding scalars and
|
get completely out of hand. So we avoid adding scalars and
|
"small" aggregates to the list at all. */
|
"small" aggregates to the list at all. */
|
if (optimize == 0 && tree_low_cst (DECL_SIZE_UNIT (var), 1) < 32)
|
if (optimize == 0 && tree_low_cst (DECL_SIZE_UNIT (var), 1) < 32)
|
return false;
|
return false;
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* A subroutine of expand_used_vars. Expand one variable according to
|
/* A subroutine of expand_used_vars. Expand one variable according to
|
its flavor. Variables to be placed on the stack are not actually
|
its flavor. Variables to be placed on the stack are not actually
|
expanded yet, merely recorded. */
|
expanded yet, merely recorded. */
|
|
|
static void
|
static void
|
expand_one_var (tree var, bool toplevel)
|
expand_one_var (tree var, bool toplevel)
|
{
|
{
|
if (TREE_CODE (var) != VAR_DECL)
|
if (TREE_CODE (var) != VAR_DECL)
|
lang_hooks.expand_decl (var);
|
lang_hooks.expand_decl (var);
|
else if (DECL_EXTERNAL (var))
|
else if (DECL_EXTERNAL (var))
|
;
|
;
|
else if (DECL_HAS_VALUE_EXPR_P (var))
|
else if (DECL_HAS_VALUE_EXPR_P (var))
|
;
|
;
|
else if (TREE_STATIC (var))
|
else if (TREE_STATIC (var))
|
expand_one_static_var (var);
|
expand_one_static_var (var);
|
else if (DECL_RTL_SET_P (var))
|
else if (DECL_RTL_SET_P (var))
|
;
|
;
|
else if (TREE_TYPE (var) == error_mark_node)
|
else if (TREE_TYPE (var) == error_mark_node)
|
expand_one_error_var (var);
|
expand_one_error_var (var);
|
else if (DECL_HARD_REGISTER (var))
|
else if (DECL_HARD_REGISTER (var))
|
expand_one_hard_reg_var (var);
|
expand_one_hard_reg_var (var);
|
else if (use_register_for_decl (var))
|
else if (use_register_for_decl (var))
|
expand_one_register_var (var);
|
expand_one_register_var (var);
|
else if (defer_stack_allocation (var, toplevel))
|
else if (defer_stack_allocation (var, toplevel))
|
add_stack_var (var);
|
add_stack_var (var);
|
else
|
else
|
expand_one_stack_var (var);
|
expand_one_stack_var (var);
|
}
|
}
|
|
|
/* A subroutine of expand_used_vars. Walk down through the BLOCK tree
|
/* A subroutine of expand_used_vars. Walk down through the BLOCK tree
|
expanding variables. Those variables that can be put into registers
|
expanding variables. Those variables that can be put into registers
|
are allocated pseudos; those that can't are put on the stack.
|
are allocated pseudos; those that can't are put on the stack.
|
|
|
TOPLEVEL is true if this is the outermost BLOCK. */
|
TOPLEVEL is true if this is the outermost BLOCK. */
|
|
|
static void
|
static void
|
expand_used_vars_for_block (tree block, bool toplevel)
|
expand_used_vars_for_block (tree block, bool toplevel)
|
{
|
{
|
size_t i, j, old_sv_num, this_sv_num, new_sv_num;
|
size_t i, j, old_sv_num, this_sv_num, new_sv_num;
|
tree t;
|
tree t;
|
|
|
old_sv_num = toplevel ? 0 : stack_vars_num;
|
old_sv_num = toplevel ? 0 : stack_vars_num;
|
|
|
/* Expand all variables at this level. */
|
/* Expand all variables at this level. */
|
for (t = BLOCK_VARS (block); t ; t = TREE_CHAIN (t))
|
for (t = BLOCK_VARS (block); t ; t = TREE_CHAIN (t))
|
if (TREE_USED (t)
|
if (TREE_USED (t)
|
/* Force local static variables to be output when marked by
|
/* Force local static variables to be output when marked by
|
used attribute. For unit-at-a-time, cgraph code already takes
|
used attribute. For unit-at-a-time, cgraph code already takes
|
care of this. */
|
care of this. */
|
|| (!flag_unit_at_a_time && TREE_STATIC (t)
|
|| (!flag_unit_at_a_time && TREE_STATIC (t)
|
&& DECL_PRESERVE_P (t)))
|
&& DECL_PRESERVE_P (t)))
|
expand_one_var (t, toplevel);
|
expand_one_var (t, toplevel);
|
|
|
this_sv_num = stack_vars_num;
|
this_sv_num = stack_vars_num;
|
|
|
/* Expand all variables at containing levels. */
|
/* Expand all variables at containing levels. */
|
for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
|
for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
|
expand_used_vars_for_block (t, false);
|
expand_used_vars_for_block (t, false);
|
|
|
/* Since we do not track exact variable lifetimes (which is not even
|
/* Since we do not track exact variable lifetimes (which is not even
|
possible for variables whose address escapes), we mirror the block
|
possible for variables whose address escapes), we mirror the block
|
tree in the interference graph. Here we cause all variables at this
|
tree in the interference graph. Here we cause all variables at this
|
level, and all sublevels, to conflict. Do make certain that a
|
level, and all sublevels, to conflict. Do make certain that a
|
variable conflicts with itself. */
|
variable conflicts with itself. */
|
if (old_sv_num < this_sv_num)
|
if (old_sv_num < this_sv_num)
|
{
|
{
|
new_sv_num = stack_vars_num;
|
new_sv_num = stack_vars_num;
|
resize_stack_vars_conflict (new_sv_num);
|
resize_stack_vars_conflict (new_sv_num);
|
|
|
for (i = old_sv_num; i < new_sv_num; ++i)
|
for (i = old_sv_num; i < new_sv_num; ++i)
|
for (j = i < this_sv_num ? i+1 : this_sv_num; j-- > old_sv_num ;)
|
for (j = i < this_sv_num ? i+1 : this_sv_num; j-- > old_sv_num ;)
|
add_stack_var_conflict (i, j);
|
add_stack_var_conflict (i, j);
|
}
|
}
|
}
|
}
|
|
|
/* A subroutine of expand_used_vars. Walk down through the BLOCK tree
|
/* A subroutine of expand_used_vars. Walk down through the BLOCK tree
|
and clear TREE_USED on all local variables. */
|
and clear TREE_USED on all local variables. */
|
|
|
static void
|
static void
|
clear_tree_used (tree block)
|
clear_tree_used (tree block)
|
{
|
{
|
tree t;
|
tree t;
|
|
|
for (t = BLOCK_VARS (block); t ; t = TREE_CHAIN (t))
|
for (t = BLOCK_VARS (block); t ; t = TREE_CHAIN (t))
|
/* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
|
/* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
|
TREE_USED (t) = 0;
|
TREE_USED (t) = 0;
|
|
|
for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
|
for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
|
clear_tree_used (t);
|
clear_tree_used (t);
|
}
|
}
|
|
|
/* Examine TYPE and determine a bit mask of the following features. */
|
/* Examine TYPE and determine a bit mask of the following features. */
|
|
|
#define SPCT_HAS_LARGE_CHAR_ARRAY 1
|
#define SPCT_HAS_LARGE_CHAR_ARRAY 1
|
#define SPCT_HAS_SMALL_CHAR_ARRAY 2
|
#define SPCT_HAS_SMALL_CHAR_ARRAY 2
|
#define SPCT_HAS_ARRAY 4
|
#define SPCT_HAS_ARRAY 4
|
#define SPCT_HAS_AGGREGATE 8
|
#define SPCT_HAS_AGGREGATE 8
|
|
|
static unsigned int
|
static unsigned int
|
stack_protect_classify_type (tree type)
|
stack_protect_classify_type (tree type)
|
{
|
{
|
unsigned int ret = 0;
|
unsigned int ret = 0;
|
tree t;
|
tree t;
|
|
|
switch (TREE_CODE (type))
|
switch (TREE_CODE (type))
|
{
|
{
|
case ARRAY_TYPE:
|
case ARRAY_TYPE:
|
t = TYPE_MAIN_VARIANT (TREE_TYPE (type));
|
t = TYPE_MAIN_VARIANT (TREE_TYPE (type));
|
if (t == char_type_node
|
if (t == char_type_node
|
|| t == signed_char_type_node
|
|| t == signed_char_type_node
|
|| t == unsigned_char_type_node)
|
|| t == unsigned_char_type_node)
|
{
|
{
|
unsigned HOST_WIDE_INT max = PARAM_VALUE (PARAM_SSP_BUFFER_SIZE);
|
unsigned HOST_WIDE_INT max = PARAM_VALUE (PARAM_SSP_BUFFER_SIZE);
|
unsigned HOST_WIDE_INT len;
|
unsigned HOST_WIDE_INT len;
|
|
|
if (!TYPE_SIZE_UNIT (type)
|
if (!TYPE_SIZE_UNIT (type)
|
|| !host_integerp (TYPE_SIZE_UNIT (type), 1))
|
|| !host_integerp (TYPE_SIZE_UNIT (type), 1))
|
len = max;
|
len = max;
|
else
|
else
|
len = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
|
len = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
|
|
|
if (len < max)
|
if (len < max)
|
ret = SPCT_HAS_SMALL_CHAR_ARRAY | SPCT_HAS_ARRAY;
|
ret = SPCT_HAS_SMALL_CHAR_ARRAY | SPCT_HAS_ARRAY;
|
else
|
else
|
ret = SPCT_HAS_LARGE_CHAR_ARRAY | SPCT_HAS_ARRAY;
|
ret = SPCT_HAS_LARGE_CHAR_ARRAY | SPCT_HAS_ARRAY;
|
}
|
}
|
else
|
else
|
ret = SPCT_HAS_ARRAY;
|
ret = SPCT_HAS_ARRAY;
|
break;
|
break;
|
|
|
case UNION_TYPE:
|
case UNION_TYPE:
|
case QUAL_UNION_TYPE:
|
case QUAL_UNION_TYPE:
|
case RECORD_TYPE:
|
case RECORD_TYPE:
|
ret = SPCT_HAS_AGGREGATE;
|
ret = SPCT_HAS_AGGREGATE;
|
for (t = TYPE_FIELDS (type); t ; t = TREE_CHAIN (t))
|
for (t = TYPE_FIELDS (type); t ; t = TREE_CHAIN (t))
|
if (TREE_CODE (t) == FIELD_DECL)
|
if (TREE_CODE (t) == FIELD_DECL)
|
ret |= stack_protect_classify_type (TREE_TYPE (t));
|
ret |= stack_protect_classify_type (TREE_TYPE (t));
|
break;
|
break;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/* Return nonzero if DECL should be segregated into the "vulnerable" upper
|
/* Return nonzero if DECL should be segregated into the "vulnerable" upper
|
part of the local stack frame. Remember if we ever return nonzero for
|
part of the local stack frame. Remember if we ever return nonzero for
|
any variable in this function. The return value is the phase number in
|
any variable in this function. The return value is the phase number in
|
which the variable should be allocated. */
|
which the variable should be allocated. */
|
|
|
static int
|
static int
|
stack_protect_decl_phase (tree decl)
|
stack_protect_decl_phase (tree decl)
|
{
|
{
|
unsigned int bits = stack_protect_classify_type (TREE_TYPE (decl));
|
unsigned int bits = stack_protect_classify_type (TREE_TYPE (decl));
|
int ret = 0;
|
int ret = 0;
|
|
|
if (bits & SPCT_HAS_SMALL_CHAR_ARRAY)
|
if (bits & SPCT_HAS_SMALL_CHAR_ARRAY)
|
has_short_buffer = true;
|
has_short_buffer = true;
|
|
|
if (flag_stack_protect == 2)
|
if (flag_stack_protect == 2)
|
{
|
{
|
if ((bits & (SPCT_HAS_SMALL_CHAR_ARRAY | SPCT_HAS_LARGE_CHAR_ARRAY))
|
if ((bits & (SPCT_HAS_SMALL_CHAR_ARRAY | SPCT_HAS_LARGE_CHAR_ARRAY))
|
&& !(bits & SPCT_HAS_AGGREGATE))
|
&& !(bits & SPCT_HAS_AGGREGATE))
|
ret = 1;
|
ret = 1;
|
else if (bits & SPCT_HAS_ARRAY)
|
else if (bits & SPCT_HAS_ARRAY)
|
ret = 2;
|
ret = 2;
|
}
|
}
|
else
|
else
|
ret = (bits & SPCT_HAS_LARGE_CHAR_ARRAY) != 0;
|
ret = (bits & SPCT_HAS_LARGE_CHAR_ARRAY) != 0;
|
|
|
if (ret)
|
if (ret)
|
has_protected_decls = true;
|
has_protected_decls = true;
|
|
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/* Two helper routines that check for phase 1 and phase 2. These are used
|
/* Two helper routines that check for phase 1 and phase 2. These are used
|
as callbacks for expand_stack_vars. */
|
as callbacks for expand_stack_vars. */
|
|
|
static bool
|
static bool
|
stack_protect_decl_phase_1 (tree decl)
|
stack_protect_decl_phase_1 (tree decl)
|
{
|
{
|
return stack_protect_decl_phase (decl) == 1;
|
return stack_protect_decl_phase (decl) == 1;
|
}
|
}
|
|
|
static bool
|
static bool
|
stack_protect_decl_phase_2 (tree decl)
|
stack_protect_decl_phase_2 (tree decl)
|
{
|
{
|
return stack_protect_decl_phase (decl) == 2;
|
return stack_protect_decl_phase (decl) == 2;
|
}
|
}
|
|
|
/* Ensure that variables in different stack protection phases conflict
|
/* Ensure that variables in different stack protection phases conflict
|
so that they are not merged and share the same stack slot. */
|
so that they are not merged and share the same stack slot. */
|
|
|
static void
|
static void
|
add_stack_protection_conflicts (void)
|
add_stack_protection_conflicts (void)
|
{
|
{
|
size_t i, j, n = stack_vars_num;
|
size_t i, j, n = stack_vars_num;
|
unsigned char *phase;
|
unsigned char *phase;
|
|
|
phase = XNEWVEC (unsigned char, n);
|
phase = XNEWVEC (unsigned char, n);
|
for (i = 0; i < n; ++i)
|
for (i = 0; i < n; ++i)
|
phase[i] = stack_protect_decl_phase (stack_vars[i].decl);
|
phase[i] = stack_protect_decl_phase (stack_vars[i].decl);
|
|
|
for (i = 0; i < n; ++i)
|
for (i = 0; i < n; ++i)
|
{
|
{
|
unsigned char ph_i = phase[i];
|
unsigned char ph_i = phase[i];
|
for (j = 0; j < i; ++j)
|
for (j = 0; j < i; ++j)
|
if (ph_i != phase[j])
|
if (ph_i != phase[j])
|
add_stack_var_conflict (i, j);
|
add_stack_var_conflict (i, j);
|
}
|
}
|
|
|
XDELETEVEC (phase);
|
XDELETEVEC (phase);
|
}
|
}
|
|
|
/* Create a decl for the guard at the top of the stack frame. */
|
/* Create a decl for the guard at the top of the stack frame. */
|
|
|
static void
|
static void
|
create_stack_guard (void)
|
create_stack_guard (void)
|
{
|
{
|
tree guard = build_decl (VAR_DECL, NULL, ptr_type_node);
|
tree guard = build_decl (VAR_DECL, NULL, ptr_type_node);
|
TREE_THIS_VOLATILE (guard) = 1;
|
TREE_THIS_VOLATILE (guard) = 1;
|
TREE_USED (guard) = 1;
|
TREE_USED (guard) = 1;
|
expand_one_stack_var (guard);
|
expand_one_stack_var (guard);
|
cfun->stack_protect_guard = guard;
|
cfun->stack_protect_guard = guard;
|
}
|
}
|
|
|
/* Expand all variables used in the function. */
|
/* Expand all variables used in the function. */
|
|
|
static void
|
static void
|
expand_used_vars (void)
|
expand_used_vars (void)
|
{
|
{
|
tree t, outer_block = DECL_INITIAL (current_function_decl);
|
tree t, outer_block = DECL_INITIAL (current_function_decl);
|
|
|
/* Compute the phase of the stack frame for this function. */
|
/* Compute the phase of the stack frame for this function. */
|
{
|
{
|
int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
|
int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
|
int off = STARTING_FRAME_OFFSET % align;
|
int off = STARTING_FRAME_OFFSET % align;
|
frame_phase = off ? align - off : 0;
|
frame_phase = off ? align - off : 0;
|
}
|
}
|
|
|
/* Set TREE_USED on all variables in the unexpanded_var_list. */
|
/* Set TREE_USED on all variables in the unexpanded_var_list. */
|
for (t = cfun->unexpanded_var_list; t; t = TREE_CHAIN (t))
|
for (t = cfun->unexpanded_var_list; t; t = TREE_CHAIN (t))
|
TREE_USED (TREE_VALUE (t)) = 1;
|
TREE_USED (TREE_VALUE (t)) = 1;
|
|
|
/* Clear TREE_USED on all variables associated with a block scope. */
|
/* Clear TREE_USED on all variables associated with a block scope. */
|
clear_tree_used (outer_block);
|
clear_tree_used (outer_block);
|
|
|
/* Initialize local stack smashing state. */
|
/* Initialize local stack smashing state. */
|
has_protected_decls = false;
|
has_protected_decls = false;
|
has_short_buffer = false;
|
has_short_buffer = false;
|
|
|
/* At this point all variables on the unexpanded_var_list with TREE_USED
|
/* At this point all variables on the unexpanded_var_list with TREE_USED
|
set are not associated with any block scope. Lay them out. */
|
set are not associated with any block scope. Lay them out. */
|
for (t = cfun->unexpanded_var_list; t; t = TREE_CHAIN (t))
|
for (t = cfun->unexpanded_var_list; t; t = TREE_CHAIN (t))
|
{
|
{
|
tree var = TREE_VALUE (t);
|
tree var = TREE_VALUE (t);
|
bool expand_now = false;
|
bool expand_now = false;
|
|
|
/* We didn't set a block for static or extern because it's hard
|
/* We didn't set a block for static or extern because it's hard
|
to tell the difference between a global variable (re)declared
|
to tell the difference between a global variable (re)declared
|
in a local scope, and one that's really declared there to
|
in a local scope, and one that's really declared there to
|
begin with. And it doesn't really matter much, since we're
|
begin with. And it doesn't really matter much, since we're
|
not giving them stack space. Expand them now. */
|
not giving them stack space. Expand them now. */
|
if (TREE_STATIC (var) || DECL_EXTERNAL (var))
|
if (TREE_STATIC (var) || DECL_EXTERNAL (var))
|
expand_now = true;
|
expand_now = true;
|
|
|
/* Any variable that could have been hoisted into an SSA_NAME
|
/* Any variable that could have been hoisted into an SSA_NAME
|
will have been propagated anywhere the optimizers chose,
|
will have been propagated anywhere the optimizers chose,
|
i.e. not confined to their original block. Allocate them
|
i.e. not confined to their original block. Allocate them
|
as if they were defined in the outermost scope. */
|
as if they were defined in the outermost scope. */
|
else if (is_gimple_reg (var))
|
else if (is_gimple_reg (var))
|
expand_now = true;
|
expand_now = true;
|
|
|
/* If the variable is not associated with any block, then it
|
/* If the variable is not associated with any block, then it
|
was created by the optimizers, and could be live anywhere
|
was created by the optimizers, and could be live anywhere
|
in the function. */
|
in the function. */
|
else if (TREE_USED (var))
|
else if (TREE_USED (var))
|
expand_now = true;
|
expand_now = true;
|
|
|
/* Finally, mark all variables on the list as used. We'll use
|
/* Finally, mark all variables on the list as used. We'll use
|
this in a moment when we expand those associated with scopes. */
|
this in a moment when we expand those associated with scopes. */
|
TREE_USED (var) = 1;
|
TREE_USED (var) = 1;
|
|
|
if (expand_now)
|
if (expand_now)
|
expand_one_var (var, true);
|
expand_one_var (var, true);
|
}
|
}
|
cfun->unexpanded_var_list = NULL_TREE;
|
cfun->unexpanded_var_list = NULL_TREE;
|
|
|
/* At this point, all variables within the block tree with TREE_USED
|
/* At this point, all variables within the block tree with TREE_USED
|
set are actually used by the optimized function. Lay them out. */
|
set are actually used by the optimized function. Lay them out. */
|
expand_used_vars_for_block (outer_block, true);
|
expand_used_vars_for_block (outer_block, true);
|
|
|
if (stack_vars_num > 0)
|
if (stack_vars_num > 0)
|
{
|
{
|
/* Due to the way alias sets work, no variables with non-conflicting
|
/* Due to the way alias sets work, no variables with non-conflicting
|
alias sets may be assigned the same address. Add conflicts to
|
alias sets may be assigned the same address. Add conflicts to
|
reflect this. */
|
reflect this. */
|
add_alias_set_conflicts ();
|
add_alias_set_conflicts ();
|
|
|
/* If stack protection is enabled, we don't share space between
|
/* If stack protection is enabled, we don't share space between
|
vulnerable data and non-vulnerable data. */
|
vulnerable data and non-vulnerable data. */
|
if (flag_stack_protect)
|
if (flag_stack_protect)
|
add_stack_protection_conflicts ();
|
add_stack_protection_conflicts ();
|
|
|
/* Now that we have collected all stack variables, and have computed a
|
/* Now that we have collected all stack variables, and have computed a
|
minimal interference graph, attempt to save some stack space. */
|
minimal interference graph, attempt to save some stack space. */
|
partition_stack_vars ();
|
partition_stack_vars ();
|
if (dump_file)
|
if (dump_file)
|
dump_stack_var_partition ();
|
dump_stack_var_partition ();
|
}
|
}
|
|
|
/* There are several conditions under which we should create a
|
/* There are several conditions under which we should create a
|
stack guard: protect-all, alloca used, protected decls present. */
|
stack guard: protect-all, alloca used, protected decls present. */
|
if (flag_stack_protect == 2
|
if (flag_stack_protect == 2
|
|| (flag_stack_protect
|
|| (flag_stack_protect
|
&& (current_function_calls_alloca || has_protected_decls)))
|
&& (current_function_calls_alloca || has_protected_decls)))
|
create_stack_guard ();
|
create_stack_guard ();
|
|
|
/* Assign rtl to each variable based on these partitions. */
|
/* Assign rtl to each variable based on these partitions. */
|
if (stack_vars_num > 0)
|
if (stack_vars_num > 0)
|
{
|
{
|
/* Reorder decls to be protected by iterating over the variables
|
/* Reorder decls to be protected by iterating over the variables
|
array multiple times, and allocating out of each phase in turn. */
|
array multiple times, and allocating out of each phase in turn. */
|
/* ??? We could probably integrate this into the qsort we did
|
/* ??? We could probably integrate this into the qsort we did
|
earlier, such that we naturally see these variables first,
|
earlier, such that we naturally see these variables first,
|
and thus naturally allocate things in the right order. */
|
and thus naturally allocate things in the right order. */
|
if (has_protected_decls)
|
if (has_protected_decls)
|
{
|
{
|
/* Phase 1 contains only character arrays. */
|
/* Phase 1 contains only character arrays. */
|
expand_stack_vars (stack_protect_decl_phase_1);
|
expand_stack_vars (stack_protect_decl_phase_1);
|
|
|
/* Phase 2 contains other kinds of arrays. */
|
/* Phase 2 contains other kinds of arrays. */
|
if (flag_stack_protect == 2)
|
if (flag_stack_protect == 2)
|
expand_stack_vars (stack_protect_decl_phase_2);
|
expand_stack_vars (stack_protect_decl_phase_2);
|
}
|
}
|
|
|
expand_stack_vars (NULL);
|
expand_stack_vars (NULL);
|
|
|
/* Free up stack variable graph data. */
|
/* Free up stack variable graph data. */
|
XDELETEVEC (stack_vars);
|
XDELETEVEC (stack_vars);
|
XDELETEVEC (stack_vars_sorted);
|
XDELETEVEC (stack_vars_sorted);
|
XDELETEVEC (stack_vars_conflict);
|
XDELETEVEC (stack_vars_conflict);
|
stack_vars = NULL;
|
stack_vars = NULL;
|
stack_vars_alloc = stack_vars_num = 0;
|
stack_vars_alloc = stack_vars_num = 0;
|
stack_vars_conflict = NULL;
|
stack_vars_conflict = NULL;
|
stack_vars_conflict_alloc = 0;
|
stack_vars_conflict_alloc = 0;
|
}
|
}
|
|
|
/* If the target requires that FRAME_OFFSET be aligned, do it. */
|
/* If the target requires that FRAME_OFFSET be aligned, do it. */
|
if (STACK_ALIGNMENT_NEEDED)
|
if (STACK_ALIGNMENT_NEEDED)
|
{
|
{
|
HOST_WIDE_INT align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
|
HOST_WIDE_INT align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
|
if (!FRAME_GROWS_DOWNWARD)
|
if (!FRAME_GROWS_DOWNWARD)
|
frame_offset += align - 1;
|
frame_offset += align - 1;
|
frame_offset &= -align;
|
frame_offset &= -align;
|
}
|
}
|
}
|
}
|
|
|
|
|
/* If we need to produce a detailed dump, print the tree representation
|
/* If we need to produce a detailed dump, print the tree representation
|
for STMT to the dump file. SINCE is the last RTX after which the RTL
|
for STMT to the dump file. SINCE is the last RTX after which the RTL
|
generated for STMT should have been appended. */
|
generated for STMT should have been appended. */
|
|
|
static void
|
static void
|
maybe_dump_rtl_for_tree_stmt (tree stmt, rtx since)
|
maybe_dump_rtl_for_tree_stmt (tree stmt, rtx since)
|
{
|
{
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "\n;; ");
|
fprintf (dump_file, "\n;; ");
|
print_generic_expr (dump_file, stmt, TDF_SLIM);
|
print_generic_expr (dump_file, stmt, TDF_SLIM);
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
|
|
print_rtl (dump_file, since ? NEXT_INSN (since) : since);
|
print_rtl (dump_file, since ? NEXT_INSN (since) : since);
|
}
|
}
|
}
|
}
|
|
|
/* A subroutine of expand_gimple_basic_block. Expand one COND_EXPR.
|
/* A subroutine of expand_gimple_basic_block. Expand one COND_EXPR.
|
Returns a new basic block if we've terminated the current basic
|
Returns a new basic block if we've terminated the current basic
|
block and created a new one. */
|
block and created a new one. */
|
|
|
static basic_block
|
static basic_block
|
expand_gimple_cond_expr (basic_block bb, tree stmt)
|
expand_gimple_cond_expr (basic_block bb, tree stmt)
|
{
|
{
|
basic_block new_bb, dest;
|
basic_block new_bb, dest;
|
edge new_edge;
|
edge new_edge;
|
edge true_edge;
|
edge true_edge;
|
edge false_edge;
|
edge false_edge;
|
tree pred = COND_EXPR_COND (stmt);
|
tree pred = COND_EXPR_COND (stmt);
|
tree then_exp = COND_EXPR_THEN (stmt);
|
tree then_exp = COND_EXPR_THEN (stmt);
|
tree else_exp = COND_EXPR_ELSE (stmt);
|
tree else_exp = COND_EXPR_ELSE (stmt);
|
rtx last2, last;
|
rtx last2, last;
|
|
|
last2 = last = get_last_insn ();
|
last2 = last = get_last_insn ();
|
|
|
extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
|
extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
|
if (EXPR_LOCUS (stmt))
|
if (EXPR_LOCUS (stmt))
|
{
|
{
|
emit_line_note (*(EXPR_LOCUS (stmt)));
|
emit_line_note (*(EXPR_LOCUS (stmt)));
|
record_block_change (TREE_BLOCK (stmt));
|
record_block_change (TREE_BLOCK (stmt));
|
}
|
}
|
|
|
/* These flags have no purpose in RTL land. */
|
/* These flags have no purpose in RTL land. */
|
true_edge->flags &= ~EDGE_TRUE_VALUE;
|
true_edge->flags &= ~EDGE_TRUE_VALUE;
|
false_edge->flags &= ~EDGE_FALSE_VALUE;
|
false_edge->flags &= ~EDGE_FALSE_VALUE;
|
|
|
/* We can either have a pure conditional jump with one fallthru edge or
|
/* We can either have a pure conditional jump with one fallthru edge or
|
two-way jump that needs to be decomposed into two basic blocks. */
|
two-way jump that needs to be decomposed into two basic blocks. */
|
if (TREE_CODE (then_exp) == GOTO_EXPR && IS_EMPTY_STMT (else_exp))
|
if (TREE_CODE (then_exp) == GOTO_EXPR && IS_EMPTY_STMT (else_exp))
|
{
|
{
|
jumpif (pred, label_rtx (GOTO_DESTINATION (then_exp)));
|
jumpif (pred, label_rtx (GOTO_DESTINATION (then_exp)));
|
add_reg_br_prob_note (last, true_edge->probability);
|
add_reg_br_prob_note (last, true_edge->probability);
|
maybe_dump_rtl_for_tree_stmt (stmt, last);
|
maybe_dump_rtl_for_tree_stmt (stmt, last);
|
if (EXPR_LOCUS (then_exp))
|
if (EXPR_LOCUS (then_exp))
|
emit_line_note (*(EXPR_LOCUS (then_exp)));
|
emit_line_note (*(EXPR_LOCUS (then_exp)));
|
return NULL;
|
return NULL;
|
}
|
}
|
if (TREE_CODE (else_exp) == GOTO_EXPR && IS_EMPTY_STMT (then_exp))
|
if (TREE_CODE (else_exp) == GOTO_EXPR && IS_EMPTY_STMT (then_exp))
|
{
|
{
|
jumpifnot (pred, label_rtx (GOTO_DESTINATION (else_exp)));
|
jumpifnot (pred, label_rtx (GOTO_DESTINATION (else_exp)));
|
add_reg_br_prob_note (last, false_edge->probability);
|
add_reg_br_prob_note (last, false_edge->probability);
|
maybe_dump_rtl_for_tree_stmt (stmt, last);
|
maybe_dump_rtl_for_tree_stmt (stmt, last);
|
if (EXPR_LOCUS (else_exp))
|
if (EXPR_LOCUS (else_exp))
|
emit_line_note (*(EXPR_LOCUS (else_exp)));
|
emit_line_note (*(EXPR_LOCUS (else_exp)));
|
return NULL;
|
return NULL;
|
}
|
}
|
gcc_assert (TREE_CODE (then_exp) == GOTO_EXPR
|
gcc_assert (TREE_CODE (then_exp) == GOTO_EXPR
|
&& TREE_CODE (else_exp) == GOTO_EXPR);
|
&& TREE_CODE (else_exp) == GOTO_EXPR);
|
|
|
jumpif (pred, label_rtx (GOTO_DESTINATION (then_exp)));
|
jumpif (pred, label_rtx (GOTO_DESTINATION (then_exp)));
|
add_reg_br_prob_note (last, true_edge->probability);
|
add_reg_br_prob_note (last, true_edge->probability);
|
last = get_last_insn ();
|
last = get_last_insn ();
|
expand_expr (else_exp, const0_rtx, VOIDmode, 0);
|
expand_expr (else_exp, const0_rtx, VOIDmode, 0);
|
|
|
BB_END (bb) = last;
|
BB_END (bb) = last;
|
if (BARRIER_P (BB_END (bb)))
|
if (BARRIER_P (BB_END (bb)))
|
BB_END (bb) = PREV_INSN (BB_END (bb));
|
BB_END (bb) = PREV_INSN (BB_END (bb));
|
update_bb_for_insn (bb);
|
update_bb_for_insn (bb);
|
|
|
new_bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
|
new_bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
|
dest = false_edge->dest;
|
dest = false_edge->dest;
|
redirect_edge_succ (false_edge, new_bb);
|
redirect_edge_succ (false_edge, new_bb);
|
false_edge->flags |= EDGE_FALLTHRU;
|
false_edge->flags |= EDGE_FALLTHRU;
|
new_bb->count = false_edge->count;
|
new_bb->count = false_edge->count;
|
new_bb->frequency = EDGE_FREQUENCY (false_edge);
|
new_bb->frequency = EDGE_FREQUENCY (false_edge);
|
new_edge = make_edge (new_bb, dest, 0);
|
new_edge = make_edge (new_bb, dest, 0);
|
new_edge->probability = REG_BR_PROB_BASE;
|
new_edge->probability = REG_BR_PROB_BASE;
|
new_edge->count = new_bb->count;
|
new_edge->count = new_bb->count;
|
if (BARRIER_P (BB_END (new_bb)))
|
if (BARRIER_P (BB_END (new_bb)))
|
BB_END (new_bb) = PREV_INSN (BB_END (new_bb));
|
BB_END (new_bb) = PREV_INSN (BB_END (new_bb));
|
update_bb_for_insn (new_bb);
|
update_bb_for_insn (new_bb);
|
|
|
maybe_dump_rtl_for_tree_stmt (stmt, last2);
|
maybe_dump_rtl_for_tree_stmt (stmt, last2);
|
|
|
if (EXPR_LOCUS (else_exp))
|
if (EXPR_LOCUS (else_exp))
|
emit_line_note (*(EXPR_LOCUS (else_exp)));
|
emit_line_note (*(EXPR_LOCUS (else_exp)));
|
|
|
return new_bb;
|
return new_bb;
|
}
|
}
|
|
|
/* A subroutine of expand_gimple_basic_block. Expand one CALL_EXPR
|
/* A subroutine of expand_gimple_basic_block. Expand one CALL_EXPR
|
that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
|
that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
|
generated a tail call (something that might be denied by the ABI
|
generated a tail call (something that might be denied by the ABI
|
rules governing the call; see calls.c).
|
rules governing the call; see calls.c).
|
|
|
Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
|
Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
|
can still reach the rest of BB. The case here is __builtin_sqrt,
|
can still reach the rest of BB. The case here is __builtin_sqrt,
|
where the NaN result goes through the external function (with a
|
where the NaN result goes through the external function (with a
|
tailcall) and the normal result happens via a sqrt instruction. */
|
tailcall) and the normal result happens via a sqrt instruction. */
|
|
|
static basic_block
|
static basic_block
|
expand_gimple_tailcall (basic_block bb, tree stmt, bool *can_fallthru)
|
expand_gimple_tailcall (basic_block bb, tree stmt, bool *can_fallthru)
|
{
|
{
|
rtx last2, last;
|
rtx last2, last;
|
edge e;
|
edge e;
|
edge_iterator ei;
|
edge_iterator ei;
|
int probability;
|
int probability;
|
gcov_type count;
|
gcov_type count;
|
|
|
last2 = last = get_last_insn ();
|
last2 = last = get_last_insn ();
|
|
|
expand_expr_stmt (stmt);
|
expand_expr_stmt (stmt);
|
|
|
for (last = NEXT_INSN (last); last; last = NEXT_INSN (last))
|
for (last = NEXT_INSN (last); last; last = NEXT_INSN (last))
|
if (CALL_P (last) && SIBLING_CALL_P (last))
|
if (CALL_P (last) && SIBLING_CALL_P (last))
|
goto found;
|
goto found;
|
|
|
maybe_dump_rtl_for_tree_stmt (stmt, last2);
|
maybe_dump_rtl_for_tree_stmt (stmt, last2);
|
|
|
*can_fallthru = true;
|
*can_fallthru = true;
|
return NULL;
|
return NULL;
|
|
|
found:
|
found:
|
/* ??? Wouldn't it be better to just reset any pending stack adjust?
|
/* ??? Wouldn't it be better to just reset any pending stack adjust?
|
Any instructions emitted here are about to be deleted. */
|
Any instructions emitted here are about to be deleted. */
|
do_pending_stack_adjust ();
|
do_pending_stack_adjust ();
|
|
|
/* Remove any non-eh, non-abnormal edges that don't go to exit. */
|
/* Remove any non-eh, non-abnormal edges that don't go to exit. */
|
/* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
|
/* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
|
EH or abnormal edges, we shouldn't have created a tail call in
|
EH or abnormal edges, we shouldn't have created a tail call in
|
the first place. So it seems to me we should just be removing
|
the first place. So it seems to me we should just be removing
|
all edges here, or redirecting the existing fallthru edge to
|
all edges here, or redirecting the existing fallthru edge to
|
the exit block. */
|
the exit block. */
|
|
|
probability = 0;
|
probability = 0;
|
count = 0;
|
count = 0;
|
|
|
for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
|
for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
|
{
|
{
|
if (!(e->flags & (EDGE_ABNORMAL | EDGE_EH)))
|
if (!(e->flags & (EDGE_ABNORMAL | EDGE_EH)))
|
{
|
{
|
if (e->dest != EXIT_BLOCK_PTR)
|
if (e->dest != EXIT_BLOCK_PTR)
|
{
|
{
|
e->dest->count -= e->count;
|
e->dest->count -= e->count;
|
e->dest->frequency -= EDGE_FREQUENCY (e);
|
e->dest->frequency -= EDGE_FREQUENCY (e);
|
if (e->dest->count < 0)
|
if (e->dest->count < 0)
|
e->dest->count = 0;
|
e->dest->count = 0;
|
if (e->dest->frequency < 0)
|
if (e->dest->frequency < 0)
|
e->dest->frequency = 0;
|
e->dest->frequency = 0;
|
}
|
}
|
count += e->count;
|
count += e->count;
|
probability += e->probability;
|
probability += e->probability;
|
remove_edge (e);
|
remove_edge (e);
|
}
|
}
|
else
|
else
|
ei_next (&ei);
|
ei_next (&ei);
|
}
|
}
|
|
|
/* This is somewhat ugly: the call_expr expander often emits instructions
|
/* This is somewhat ugly: the call_expr expander often emits instructions
|
after the sibcall (to perform the function return). These confuse the
|
after the sibcall (to perform the function return). These confuse the
|
find_many_sub_basic_blocks code, so we need to get rid of these. */
|
find_many_sub_basic_blocks code, so we need to get rid of these. */
|
last = NEXT_INSN (last);
|
last = NEXT_INSN (last);
|
gcc_assert (BARRIER_P (last));
|
gcc_assert (BARRIER_P (last));
|
|
|
*can_fallthru = false;
|
*can_fallthru = false;
|
while (NEXT_INSN (last))
|
while (NEXT_INSN (last))
|
{
|
{
|
/* For instance an sqrt builtin expander expands if with
|
/* For instance an sqrt builtin expander expands if with
|
sibcall in the then and label for `else`. */
|
sibcall in the then and label for `else`. */
|
if (LABEL_P (NEXT_INSN (last)))
|
if (LABEL_P (NEXT_INSN (last)))
|
{
|
{
|
*can_fallthru = true;
|
*can_fallthru = true;
|
break;
|
break;
|
}
|
}
|
delete_insn (NEXT_INSN (last));
|
delete_insn (NEXT_INSN (last));
|
}
|
}
|
|
|
e = make_edge (bb, EXIT_BLOCK_PTR, EDGE_ABNORMAL | EDGE_SIBCALL);
|
e = make_edge (bb, EXIT_BLOCK_PTR, EDGE_ABNORMAL | EDGE_SIBCALL);
|
e->probability += probability;
|
e->probability += probability;
|
e->count += count;
|
e->count += count;
|
BB_END (bb) = last;
|
BB_END (bb) = last;
|
update_bb_for_insn (bb);
|
update_bb_for_insn (bb);
|
|
|
if (NEXT_INSN (last))
|
if (NEXT_INSN (last))
|
{
|
{
|
bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
|
bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
|
|
|
last = BB_END (bb);
|
last = BB_END (bb);
|
if (BARRIER_P (last))
|
if (BARRIER_P (last))
|
BB_END (bb) = PREV_INSN (last);
|
BB_END (bb) = PREV_INSN (last);
|
}
|
}
|
|
|
maybe_dump_rtl_for_tree_stmt (stmt, last2);
|
maybe_dump_rtl_for_tree_stmt (stmt, last2);
|
|
|
return bb;
|
return bb;
|
}
|
}
|
|
|
/* Expand basic block BB from GIMPLE trees to RTL. */
|
/* Expand basic block BB from GIMPLE trees to RTL. */
|
|
|
static basic_block
|
static basic_block
|
expand_gimple_basic_block (basic_block bb)
|
expand_gimple_basic_block (basic_block bb)
|
{
|
{
|
block_stmt_iterator bsi = bsi_start (bb);
|
block_stmt_iterator bsi = bsi_start (bb);
|
tree stmt = NULL;
|
tree stmt = NULL;
|
rtx note, last;
|
rtx note, last;
|
edge e;
|
edge e;
|
edge_iterator ei;
|
edge_iterator ei;
|
|
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
fprintf (dump_file,
|
fprintf (dump_file,
|
"\n;; Generating RTL for tree basic block %d\n",
|
"\n;; Generating RTL for tree basic block %d\n",
|
bb->index);
|
bb->index);
|
}
|
}
|
|
|
init_rtl_bb_info (bb);
|
init_rtl_bb_info (bb);
|
bb->flags |= BB_RTL;
|
bb->flags |= BB_RTL;
|
|
|
if (!bsi_end_p (bsi))
|
if (!bsi_end_p (bsi))
|
stmt = bsi_stmt (bsi);
|
stmt = bsi_stmt (bsi);
|
|
|
if (stmt && TREE_CODE (stmt) == LABEL_EXPR)
|
if (stmt && TREE_CODE (stmt) == LABEL_EXPR)
|
{
|
{
|
last = get_last_insn ();
|
last = get_last_insn ();
|
|
|
expand_expr_stmt (stmt);
|
expand_expr_stmt (stmt);
|
|
|
/* Java emits line number notes in the top of labels.
|
/* Java emits line number notes in the top of labels.
|
??? Make this go away once line number notes are obsoleted. */
|
??? Make this go away once line number notes are obsoleted. */
|
BB_HEAD (bb) = NEXT_INSN (last);
|
BB_HEAD (bb) = NEXT_INSN (last);
|
if (NOTE_P (BB_HEAD (bb)))
|
if (NOTE_P (BB_HEAD (bb)))
|
BB_HEAD (bb) = NEXT_INSN (BB_HEAD (bb));
|
BB_HEAD (bb) = NEXT_INSN (BB_HEAD (bb));
|
bsi_next (&bsi);
|
bsi_next (&bsi);
|
note = emit_note_after (NOTE_INSN_BASIC_BLOCK, BB_HEAD (bb));
|
note = emit_note_after (NOTE_INSN_BASIC_BLOCK, BB_HEAD (bb));
|
|
|
maybe_dump_rtl_for_tree_stmt (stmt, last);
|
maybe_dump_rtl_for_tree_stmt (stmt, last);
|
}
|
}
|
else
|
else
|
note = BB_HEAD (bb) = emit_note (NOTE_INSN_BASIC_BLOCK);
|
note = BB_HEAD (bb) = emit_note (NOTE_INSN_BASIC_BLOCK);
|
|
|
NOTE_BASIC_BLOCK (note) = bb;
|
NOTE_BASIC_BLOCK (note) = bb;
|
|
|
for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
|
for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
|
{
|
{
|
/* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
|
/* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
|
e->flags &= ~EDGE_EXECUTABLE;
|
e->flags &= ~EDGE_EXECUTABLE;
|
|
|
/* At the moment not all abnormal edges match the RTL representation.
|
/* At the moment not all abnormal edges match the RTL representation.
|
It is safe to remove them here as find_many_sub_basic_blocks will
|
It is safe to remove them here as find_many_sub_basic_blocks will
|
rediscover them. In the future we should get this fixed properly. */
|
rediscover them. In the future we should get this fixed properly. */
|
if (e->flags & EDGE_ABNORMAL)
|
if (e->flags & EDGE_ABNORMAL)
|
remove_edge (e);
|
remove_edge (e);
|
else
|
else
|
ei_next (&ei);
|
ei_next (&ei);
|
}
|
}
|
|
|
for (; !bsi_end_p (bsi); bsi_next (&bsi))
|
for (; !bsi_end_p (bsi); bsi_next (&bsi))
|
{
|
{
|
tree stmt = bsi_stmt (bsi);
|
tree stmt = bsi_stmt (bsi);
|
basic_block new_bb;
|
basic_block new_bb;
|
|
|
if (!stmt)
|
if (!stmt)
|
continue;
|
continue;
|
|
|
/* Expand this statement, then evaluate the resulting RTL and
|
/* Expand this statement, then evaluate the resulting RTL and
|
fixup the CFG accordingly. */
|
fixup the CFG accordingly. */
|
if (TREE_CODE (stmt) == COND_EXPR)
|
if (TREE_CODE (stmt) == COND_EXPR)
|
{
|
{
|
new_bb = expand_gimple_cond_expr (bb, stmt);
|
new_bb = expand_gimple_cond_expr (bb, stmt);
|
if (new_bb)
|
if (new_bb)
|
return new_bb;
|
return new_bb;
|
}
|
}
|
else
|
else
|
{
|
{
|
tree call = get_call_expr_in (stmt);
|
tree call = get_call_expr_in (stmt);
|
if (call && CALL_EXPR_TAILCALL (call))
|
if (call && CALL_EXPR_TAILCALL (call))
|
{
|
{
|
bool can_fallthru;
|
bool can_fallthru;
|
new_bb = expand_gimple_tailcall (bb, stmt, &can_fallthru);
|
new_bb = expand_gimple_tailcall (bb, stmt, &can_fallthru);
|
if (new_bb)
|
if (new_bb)
|
{
|
{
|
if (can_fallthru)
|
if (can_fallthru)
|
bb = new_bb;
|
bb = new_bb;
|
else
|
else
|
return new_bb;
|
return new_bb;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
last = get_last_insn ();
|
last = get_last_insn ();
|
expand_expr_stmt (stmt);
|
expand_expr_stmt (stmt);
|
maybe_dump_rtl_for_tree_stmt (stmt, last);
|
maybe_dump_rtl_for_tree_stmt (stmt, last);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
do_pending_stack_adjust ();
|
do_pending_stack_adjust ();
|
|
|
/* Find the block tail. The last insn in the block is the insn
|
/* Find the block tail. The last insn in the block is the insn
|
before a barrier and/or table jump insn. */
|
before a barrier and/or table jump insn. */
|
last = get_last_insn ();
|
last = get_last_insn ();
|
if (BARRIER_P (last))
|
if (BARRIER_P (last))
|
last = PREV_INSN (last);
|
last = PREV_INSN (last);
|
if (JUMP_TABLE_DATA_P (last))
|
if (JUMP_TABLE_DATA_P (last))
|
last = PREV_INSN (PREV_INSN (last));
|
last = PREV_INSN (PREV_INSN (last));
|
BB_END (bb) = last;
|
BB_END (bb) = last;
|
|
|
update_bb_for_insn (bb);
|
update_bb_for_insn (bb);
|
|
|
return bb;
|
return bb;
|
}
|
}
|
|
|
|
|
/* Create a basic block for initialization code. */
|
/* Create a basic block for initialization code. */
|
|
|
static basic_block
|
static basic_block
|
construct_init_block (void)
|
construct_init_block (void)
|
{
|
{
|
basic_block init_block, first_block;
|
basic_block init_block, first_block;
|
edge e = NULL;
|
edge e = NULL;
|
int flags;
|
int flags;
|
|
|
/* Multiple entry points not supported yet. */
|
/* Multiple entry points not supported yet. */
|
gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR->succs) == 1);
|
gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR->succs) == 1);
|
init_rtl_bb_info (ENTRY_BLOCK_PTR);
|
init_rtl_bb_info (ENTRY_BLOCK_PTR);
|
init_rtl_bb_info (EXIT_BLOCK_PTR);
|
init_rtl_bb_info (EXIT_BLOCK_PTR);
|
ENTRY_BLOCK_PTR->flags |= BB_RTL;
|
ENTRY_BLOCK_PTR->flags |= BB_RTL;
|
EXIT_BLOCK_PTR->flags |= BB_RTL;
|
EXIT_BLOCK_PTR->flags |= BB_RTL;
|
|
|
e = EDGE_SUCC (ENTRY_BLOCK_PTR, 0);
|
e = EDGE_SUCC (ENTRY_BLOCK_PTR, 0);
|
|
|
/* When entry edge points to first basic block, we don't need jump,
|
/* When entry edge points to first basic block, we don't need jump,
|
otherwise we have to jump into proper target. */
|
otherwise we have to jump into proper target. */
|
if (e && e->dest != ENTRY_BLOCK_PTR->next_bb)
|
if (e && e->dest != ENTRY_BLOCK_PTR->next_bb)
|
{
|
{
|
tree label = tree_block_label (e->dest);
|
tree label = tree_block_label (e->dest);
|
|
|
emit_jump (label_rtx (label));
|
emit_jump (label_rtx (label));
|
flags = 0;
|
flags = 0;
|
}
|
}
|
else
|
else
|
flags = EDGE_FALLTHRU;
|
flags = EDGE_FALLTHRU;
|
|
|
init_block = create_basic_block (NEXT_INSN (get_insns ()),
|
init_block = create_basic_block (NEXT_INSN (get_insns ()),
|
get_last_insn (),
|
get_last_insn (),
|
ENTRY_BLOCK_PTR);
|
ENTRY_BLOCK_PTR);
|
init_block->frequency = ENTRY_BLOCK_PTR->frequency;
|
init_block->frequency = ENTRY_BLOCK_PTR->frequency;
|
init_block->count = ENTRY_BLOCK_PTR->count;
|
init_block->count = ENTRY_BLOCK_PTR->count;
|
if (e)
|
if (e)
|
{
|
{
|
first_block = e->dest;
|
first_block = e->dest;
|
redirect_edge_succ (e, init_block);
|
redirect_edge_succ (e, init_block);
|
e = make_edge (init_block, first_block, flags);
|
e = make_edge (init_block, first_block, flags);
|
}
|
}
|
else
|
else
|
e = make_edge (init_block, EXIT_BLOCK_PTR, EDGE_FALLTHRU);
|
e = make_edge (init_block, EXIT_BLOCK_PTR, EDGE_FALLTHRU);
|
e->probability = REG_BR_PROB_BASE;
|
e->probability = REG_BR_PROB_BASE;
|
e->count = ENTRY_BLOCK_PTR->count;
|
e->count = ENTRY_BLOCK_PTR->count;
|
|
|
update_bb_for_insn (init_block);
|
update_bb_for_insn (init_block);
|
return init_block;
|
return init_block;
|
}
|
}
|
|
|
|
|
/* Create a block containing landing pads and similar stuff. */
|
/* Create a block containing landing pads and similar stuff. */
|
|
|
static void
|
static void
|
construct_exit_block (void)
|
construct_exit_block (void)
|
{
|
{
|
rtx head = get_last_insn ();
|
rtx head = get_last_insn ();
|
rtx end;
|
rtx end;
|
basic_block exit_block;
|
basic_block exit_block;
|
edge e, e2;
|
edge e, e2;
|
unsigned ix;
|
unsigned ix;
|
edge_iterator ei;
|
edge_iterator ei;
|
|
|
/* Make sure the locus is set to the end of the function, so that
|
/* Make sure the locus is set to the end of the function, so that
|
epilogue line numbers and warnings are set properly. */
|
epilogue line numbers and warnings are set properly. */
|
#ifdef USE_MAPPED_LOCATION
|
#ifdef USE_MAPPED_LOCATION
|
if (cfun->function_end_locus != UNKNOWN_LOCATION)
|
if (cfun->function_end_locus != UNKNOWN_LOCATION)
|
#else
|
#else
|
if (cfun->function_end_locus.file)
|
if (cfun->function_end_locus.file)
|
#endif
|
#endif
|
input_location = cfun->function_end_locus;
|
input_location = cfun->function_end_locus;
|
|
|
/* The following insns belong to the top scope. */
|
/* The following insns belong to the top scope. */
|
record_block_change (DECL_INITIAL (current_function_decl));
|
record_block_change (DECL_INITIAL (current_function_decl));
|
|
|
/* Generate rtl for function exit. */
|
/* Generate rtl for function exit. */
|
expand_function_end ();
|
expand_function_end ();
|
|
|
end = get_last_insn ();
|
end = get_last_insn ();
|
if (head == end)
|
if (head == end)
|
return;
|
return;
|
while (NEXT_INSN (head) && NOTE_P (NEXT_INSN (head)))
|
while (NEXT_INSN (head) && NOTE_P (NEXT_INSN (head)))
|
head = NEXT_INSN (head);
|
head = NEXT_INSN (head);
|
exit_block = create_basic_block (NEXT_INSN (head), end,
|
exit_block = create_basic_block (NEXT_INSN (head), end,
|
EXIT_BLOCK_PTR->prev_bb);
|
EXIT_BLOCK_PTR->prev_bb);
|
exit_block->frequency = EXIT_BLOCK_PTR->frequency;
|
exit_block->frequency = EXIT_BLOCK_PTR->frequency;
|
exit_block->count = EXIT_BLOCK_PTR->count;
|
exit_block->count = EXIT_BLOCK_PTR->count;
|
|
|
ix = 0;
|
ix = 0;
|
while (ix < EDGE_COUNT (EXIT_BLOCK_PTR->preds))
|
while (ix < EDGE_COUNT (EXIT_BLOCK_PTR->preds))
|
{
|
{
|
e = EDGE_PRED (EXIT_BLOCK_PTR, ix);
|
e = EDGE_PRED (EXIT_BLOCK_PTR, ix);
|
if (!(e->flags & EDGE_ABNORMAL))
|
if (!(e->flags & EDGE_ABNORMAL))
|
redirect_edge_succ (e, exit_block);
|
redirect_edge_succ (e, exit_block);
|
else
|
else
|
ix++;
|
ix++;
|
}
|
}
|
|
|
e = make_edge (exit_block, EXIT_BLOCK_PTR, EDGE_FALLTHRU);
|
e = make_edge (exit_block, EXIT_BLOCK_PTR, EDGE_FALLTHRU);
|
e->probability = REG_BR_PROB_BASE;
|
e->probability = REG_BR_PROB_BASE;
|
e->count = EXIT_BLOCK_PTR->count;
|
e->count = EXIT_BLOCK_PTR->count;
|
FOR_EACH_EDGE (e2, ei, EXIT_BLOCK_PTR->preds)
|
FOR_EACH_EDGE (e2, ei, EXIT_BLOCK_PTR->preds)
|
if (e2 != e)
|
if (e2 != e)
|
{
|
{
|
e->count -= e2->count;
|
e->count -= e2->count;
|
exit_block->count -= e2->count;
|
exit_block->count -= e2->count;
|
exit_block->frequency -= EDGE_FREQUENCY (e2);
|
exit_block->frequency -= EDGE_FREQUENCY (e2);
|
}
|
}
|
if (e->count < 0)
|
if (e->count < 0)
|
e->count = 0;
|
e->count = 0;
|
if (exit_block->count < 0)
|
if (exit_block->count < 0)
|
exit_block->count = 0;
|
exit_block->count = 0;
|
if (exit_block->frequency < 0)
|
if (exit_block->frequency < 0)
|
exit_block->frequency = 0;
|
exit_block->frequency = 0;
|
update_bb_for_insn (exit_block);
|
update_bb_for_insn (exit_block);
|
}
|
}
|
|
|
/* Helper function for discover_nonconstant_array_refs.
|
/* Helper function for discover_nonconstant_array_refs.
|
Look for ARRAY_REF nodes with non-constant indexes and mark them
|
Look for ARRAY_REF nodes with non-constant indexes and mark them
|
addressable. */
|
addressable. */
|
|
|
static tree
|
static tree
|
discover_nonconstant_array_refs_r (tree * tp, int *walk_subtrees,
|
discover_nonconstant_array_refs_r (tree * tp, int *walk_subtrees,
|
void *data ATTRIBUTE_UNUSED)
|
void *data ATTRIBUTE_UNUSED)
|
{
|
{
|
tree t = *tp;
|
tree t = *tp;
|
|
|
if (IS_TYPE_OR_DECL_P (t))
|
if (IS_TYPE_OR_DECL_P (t))
|
*walk_subtrees = 0;
|
*walk_subtrees = 0;
|
else if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
|
else if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
|
{
|
{
|
while (((TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
|
while (((TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
|
&& is_gimple_min_invariant (TREE_OPERAND (t, 1))
|
&& is_gimple_min_invariant (TREE_OPERAND (t, 1))
|
&& (!TREE_OPERAND (t, 2)
|
&& (!TREE_OPERAND (t, 2)
|
|| is_gimple_min_invariant (TREE_OPERAND (t, 2))))
|
|| is_gimple_min_invariant (TREE_OPERAND (t, 2))))
|
|| (TREE_CODE (t) == COMPONENT_REF
|
|| (TREE_CODE (t) == COMPONENT_REF
|
&& (!TREE_OPERAND (t,2)
|
&& (!TREE_OPERAND (t,2)
|
|| is_gimple_min_invariant (TREE_OPERAND (t, 2))))
|
|| is_gimple_min_invariant (TREE_OPERAND (t, 2))))
|
|| TREE_CODE (t) == BIT_FIELD_REF
|
|| TREE_CODE (t) == BIT_FIELD_REF
|
|| TREE_CODE (t) == REALPART_EXPR
|
|| TREE_CODE (t) == REALPART_EXPR
|
|| TREE_CODE (t) == IMAGPART_EXPR
|
|| TREE_CODE (t) == IMAGPART_EXPR
|
|| TREE_CODE (t) == VIEW_CONVERT_EXPR
|
|| TREE_CODE (t) == VIEW_CONVERT_EXPR
|
|| TREE_CODE (t) == NOP_EXPR
|
|| TREE_CODE (t) == NOP_EXPR
|
|| TREE_CODE (t) == CONVERT_EXPR)
|
|| TREE_CODE (t) == CONVERT_EXPR)
|
t = TREE_OPERAND (t, 0);
|
t = TREE_OPERAND (t, 0);
|
|
|
if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
|
if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
|
{
|
{
|
t = get_base_address (t);
|
t = get_base_address (t);
|
if (t && DECL_P (t))
|
if (t && DECL_P (t))
|
TREE_ADDRESSABLE (t) = 1;
|
TREE_ADDRESSABLE (t) = 1;
|
}
|
}
|
|
|
*walk_subtrees = 0;
|
*walk_subtrees = 0;
|
}
|
}
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* RTL expansion is not able to compile array references with variable
|
/* RTL expansion is not able to compile array references with variable
|
offsets for arrays stored in single register. Discover such
|
offsets for arrays stored in single register. Discover such
|
expressions and mark variables as addressable to avoid this
|
expressions and mark variables as addressable to avoid this
|
scenario. */
|
scenario. */
|
|
|
static void
|
static void
|
discover_nonconstant_array_refs (void)
|
discover_nonconstant_array_refs (void)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
block_stmt_iterator bsi;
|
block_stmt_iterator bsi;
|
|
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
|
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
|
walk_tree (bsi_stmt_ptr (bsi), discover_nonconstant_array_refs_r,
|
walk_tree (bsi_stmt_ptr (bsi), discover_nonconstant_array_refs_r,
|
NULL , NULL);
|
NULL , NULL);
|
}
|
}
|
}
|
}
|
|
|
/* Translate the intermediate representation contained in the CFG
|
/* Translate the intermediate representation contained in the CFG
|
from GIMPLE trees to RTL.
|
from GIMPLE trees to RTL.
|
|
|
We do conversion per basic block and preserve/update the tree CFG.
|
We do conversion per basic block and preserve/update the tree CFG.
|
This implies we have to do some magic as the CFG can simultaneously
|
This implies we have to do some magic as the CFG can simultaneously
|
consist of basic blocks containing RTL and GIMPLE trees. This can
|
consist of basic blocks containing RTL and GIMPLE trees. This can
|
confuse the CFG hooks, so be careful to not manipulate CFG during
|
confuse the CFG hooks, so be careful to not manipulate CFG during
|
the expansion. */
|
the expansion. */
|
|
|
static unsigned int
|
static unsigned int
|
tree_expand_cfg (void)
|
tree_expand_cfg (void)
|
{
|
{
|
basic_block bb, init_block;
|
basic_block bb, init_block;
|
sbitmap blocks;
|
sbitmap blocks;
|
edge_iterator ei;
|
edge_iterator ei;
|
edge e;
|
edge e;
|
|
|
/* Some backends want to know that we are expanding to RTL. */
|
/* Some backends want to know that we are expanding to RTL. */
|
currently_expanding_to_rtl = 1;
|
currently_expanding_to_rtl = 1;
|
|
|
/* Prepare the rtl middle end to start recording block changes. */
|
/* Prepare the rtl middle end to start recording block changes. */
|
reset_block_changes ();
|
reset_block_changes ();
|
|
|
/* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
|
/* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
|
discover_nonconstant_array_refs ();
|
discover_nonconstant_array_refs ();
|
|
|
/* Expand the variables recorded during gimple lowering. */
|
/* Expand the variables recorded during gimple lowering. */
|
expand_used_vars ();
|
expand_used_vars ();
|
|
|
/* Honor stack protection warnings. */
|
/* Honor stack protection warnings. */
|
if (warn_stack_protect)
|
if (warn_stack_protect)
|
{
|
{
|
if (current_function_calls_alloca)
|
if (current_function_calls_alloca)
|
warning (0, "not protecting local variables: variable length buffer");
|
warning (0, "not protecting local variables: variable length buffer");
|
if (has_short_buffer && !cfun->stack_protect_guard)
|
if (has_short_buffer && !cfun->stack_protect_guard)
|
warning (0, "not protecting function: no buffer at least %d bytes long",
|
warning (0, "not protecting function: no buffer at least %d bytes long",
|
(int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE));
|
(int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE));
|
}
|
}
|
|
|
/* Set up parameters and prepare for return, for the function. */
|
/* Set up parameters and prepare for return, for the function. */
|
expand_function_start (current_function_decl);
|
expand_function_start (current_function_decl);
|
|
|
/* If this function is `main', emit a call to `__main'
|
/* If this function is `main', emit a call to `__main'
|
to run global initializers, etc. */
|
to run global initializers, etc. */
|
if (DECL_NAME (current_function_decl)
|
if (DECL_NAME (current_function_decl)
|
&& MAIN_NAME_P (DECL_NAME (current_function_decl))
|
&& MAIN_NAME_P (DECL_NAME (current_function_decl))
|
&& DECL_FILE_SCOPE_P (current_function_decl))
|
&& DECL_FILE_SCOPE_P (current_function_decl))
|
expand_main_function ();
|
expand_main_function ();
|
|
|
/* Initialize the stack_protect_guard field. This must happen after the
|
/* Initialize the stack_protect_guard field. This must happen after the
|
call to __main (if any) so that the external decl is initialized. */
|
call to __main (if any) so that the external decl is initialized. */
|
if (cfun->stack_protect_guard)
|
if (cfun->stack_protect_guard)
|
stack_protect_prologue ();
|
stack_protect_prologue ();
|
|
|
/* Register rtl specific functions for cfg. */
|
/* Register rtl specific functions for cfg. */
|
rtl_register_cfg_hooks ();
|
rtl_register_cfg_hooks ();
|
|
|
init_block = construct_init_block ();
|
init_block = construct_init_block ();
|
|
|
/* Clear EDGE_EXECUTABLE on the entry edge(s). It is cleaned from the
|
/* Clear EDGE_EXECUTABLE on the entry edge(s). It is cleaned from the
|
remaining edges in expand_gimple_basic_block. */
|
remaining edges in expand_gimple_basic_block. */
|
FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
|
FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
|
e->flags &= ~EDGE_EXECUTABLE;
|
e->flags &= ~EDGE_EXECUTABLE;
|
|
|
FOR_BB_BETWEEN (bb, init_block->next_bb, EXIT_BLOCK_PTR, next_bb)
|
FOR_BB_BETWEEN (bb, init_block->next_bb, EXIT_BLOCK_PTR, next_bb)
|
bb = expand_gimple_basic_block (bb);
|
bb = expand_gimple_basic_block (bb);
|
|
|
construct_exit_block ();
|
construct_exit_block ();
|
|
|
/* We're done expanding trees to RTL. */
|
/* We're done expanding trees to RTL. */
|
currently_expanding_to_rtl = 0;
|
currently_expanding_to_rtl = 0;
|
|
|
/* Convert tree EH labels to RTL EH labels, and clean out any unreachable
|
/* Convert tree EH labels to RTL EH labels, and clean out any unreachable
|
EH regions. */
|
EH regions. */
|
convert_from_eh_region_ranges ();
|
convert_from_eh_region_ranges ();
|
|
|
rebuild_jump_labels (get_insns ());
|
rebuild_jump_labels (get_insns ());
|
find_exception_handler_labels ();
|
find_exception_handler_labels ();
|
|
|
blocks = sbitmap_alloc (last_basic_block);
|
blocks = sbitmap_alloc (last_basic_block);
|
sbitmap_ones (blocks);
|
sbitmap_ones (blocks);
|
find_many_sub_basic_blocks (blocks);
|
find_many_sub_basic_blocks (blocks);
|
purge_all_dead_edges ();
|
purge_all_dead_edges ();
|
sbitmap_free (blocks);
|
sbitmap_free (blocks);
|
|
|
compact_blocks ();
|
compact_blocks ();
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
verify_flow_info();
|
verify_flow_info();
|
#endif
|
#endif
|
|
|
/* There's no need to defer outputting this function any more; we
|
/* There's no need to defer outputting this function any more; we
|
know we want to output it. */
|
know we want to output it. */
|
DECL_DEFER_OUTPUT (current_function_decl) = 0;
|
DECL_DEFER_OUTPUT (current_function_decl) = 0;
|
|
|
/* Now that we're done expanding trees to RTL, we shouldn't have any
|
/* Now that we're done expanding trees to RTL, we shouldn't have any
|
more CONCATs anywhere. */
|
more CONCATs anywhere. */
|
generating_concat_p = 0;
|
generating_concat_p = 0;
|
|
|
finalize_block_changes ();
|
finalize_block_changes ();
|
|
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
fprintf (dump_file,
|
fprintf (dump_file,
|
"\n\n;;\n;; Full RTL generated for this function:\n;;\n");
|
"\n\n;;\n;; Full RTL generated for this function:\n;;\n");
|
/* And the pass manager will dump RTL for us. */
|
/* And the pass manager will dump RTL for us. */
|
}
|
}
|
|
|
/* If we're emitting a nested function, make sure its parent gets
|
/* If we're emitting a nested function, make sure its parent gets
|
emitted as well. Doing otherwise confuses debug info. */
|
emitted as well. Doing otherwise confuses debug info. */
|
{
|
{
|
tree parent;
|
tree parent;
|
for (parent = DECL_CONTEXT (current_function_decl);
|
for (parent = DECL_CONTEXT (current_function_decl);
|
parent != NULL_TREE;
|
parent != NULL_TREE;
|
parent = get_containing_scope (parent))
|
parent = get_containing_scope (parent))
|
if (TREE_CODE (parent) == FUNCTION_DECL)
|
if (TREE_CODE (parent) == FUNCTION_DECL)
|
TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent)) = 1;
|
TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent)) = 1;
|
}
|
}
|
|
|
/* We are now committed to emitting code for this function. Do any
|
/* We are now committed to emitting code for this function. Do any
|
preparation, such as emitting abstract debug info for the inline
|
preparation, such as emitting abstract debug info for the inline
|
before it gets mangled by optimization. */
|
before it gets mangled by optimization. */
|
if (cgraph_function_possibly_inlined_p (current_function_decl))
|
if (cgraph_function_possibly_inlined_p (current_function_decl))
|
(*debug_hooks->outlining_inline_function) (current_function_decl);
|
(*debug_hooks->outlining_inline_function) (current_function_decl);
|
|
|
TREE_ASM_WRITTEN (current_function_decl) = 1;
|
TREE_ASM_WRITTEN (current_function_decl) = 1;
|
|
|
/* After expanding, the return labels are no longer needed. */
|
/* After expanding, the return labels are no longer needed. */
|
return_label = NULL;
|
return_label = NULL;
|
naked_return_label = NULL;
|
naked_return_label = NULL;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
struct tree_opt_pass pass_expand =
|
struct tree_opt_pass pass_expand =
|
{
|
{
|
"expand", /* name */
|
"expand", /* name */
|
NULL, /* gate */
|
NULL, /* gate */
|
tree_expand_cfg, /* execute */
|
tree_expand_cfg, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
TV_EXPAND, /* tv_id */
|
TV_EXPAND, /* tv_id */
|
/* ??? If TER is enabled, we actually receive GENERIC. */
|
/* ??? If TER is enabled, we actually receive GENERIC. */
|
PROP_gimple_leh | PROP_cfg, /* properties_required */
|
PROP_gimple_leh | PROP_cfg, /* properties_required */
|
PROP_rtl, /* properties_provided */
|
PROP_rtl, /* properties_provided */
|
PROP_trees, /* properties_destroyed */
|
PROP_trees, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
TODO_dump_func, /* todo_flags_finish */
|
TODO_dump_func, /* todo_flags_finish */
|
'r' /* letter */
|
'r' /* letter */
|
};
|
};
|
|
|
