#include "config.h"
#ifdef PFE
#include "system.h"
#include "tree.h"
#include "c-common.h"
#include "rtl.h"
#include "hard-reg-set.h"
#include "basic-block.h"
#include "langhooks.h"
#include "pfe.h"
static int debug_pfe_walk = 0;
static int debug_rtx_walk = 0;
static int tree_nesting_level= -1;
static int rtx_nesting_level = -1;
#if !PFE_NEW_TREE_WALK
static int max_nesting_level = 0;
static tree max_nested_node = NULL;
static int max_stk_size = 0;
#endif
static void freeze_thaw_tree_common PARAMS ((tree));
static void freeze_thaw_tree_decl PARAMS ((tree));
static void freeze_thaw_tree_type PARAMS ((tree));
static void freeze_thaw_tree_block PARAMS ((tree));
static void freeze_thaw_tree_expr PARAMS ((tree));
static void freeze_thaw_tree_special PARAMS ((tree));
static void freeze_thaw_type_variant PARAMS ((tree));
static void freeze_thaw_trace_tree PARAMS ((tree, tree));
static void freeze_thaw_trace_rtx PARAMS ((rtx));
static void freeze_thaw_struct_mem_attrs PARAMS ((mem_attrs **));
static void freeze_thaw_bitmap_element PARAMS ((bitmap_element **));
static void freeze_thaw_bitmap_head_def PARAMS ((struct bitmap_head_def **));
static void freeze_thaw_edge_def PARAMS ((struct edge_def **));
static void freeze_thaw_basic_block_def PARAMS ((struct basic_block_def **));
#define PFE_DEBUG 0
#if PFE_DEBUG
#define HASH_SIZE 37
struct bucket
{
void *node;
struct bucket *next;
};
static struct bucket **table = NULL;
static int pfe_seen_node (tree);
#endif
#if PFE_NEW_TREE_WALK
#define PFE_NEW_TREE_WALK_DISPLAY 1
extern int pfe_display_tree_walk;
#endif
static void freeze_thaw_trace_tree (node, chain_start)
tree node;
tree chain_start;
{
tree type0, tname, dname;
char *s;
if (tree_nesting_level > 0)
fprintf (stderr, "%*c", MIN (tree_nesting_level, 41), ' ');
else
fputc ('\n', stderr);
fprintf (stderr, "%s:", tree_code_name[(int) TREE_CODE (node)]);
fprintf (stderr, HOST_PTR_PRINTF, node);
fprintf (stderr, " (\'%c\') [depth=%d",
TREE_CODE_CLASS (TREE_CODE (node)),
tree_nesting_level);
if (chain_start)
{
fprintf (stderr, ", on ");
fprintf (stderr, HOST_PTR_PRINTF, chain_start);
fprintf (stderr, " chain]");
}
else
fputc (']', stderr);
#if 0
if (PFE_FREEZING)
{
extern int pfe_freeze_ptrs;
fprintf (stderr, "(%d)", pfe_freeze_ptrs);
}
else
{
extern int pfe_thaw_ptrs;
fprintf (stderr, "(%d)", pfe_thaw_ptrs);
}
#endif
if ((type0 = RP (TREE_TYPE (node)))
&& TREE_CODE_CLASS (TREE_CODE (node)) != 't'
&& TREE_CODE_CLASS (TREE_CODE (type0)) == 't')
{
fprintf (stderr, " t=");
fprintf (stderr, HOST_PTR_PRINTF, type0);
if ((tname = RP (TYPE_NAME (type0))))
{
if (TREE_CODE (tname) == IDENTIFIER_NODE)
{
s = RP ((char *)IDENTIFIER_POINTER (tname));
if (s && *s)
fprintf (stderr, " {%s}", s);
}
else if (TREE_CODE (tname) == TYPE_DECL
&& (dname = RP (DECL_NAME (tname)))
&& (s = RP ((char *)IDENTIFIER_POINTER (dname)))
&& *s)
fprintf (stderr, " {%s}", s);
}
else
fprintf (stderr, " {%s}", tree_code_name[(int) TREE_CODE (type0)]);
}
else if (type0)
{
fprintf (stderr, " t=");
fprintf (stderr, HOST_PTR_PRINTF, type0);
}
if (TREE_CODE (node) == IDENTIFIER_NODE
&& (s = RP ((char *)IDENTIFIER_POINTER (node)))
&& *s)
fprintf (stderr, " %s", s);
fputc ('\n', stderr);
}
#if PFE_NEW_TREE_WALK
#define NODE_VISITED(node) !(TREE_LANG_FLAG_7 (node) == !PFE_FREEZING)
typedef tree pfe_tree_stack_entry;
static pfe_tree_stack_entry *pfe_tree_stack = NULL;
static int pfe_tree_stack_size = 0;
static int pfe_tree_stack_last = -1;
static int pfe_tree_stack_total = 0;
static int pfe_tree_stack_max = -1;
#define PFE_INITIAL_TREE_STACK_SIZE (64 * 1024)
#define PFE_INITIAL_TREE_STACK_INCR (16 * 1024)
void
pfe_freeze_thaw_tree_push (nodep)
tree *nodep;
{
tree node;
if (!nodep)
return;
if (PFE_FREEZING)
{
node = *nodep;
if (!node || PFE_IS_FROZEN (node))
return;
pfe_freeze_ptr (nodep);
}
else
{
if (!PFE_IS_FROZEN (*nodep))
return;
node = pfe_thaw_ptr (nodep);
}
if (!node || NODE_VISITED (node))
return;
if (pfe_tree_stack == NULL)
{
pfe_tree_stack_size = PFE_INITIAL_TREE_STACK_SIZE;
pfe_tree_stack = (pfe_tree_stack_entry *)
xmalloc (sizeof (pfe_tree_stack_entry)
* pfe_tree_stack_size);
}
if (++pfe_tree_stack_last >= pfe_tree_stack_size)
{
pfe_tree_stack_size += PFE_INITIAL_TREE_STACK_INCR;
pfe_tree_stack = (pfe_tree_stack_entry *)
xrealloc (pfe_tree_stack,
sizeof (pfe_tree_stack_entry)
* pfe_tree_stack_size);
}
pfe_tree_stack_total++;
if (pfe_tree_stack_last > pfe_tree_stack_max)
pfe_tree_stack_max = pfe_tree_stack_last;
pfe_tree_stack[pfe_tree_stack_last] = node;
TREE_LANG_FLAG_7 (node) = PFE_FREEZING;
}
void
pfe_freeze_thaw_tree_walk (void)
{
tree node;
#if PFE_NEW_TREE_WALK_DISPLAY
if (pfe_display_tree_walk)
printf ("pfe_freeze_thaw_tree_walk (entry): pfe_tree_stack_max = %d\n",
pfe_tree_stack_max);
#endif
while (pfe_tree_stack_last >= 0)
{
node = pfe_tree_stack[pfe_tree_stack_last--];
if (debug_pfe_walk)
freeze_thaw_trace_tree (node, NULL);
if (PFE_THAWING)
freeze_thaw_tree_common (node);
switch (TREE_CODE_CLASS (TREE_CODE (node)))
{
case 'd':
freeze_thaw_tree_decl (node);
pfe_freeze_thaw_tree_push (&TREE_CHAIN (node));
break;
case 't':
freeze_thaw_tree_type (node);
pfe_freeze_thaw_tree_push (&TREE_CHAIN (node));
break;
case 'b':
freeze_thaw_tree_block (node);
pfe_freeze_thaw_tree_push (&TREE_CHAIN (node));
break;
case 'e':
case '<':
case '1':
case '2':
case 'r':
case 's':
freeze_thaw_tree_expr (node);
pfe_freeze_thaw_tree_push (&TREE_CHAIN (node));
break;
case 'c':
freeze_thaw_tree_special (node);
break;
case 'x':
freeze_thaw_tree_special (node);
pfe_freeze_thaw_tree_push (&TREE_CHAIN (node));
break;
default:
break;
}
if (PFE_FREEZING)
freeze_thaw_tree_common (node);
}
free (pfe_tree_stack);
#if PFE_NEW_TREE_WALK_DISPLAY
if (pfe_display_tree_walk)
printf ("pfe_freeze_thaw_tree_walk (exit): "
"pfe_tree_stack_max = %d; pfe_tree_stack_total = %d\n",
pfe_tree_stack_max, pfe_tree_stack_total);
#endif
}
#else
void
pfe_freeze_thaw_tree_walk (nodep)
tree *nodep;
{
tree node, chain_start;
static int follow_chain;
static void *start_stk_addr;
#define NODE_VISITED(node) !(TREE_LANG_FLAG_7 (node) == !PFE_FREEZING)
if (!nodep)
return;
if (PFE_FREEZING)
{
node = *nodep;
if (!node || PFE_IS_FROZEN (node))
return;
pfe_freeze_ptr (nodep);
}
else
{
if (!PFE_IS_FROZEN (*nodep))
return;
node = pfe_thaw_ptr (nodep);
}
if (!node || NODE_VISITED (node))
return;
#if PFE_DEBUG
if (pfe_seen_node (node))
{
int stop_here;
fprintf (stderr, "trying to freeze node %x more than once!\n", (unsigned)node);
stop_here = 1;
}
#endif
if (++tree_nesting_level > max_nesting_level)
{
int stk_size = (int)start_stk_addr - (int)&node;
if (stk_size < 0) stk_size = -stk_size;
if (stk_size > max_stk_size)
max_stk_size = stk_size;
max_nesting_level = tree_nesting_level;
max_nested_node = node;
}
else if (tree_nesting_level == 0)
start_stk_addr = &node;
chain_start = node;
if (debug_pfe_walk)
freeze_thaw_trace_tree (node, NULL);
do {
TREE_LANG_FLAG_7 (node) = PFE_FREEZING;
if (PFE_THAWING)
freeze_thaw_tree_common (node);
switch (TREE_CODE_CLASS (TREE_CODE (node)))
{
case 'd':
freeze_thaw_tree_decl (node);
follow_chain = 1;
break;
case 't':
freeze_thaw_tree_type (node);
follow_chain = 1;
break;
case 'b':
freeze_thaw_tree_block (node);
follow_chain = 1;
break;
case 'e':
case '<':
case '1':
case '2':
case 'r':
case 's':
freeze_thaw_tree_expr (node);
follow_chain = 1;
break;
case 'c':
freeze_thaw_tree_special (node);
follow_chain = 0;
break;
case 'x':
freeze_thaw_tree_special (node);
follow_chain = 1;
break;
default:
follow_chain = 0;
}
if (PFE_FREEZING)
freeze_thaw_tree_common (node);
if (follow_chain)
{
node = PFE_FREEZE_THAW_PTR (&TREE_CHAIN (node));
follow_chain = node && !NODE_VISITED (node);
if (debug_pfe_walk && follow_chain)
freeze_thaw_trace_tree (node, chain_start);
}
}
while (follow_chain);
--tree_nesting_level;
}
#endif
static void
freeze_thaw_tree_common (node)
tree node;
{
TREE_ASM_WRITTEN (node) = 0;
PFE_FREEZE_THAW_WALK (TREE_TYPE (node));
}
static void
freeze_thaw_tree_decl (node)
tree node;
{
pfe_freeze_thaw_ptr_fp (&DECL_SOURCE_FILE (node));
PFE_FREEZE_THAW_WALK (DECL_SIZE (node));
PFE_FREEZE_THAW_WALK (DECL_SIZE_UNIT (node));
PFE_FREEZE_THAW_WALK (DECL_NAME (node));
PFE_FREEZE_THAW_WALK (DECL_ARGUMENTS (node));
PFE_FREEZE_THAW_WALK (DECL_INITIAL (node));
PFE_FREEZE_THAW_WALK (DECL_ABSTRACT_ORIGIN (node));
if (node->decl.assembler_name)
PFE_FREEZE_THAW_WALK ((node->decl.assembler_name));
PFE_FREEZE_THAW_WALK (DECL_SECTION_NAME (node));
PFE_FREEZE_THAW_WALK (DECL_ATTRIBUTES (node));
PFE_FREEZE_THAW_RTX (node->decl.rtl);
PFE_FREEZE_THAW_RTX (DECL_LIVE_RANGE_RTL (node));
if (PFE_THAWING)
{
pfe_thaw_ptr (&DECL_LANG_SPECIFIC (node));
PFE_FREEZE_THAW_WALK (DECL_CONTEXT (node));
}
if (!(*lang_hooks.pfe_freeze_thaw_decl) (node))
{
switch (TREE_CODE (node))
{
case FUNCTION_DECL:
pfe_freeze_thaw_function (&DECL_SAVED_INSNS (node));
PFE_FREEZE_THAW_WALK (DECL_SAVED_TREE (node));
PFE_FREEZE_THAW_WALK (DECL_INLINED_FNS (node));
PFE_FREEZE_THAW_WALK (DECL_VINDEX (node));
PFE_FREEZE_THAW_WALK (DECL_RESULT (node));
break;
case PARM_DECL:
PFE_FREEZE_THAW_RTX (DECL_INCOMING_RTL (node));
PFE_FREEZE_THAW_WALK (DECL_ARG_TYPE_AS_WRITTEN (node));
break;
case FIELD_DECL:
PFE_FREEZE_THAW_WALK (DECL_FIELD_BIT_OFFSET (node));
PFE_FREEZE_THAW_WALK (DECL_BIT_FIELD_TYPE (node));
PFE_FREEZE_THAW_WALK (DECL_FCONTEXT (node));
break;
case TYPE_DECL:
PFE_FREEZE_THAW_WALK (DECL_ORIGINAL_TYPE (node));
break;
default: ;
break;
}
}
if (PFE_FREEZING)
{
PFE_FREEZE_THAW_WALK (DECL_CONTEXT (node));
pfe_freeze_ptr (&DECL_LANG_SPECIFIC (node));
}
}
static void freeze_thaw_type_variant (node)
tree node;
{
if (PFE_FREEZING)
{
tree *nodep = &TYPE_MAIN_VARIANT (node);
while (*nodep && !PFE_IS_FROZEN (*nodep))
{
node = *nodep;
#if PFE_NEW_TREE_WALK
pfe_freeze_thaw_tree_push (nodep);
#else
pfe_freeze_thaw_tree_walk (nodep);
#endif
PFE_FREEZE_THAW_PTR (&TYPE_MAIN_VARIANT (node));
nodep = &TYPE_NEXT_VARIANT (node);
}
}
else
{
tree *nodep = &TYPE_MAIN_VARIANT (node);
while (*nodep && PFE_IS_FROZEN (*nodep))
{
#if PFE_NEW_TREE_WALK
pfe_freeze_thaw_tree_push (nodep);
#else
pfe_freeze_thaw_tree_walk (nodep);
#endif
PFE_FREEZE_THAW_PTR (&TYPE_MAIN_VARIANT (*nodep));
nodep = &TYPE_NEXT_VARIANT (*nodep);
}
}
}
static void
freeze_thaw_tree_type (node)
tree node;
{
PFE_FREEZE_THAW_WALK (TYPE_VALUES (node));
PFE_FREEZE_THAW_WALK (TYPE_SIZE (node));
PFE_FREEZE_THAW_WALK (TYPE_SIZE_UNIT (node));
PFE_FREEZE_THAW_WALK (TYPE_ATTRIBUTES (node));
PFE_FREEZE_THAW_WALK (TYPE_POINTER_TO (node));
PFE_FREEZE_THAW_WALK (TYPE_REFERENCE_TO (node));
#if defined(DBX_DEBUGGING_INFO)
TYPE_SYMTAB_ADDRESS (node) = 0;
#elif defined(XCOFF_DEBUGGING_INFO)
TYPE_SYMTAB_ADDRESS (node) = 0;
#elif defined(SDB_DEBUGGING_INFO)
pfe_freeze_thaw_ptr_fp (&TYPE_SYMTAB_POINTER (node));
#elif defined(DWARF_DEBUGGING_INFO)
pfe_freeze_thaw_ptr_fp (&TYPE_SYMTAB_POINTER (node));
#elif defined(DWARF2_DEBUGGING_INFO)
pfe_freeze_thaw_ptr_fp (&TYPE_SYMTAB_POINTER (node));
#endif
PFE_FREEZE_THAW_WALK (TYPE_NAME (node));
PFE_FREEZE_THAW_WALK (TYPE_MIN_VALUE (node));
PFE_FREEZE_THAW_WALK (TYPE_MAX_VALUE (node));
freeze_thaw_type_variant (node);
PFE_FREEZE_THAW_WALK (TYPE_CONTEXT (node));
if (PFE_THAWING)
pfe_thaw_ptr (&TYPE_LANG_SPECIFIC (node));
if (!(*lang_hooks.pfe_freeze_thaw_type) (node))
{
switch (TREE_CODE (node))
{
case RECORD_TYPE:
case UNION_TYPE:
case QUAL_UNION_TYPE:
PFE_FREEZE_THAW_WALK (TYPE_METHODS (node));
PFE_FREEZE_THAW_WALK (TYPE_BINFO (node));
break;
case FUNCTION_TYPE:
case METHOD_TYPE:
PFE_FREEZE_THAW_WALK (TYPE_METHOD_BASETYPE (node));
break;
case OFFSET_TYPE:
PFE_FREEZE_THAW_WALK (TYPE_OFFSET_BASETYPE (node));
break;
default: ;
break;
}
}
if (PFE_FREEZING)
pfe_freeze_ptr (&TYPE_LANG_SPECIFIC (node));
}
static void
freeze_thaw_tree_block (node)
tree node;
{
PFE_FREEZE_THAW_WALK (BLOCK_VARS (node));
PFE_FREEZE_THAW_WALK (BLOCK_SUBBLOCKS (node));
PFE_FREEZE_THAW_WALK (BLOCK_SUPERCONTEXT (node));
PFE_FREEZE_THAW_WALK (BLOCK_ABSTRACT_ORIGIN (node));
PFE_FREEZE_THAW_WALK (BLOCK_FRAGMENT_ORIGIN (node));
PFE_FREEZE_THAW_WALK (BLOCK_FRAGMENT_CHAIN (node));
}
static void
freeze_thaw_tree_expr (node)
tree node;
{
int i, len, first_rtl;
len = TREE_CODE_LENGTH (TREE_CODE (node));
first_rtl = first_rtl_op (TREE_CODE (node));
for (i = 0; i < len; ++i)
{
if (i >= first_rtl)
{
rtx *rtxp = (struct rtx_def **)&TREE_OPERAND (node, i);
pfe_freeze_thaw_rtx (rtxp);
}
else
PFE_FREEZE_THAW_WALK (TREE_OPERAND (node, i));
}
}
static void
freeze_thaw_tree_special (node)
tree node;
{
int i, len;
if (!(*lang_hooks.pfe_freeze_thaw_special) (node))
{
switch (TREE_CODE (node))
{
case INTEGER_CST:
PFE_FREEZE_THAW_RTX (TREE_CST_RTL(node));
break;
case REAL_CST:
PFE_FREEZE_THAW_RTX (TREE_CST_RTL(node));
break;
case COMPLEX_CST:
PFE_FREEZE_THAW_RTX (TREE_CST_RTL(node));
PFE_FREEZE_THAW_WALK (TREE_REALPART (node));
PFE_FREEZE_THAW_WALK (TREE_IMAGPART (node));
break;
#if 0
case VECTOR_CST:
PFE_FREEZE_THAW_RTX (TREE_CST_RTL(node));
PFE_FREEZE_THAW_WALK (TREE_VECTOR_CST_0 (node));
PFE_FREEZE_THAW_WALK (TREE_VECTOR_CST_1 (node));
PFE_FREEZE_THAW_WALK (TREE_VECTOR_CST_2 (node));
PFE_FREEZE_THAW_WALK (TREE_VECTOR_CST_3 (node));
break;
#endif
case STRING_CST:
PFE_FREEZE_THAW_RTX (TREE_CST_RTL(node));
pfe_freeze_thaw_ptr_fp (&TREE_STRING_POINTER (node));
PFE_FREEZE_THAW_WALK (TREE_CHAIN (node));
break;
case TREE_LIST:
PFE_FREEZE_THAW_WALK (TREE_PURPOSE (node));
PFE_FREEZE_THAW_WALK (TREE_VALUE (node));
break;
case TREE_VEC:
len = TREE_VEC_LENGTH (node);
for (i = 0; i < len; i++)
PFE_FREEZE_THAW_WALK (TREE_VEC_ELT (node, i));
break;
case IDENTIFIER_NODE:
break;
default: ;
break;
}
}
}
static void freeze_thaw_trace_rtx (x)
rtx x;
{
if (rtx_nesting_level > 0)
fprintf (stderr, "%*c", MIN (tree_nesting_level + rtx_nesting_level, 60), ' ');
fprintf (stderr, "%s:", GET_RTX_NAME (GET_CODE (x)));
fprintf (stderr, HOST_PTR_PRINTF, x);
fprintf (stderr, " [depth=%d] codes=\"%s\"",
rtx_nesting_level,
(char *)GET_RTX_FORMAT (GET_CODE (x)));
#if 0
if (PFE_FREEZING)
{
extern int pfe_freeze_ptrs;
fprintf (stderr, "(%d)", pfe_freeze_ptrs);
}
else
{
extern int pfe_thaw_ptrs;
fprintf (stderr, "(%d)", pfe_thaw_ptrs);
}
#endif
fputc ('\n', stderr);
}
void
pfe_freeze_thaw_rtx (xp)
rtx *xp;
{
rtx x;
int i;
char *format_ptr;
if (PFE_FREEZING)
{
x = *xp;
if (!x || PFE_IS_FROZEN (x))
return;
pfe_freeze_ptr (xp);
}
else
{
if (!PFE_IS_FROZEN (*xp))
return;
x = pfe_thaw_ptr (xp);
}
if (x == NULL_RTX)
return;
++rtx_nesting_level;
if (debug_rtx_walk)
freeze_thaw_trace_rtx (x);
format_ptr = (char *)GET_RTX_FORMAT (GET_CODE (x));
for (i = 0; i < GET_RTX_LENGTH (GET_CODE (x)); i++)
switch (*format_ptr++)
{
case 'T':
pfe_freeze_thaw_ptr_fp (&XTMPL (x, i));
break;
case 'S':
case 's':
pfe_freeze_thaw_ptr_fp (&XSTR (x, i));
break;
case '0':
if (i == 3 && GET_CODE (x) == NOTE)
{
switch (NOTE_LINE_NUMBER (x))
{
case NOTE_INSN_EH_REGION_BEG:
case NOTE_INSN_EH_REGION_END:
break;
case NOTE_INSN_BLOCK_BEG:
case NOTE_INSN_BLOCK_END:
PFE_FREEZE_THAW_WALK (NOTE_BLOCK (x));
break;
case NOTE_INSN_RANGE_BEG:
case NOTE_INSN_RANGE_END:
case NOTE_INSN_LIVE:
PFE_FREEZE_THAW_RTX (NOTE_RANGE_INFO (x));
break;
case NOTE_INSN_BASIC_BLOCK:
freeze_thaw_basic_block_def (&NOTE_BASIC_BLOCK (x));
break;
case NOTE_INSN_EXPECTED_VALUE:
PFE_FREEZE_THAW_RTX (NOTE_EXPECTED_VALUE (x));
break;
case NOTE_INSN_DELETED_LABEL:
pfe_freeze_thaw_ptr_fp (&NOTE_SOURCE_FILE (x));
break;
default:
if (NOTE_LINE_NUMBER (x) >= 0)
pfe_freeze_thaw_ptr_fp (&X0STR (x, i));
break;
}
}
else if (GET_CODE (x) == MEM && MEM_ATTRS (x))
freeze_thaw_struct_mem_attrs (&MEM_ATTRS (x));
break;
case 'e':
case 'u':
PFE_FREEZE_THAW_RTX (XEXP (x, i));
break;
case 'E':
case 'V':
pfe_freeze_thaw_rtvec (&XVEC (x, i));
break;
case 'b':
freeze_thaw_bitmap_head_def (&XBITMAP (x, i));
break;
case 't':
PFE_FREEZE_THAW_WALK (XTREE (x, i));
break;
case 'w':
case 'i':
case 'n':
case '*':
break;
default:
fprintf (stderr,
"switch format wrong in pfe_freeze_thaw_rtx(); format was: %c.\n",
format_ptr[-1]);
abort ();
}
--rtx_nesting_level;
}
void
pfe_freeze_thaw_rtvec (rtvecp)
struct rtvec_def **rtvecp;
{
struct rtvec_def *v = PFE_FREEZE_THAW_PTR (rtvecp);
int i;
if (!v)
return;
for (i = 0; i < GET_NUM_ELEM (v); ++i)
{
if (debug_rtx_walk)
{
++rtx_nesting_level;
fprintf (stderr, "%*c[%d]\n",
MIN (tree_nesting_level + rtx_nesting_level, 61), ' ', i);
}
PFE_FREEZE_THAW_RTX (RTVEC_ELT (v, i));
if (debug_rtx_walk)
--rtx_nesting_level;
}
}
static void
freeze_thaw_struct_mem_attrs (mpp)
mem_attrs **mpp;
{
mem_attrs *mp = (mem_attrs *)PFE_FREEZE_THAW_PTR (mpp);
if (!mp)
return;
PFE_FREEZE_THAW_WALK (mp->expr);
PFE_FREEZE_THAW_RTX (mp->offset);
PFE_FREEZE_THAW_RTX (mp->size);
}
static void
freeze_thaw_bitmap_element (bep)
bitmap_element **bep;
{
bitmap_element *be, *next, *prev;
be = (bitmap_element *)PFE_FREEZE_THAW_PTR (bep);
if (!be)
return;
next = (bitmap_element *)PFE_FREEZE_THAW_PTR (&be->next);
prev = (bitmap_element *)PFE_FREEZE_THAW_PTR (&be->prev);
be = next;
while (be)
{
PFE_FREEZE_THAW_PTR (&be->prev);
be = (bitmap_element *)PFE_FREEZE_THAW_PTR (&be->next);
}
be = prev;
while (be)
{
PFE_FREEZE_THAW_PTR (&be->next);
be = (bitmap_element *)PFE_FREEZE_THAW_PTR (&be->prev);
}
}
static void
freeze_thaw_bitmap_head_def (bhp)
struct bitmap_head_def **bhp;
{
bitmap_head *bh = (bitmap_head *)PFE_FREEZE_THAW_PTR (bhp);
if (!bh)
return;
PFE_FREEZE_THAW_PTR (&bh->current);
freeze_thaw_bitmap_element (&bh->first);
}
static void
freeze_thaw_edge_def (edgep)
struct edge_def **edgep;
{
edge e, succ_next, pred_next;
e = (edge)PFE_FREEZE_THAW_PTR (edgep);
if (!e)
return;
freeze_thaw_basic_block_def (&e->src);
freeze_thaw_basic_block_def (&e->dest);
PFE_FREEZE_THAW_RTX (e->insns);
succ_next = (edge)PFE_FREEZE_THAW_PTR (&e->succ_next);
pred_next = (edge)PFE_FREEZE_THAW_PTR (&e->pred_next);
e = succ_next;
while (e)
{
freeze_thaw_basic_block_def (&e->src);
freeze_thaw_basic_block_def (&e->dest);
PFE_FREEZE_THAW_RTX (e->insns);
PFE_FREEZE_THAW_PTR (&e->pred_next);
e = (edge)PFE_FREEZE_THAW_PTR (&e->succ_next);
}
e = pred_next;
while (e)
{
freeze_thaw_basic_block_def (&e->src);
freeze_thaw_basic_block_def (&e->dest);
PFE_FREEZE_THAW_RTX (e->insns);
PFE_FREEZE_THAW_PTR (&e->succ_next);
e = (edge)PFE_FREEZE_THAW_PTR (&e->pred_next);
}
}
static void
freeze_thaw_basic_block_def (bbp)
struct basic_block_def **bbp;
{
struct basic_block_def *bb = (struct basic_block_def *)PFE_FREEZE_THAW_PTR (bbp);
if (!bb)
return;
PFE_FREEZE_THAW_RTX (bb->head);
PFE_FREEZE_THAW_RTX (bb->end);
PFE_FREEZE_THAW_WALK (bb->head_tree);
PFE_FREEZE_THAW_WALK (bb->end_tree);
freeze_thaw_edge_def (&bb->pred);
freeze_thaw_edge_def (&bb->succ);
freeze_thaw_bitmap_head_def (&bb->local_set);
freeze_thaw_bitmap_head_def (&bb->cond_local_set);
freeze_thaw_bitmap_head_def (&bb->global_live_at_start);
freeze_thaw_bitmap_head_def (&bb->global_live_at_end);
}
void pfe_print_TREE_CHAIN (tree);
void
pfe_print_TREE_CHAIN (node)
tree node;
{
tree node1;
char *name;
for (node1 = node, node = RP(node); node; node1 = TREE_CHAIN (node), node = RP(TREE_CHAIN (node)))
{
name = (char *)"?";
if (TREE_CODE_CLASS (TREE_CODE (node)) != 't'
&& TREE_TYPE (node)
&& TREE_CODE_CLASS (TREE_CODE (TREE_TYPE (node))) == 't')
{
tree type = TREE_TYPE (node);
if (TYPE_NAME (type))
{
if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
{
if (IDENTIFIER_POINTER (TYPE_NAME (type))
&& *IDENTIFIER_POINTER (TYPE_NAME (type)))
name = (char *)IDENTIFIER_POINTER (TYPE_NAME (type));
}
else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
&& DECL_NAME (TYPE_NAME (type))
&& IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)))
&& *IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))))
name = (char *)IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
}
else
name = (char *)tree_code_name[(int) TREE_CODE (type)];
}
if (PFE_FREEZING)
{
if (!PFE_IS_FROZEN (node1))
{
fprintf (stderr, "0x%x (%s) is not frozen", (unsigned)node, name);
if (TREE_LANG_FLAG_7 (node) != 1)
fprintf (stderr, " and doesn't have TREE_LANG_FLAG_7 set to 1");
fprintf (stderr, "\n");
}
else if (TREE_LANG_FLAG_7 (node) != 1)
fprintf (stderr, "0x%x (%s) doesn't have TREE_LANG_FLAG_7 set to 1\n", (unsigned)node, name);
}
else
{
if (PFE_IS_FROZEN (node1))
{
fprintf (stderr, "0x%x (%s) is frozen", (unsigned)node, name);
if (TREE_LANG_FLAG_7 (node) != 0)
fprintf (stderr, " and doesn't have TREE_LANG_FLAG_7 set to 0");
fprintf (stderr, "\n");
}
else if (TREE_LANG_FLAG_7 (node) != 0)
fprintf (stderr, "0x%x (%s) doesn't have TREE_LANG_FLAG_7 set to 0\n", (unsigned)node, name);
}
}
}
#if PFE_DEBUG
static int
pfe_seen_node (node)
tree node;
{
int hash;
struct bucket *b;
if (!table)
{
table = (struct bucket **) xmalloc (HASH_SIZE * sizeof (struct bucket *));
memset ((char *) table, 0, HASH_SIZE * sizeof (struct bucket *));
}
hash = ((unsigned long) node >> 4) % HASH_SIZE;
for (b = table[hash]; b; b = b->next)
if (b->node == node)
return 1;
if (tree_nesting_level >= 0)
{
b = (struct bucket *) xmalloc (sizeof (struct bucket));
b->node = node;
b->next = table[hash];
table[hash] = b;
}
return 0;
}
static void analyze_hash()
{
int i, n, t;
struct bucket *b;
for (i = t = 0; i < HASH_SIZE; ++ i)
{
for (n = 0, b = table[i]; b; b = b->next, ++n) ;
fprintf (stderr, "%4d: %6d\n", i, n);
t += n;
}
fprintf (stderr, "total number of hash entries = %d\n", t);
}
#endif
#endif
#if 0
cd $gcc3/gcc/pfe; \
cc -no-cpp-precomp -c -DIN_GCC -g \
-W -Wall -Wwrite-strings -Wstrict-prototypes -Wmissing-prototypes -Wtraditional -pedantic -Wno-long-long \
-DHAVE_CONFIG_H \
-I$gcc3obj \
-I. \
-I.. \
-I../config \
-I../../include \
freeze-thaw.c -o ~/tmp.o -w
#endif