the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
-
/* This file contains the low level primitives for operating on tree nodes,
including allocation, list operations, interning of identifiers,
construction of data type nodes and statement nodes,
#define obstack_chunk_alloc xmalloc
#define obstack_chunk_free free
-/* obstack.[ch] explicitly declined to prototype this. */
+/* obstack.[ch] explicitly declined to prototype this. */
extern int _obstack_allocated_p PARAMS ((struct obstack *h, PTR obj));
static void unsave_expr_now_r PARAMS ((tree));
int all_types_permanent;
/* Stack of places to restore the momentary obstack back to. */
-
+
struct momentary_level
{
/* Pointer back to previous such level. */
all_kinds
} tree_node_kind;
-int tree_node_counts[(int)all_kinds];
-int tree_node_sizes[(int)all_kinds];
+int tree_node_counts[(int) all_kinds];
+int tree_node_sizes[(int) all_kinds];
int id_string_size = 0;
static const char * const tree_node_kind_names[] = {
tree type;
};
-/* Initial size of the hash table (rounded to next prime). */
+/* Initial size of the hash table (rounded to next prime). */
#define TYPE_HASH_INITIAL_SIZE 1000
/* Now here is the hash table. When recording a type, it is added to
ggc_add_tree_root (hash_table, sizeof hash_table / sizeof (tree));
/* Initialize the hash table of types. */
- type_hash_table = htab_create (TYPE_HASH_INITIAL_SIZE, type_hash_hash,
+ type_hash_table = htab_create (TYPE_HASH_INITIAL_SIZE, type_hash_hash,
type_hash_eq, 0);
ggc_add_root (&type_hash_table, 1, sizeof type_hash_table, mark_type_hash);
ggc_add_tree_root (global_trees, TI_MAX);
push_obstacks_nochange ()
{
struct obstack_stack *p;
-
+
p = (struct obstack_stack *) obstack_alloc (&obstack_stack_obstack,
(sizeof (struct obstack_stack)));
PARM_DECLs of top-level functions do not have this problem. However,
we allocate them where we put the FUNCTION_DECL for languages such as
Ada that need to consult some flags in the PARM_DECLs of the function
- when calling it.
+ when calling it.
See comment in restore_tree_status for why we can't put this
in function_obstack. */
memset ((PTR) t, 0, length);
#ifdef GATHER_STATISTICS
- tree_node_counts[(int)kind]++;
- tree_node_sizes[(int)kind] += length;
+ tree_node_counts[(int) kind]++;
+ tree_node_sizes[(int) kind] += length;
#endif
TREE_SET_CODE (t, code);
DECL_USER_ALIGN (t) = 0;
DECL_IN_SYSTEM_HEADER (t) = in_system_header;
DECL_SOURCE_LINE (t) = lineno;
- DECL_SOURCE_FILE (t) =
+ DECL_SOURCE_FILE (t) =
(input_filename) ? input_filename : built_in_filename;
DECL_UID (t) = next_decl_uid++;
/* Note that we have not yet computed the alias set for this
operands are. */
TREE_SIDE_EFFECTS (t) = 1;
break;
-
+
default:
break;
}
/* Return a new type (with the indicated CODE), doing whatever
language-specific processing is required. */
-tree
+tree
make_lang_type (code)
enum tree_code code;
{
hi &= (1 << HASHBITS) - 1;
hi %= MAX_HASH_TABLE;
-
- /* Search table for identifier */
+
+ /* Search table for identifier. */
for (idp = hash_table[hi]; idp; idp = TREE_CHAIN (idp))
if (IDENTIFIER_LENGTH (idp) == len
&& IDENTIFIER_POINTER (idp)[0] == text[0]
&& !bcmp (IDENTIFIER_POINTER (idp), text, len))
- return idp; /* <-- return if found */
+ /* Return if found. */
+ return idp;
- /* Not found; optionally warn about a similar identifier */
+ /* Not found; optionally warn about a similar identifier. */
if (warn_id_clash && do_identifier_warnings && len >= id_clash_len)
for (idp = hash_table[hi]; idp; idp = TREE_CHAIN (idp))
if (!strncmp (IDENTIFIER_POINTER (idp), text, id_clash_len))
hi &= (1 << HASHBITS) - 1;
hi %= MAX_HASH_TABLE;
-
- /* Search table for identifier */
+
+ /* Search table for identifier. */
for (idp = hash_table[hi]; idp; idp = TREE_CHAIN (idp))
if (IDENTIFIER_LENGTH (idp) == len
&& IDENTIFIER_POINTER (idp)[0] == text[0]
\f
/* Return a newly constructed INTEGER_CST node whose constant value
is specified by the two ints LOW and HI.
- The TREE_TYPE is set to `int'.
+ The TREE_TYPE is set to `int'.
This function should be used via the `build_int_2' macro. */
{
REAL_VALUE_TYPE e;
- d = (double) (~ TREE_INT_CST_HIGH (i));
+ d = (double) (~TREE_INT_CST_HIGH (i));
e = ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
* (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
d *= e;
- e = (double) (~ TREE_INT_CST_LOW (i));
+ e = (double) (~TREE_INT_CST_LOW (i));
d += e;
d = (- d - 1.0);
}
d = (double) (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (i);
e = ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
- * (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
+ * (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
d *= e;
e = (double) TREE_INT_CST_LOW (i);
d += e;
struct brfic_args
{
- tree type; /* Input: type to conver to. */
- tree i; /* Input: operand to convert */
- REAL_VALUE_TYPE d; /* Output: floating point value. */
+ tree type; /* Input: type to conver to. */
+ tree i; /* Input: operand to convert. */
+ REAL_VALUE_TYPE d; /* Output: floating point value. */
};
/* Convert an integer to a floating point value while protected by a floating
static void
build_real_from_int_cst_1 (data)
- PTR data;
+ PTR data;
{
struct brfic_args *args = (struct brfic_args *) data;
-
+
#ifdef REAL_ARITHMETIC
args->d = real_value_from_int_cst (args->type, args->i);
#else
d = dconst0;
overflow = 1;
}
-
+
/* Check for valid float value for this type on this target machine. */
#ifdef CHECK_FLOAT_VALUE
uns = TREE_UNSIGNED (TREE_TYPE (expr));
if (!uns)
- return (TREE_INT_CST_LOW (expr) == ~ (unsigned HOST_WIDE_INT) 0
+ return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
&& TREE_INT_CST_HIGH (expr) == -1);
/* Note that using TYPE_PRECISION here is wrong. We care about the
else
high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1;
- return (TREE_INT_CST_LOW (expr) == ~ (unsigned HOST_WIDE_INT) 0
+ return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
&& TREE_INT_CST_HIGH (expr) == high_value);
}
else
}
return (high != 0 ? HOST_BITS_PER_WIDE_INT + exact_log2 (high)
- : exact_log2 (low));
+ : exact_log2 (low));
}
/* Similar, but return the largest integer Y such that 2 ** Y is less
}
/* Nonzero if EXP is a constant or a cast of a constant. */
-
+
int
really_constant_p (exp)
tree exp;
#endif
return op1;
}
- else return op2;
+ else
+ return op2;
}
/* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
/* If the tree evaluates to a constant, then we don't want to hide that
fact (i.e. this allows further folding, and direct checks for constants).
However, a read-only object that has side effects cannot be bypassed.
- Since it is no problem to reevaluate literals, we just return the
+ Since it is no problem to reevaluate literals, we just return the
literal node. */
if (TREE_CONSTANT (t) || (TREE_READONLY (t) && ! TREE_SIDE_EFFECTS (t))
TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3);
TREE_OPERAND (expr, 3) = NULL_TREE;
break;
-
+
case RTL_EXPR:
/* I don't yet know how to emit a sequence multiple times. */
if (RTL_EXPR_SEQUENCE (expr) != 0)
case '1': /* a unary arithmetic expression */
{
int i;
-
+
for (i = first_rtl_op (code) - 1; i >= 0; i--)
unsave_expr_now_r (TREE_OPERAND (expr, i));
}
/* Return 0 if it is safe to evaluate EXPR multiple times,
return 1 if it is safe if EXPR is unsaved afterward, or
- return 2 if it is completely unsafe.
+ return 2 if it is completely unsafe.
This assumes that CALL_EXPRs and TARGET_EXPRs are never replicated in
an expression tree, so that it safe to unsave them and the surrounding
safe to unsave a SAVE_EXPR if you know that all occurrences appear
below the UNSAVE_EXPR.
- RTL_EXPRs consume their rtl during evaluation. It is therefore
+ RTL_EXPRs consume their rtl during evaluation. It is therefore
never possible to unsave them. */
int
|| (TREE_CHAIN (exp) != 0
&& contains_placeholder_p (TREE_CHAIN (exp))));
break;
-
+
case '1':
case '2': case '<':
case 'e':
switch (code)
{
case COMPOUND_EXPR:
- /* Ignoring the first operand isn't quite right, but works best. */
+ /* Ignoring the first operand isn't quite right, but works best. */
return contains_placeholder_p (TREE_OPERAND (exp, 1));
case RTL_EXPR:
op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
if (op0 == TREE_OPERAND (exp, 0))
return exp;
-
+
new = fold (build1 (code, TREE_TYPE (exp), op0));
break;
&& TREE_OPERAND (exp, 1) == f)
return r;
- /* If this expression hasn't been completed let, leave it
+ /* If this expression hasn't been completed let, leave it
alone. */
if (TREE_CODE (inner) == PLACEHOLDER_EXPR
&& TREE_TYPE (inner) == 0)
abort ();
}
break;
-
+
default:
abort ();
}
ref)));
break;
-
/* If arg isn't a kind of lvalue we recognize, make no change.
Caller should recognize the error for an invalid lvalue. */
default:
/* Constants need no processing. In fact, we should never reach
here. */
return e;
-
+
case '2':
/* Division is slow and tends to be compiled with jumps,
especially the division by powers of 2 that is often
default:
abort ();
}
-
+
TREE_TYPE (result) = TREE_TYPE (e);
TREE_READONLY (result) = TREE_READONLY (e);
TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
memset ((PTR) t, 0, sizeof (struct tree_common));
#ifdef GATHER_STATISTICS
- tree_node_counts[(int)kind]++;
- tree_node_sizes[(int)kind] += length;
+ tree_node_counts[(int) kind]++;
+ tree_node_sizes[(int) kind] += length;
#endif
TREE_SET_CODE (t, code);
operands are. */
TREE_SIDE_EFFECTS (t) = 1;
break;
-
+
default:
break;
}
+ attribute_hash_list (attribute));
switch (TREE_CODE (ntype))
- {
+ {
case FUNCTION_TYPE:
hashcode += TYPE_HASH (TYPE_ARG_TYPES (ntype));
break;
break;
default:
break;
- }
+ }
ntype = type_hash_canon (hashcode, ntype);
ttype = build_qualified_type (ntype, TYPE_QUALS (ttype));
#ifdef VALID_MACHINE_TYPE_ATTRIBUTE
if (validated)
- /* Don't apply the attribute to both the decl and the type. */;
+ /* Don't apply the attribute to both the decl and the type. */
+ ;
else if (VALID_MACHINE_TYPE_ATTRIBUTE (type, type_attr_list, attr_name,
attr_args))
{
else
{
/* If this is part of a declaration, create a type variant,
- otherwise, this is part of a type definition, so add it
+ otherwise, this is part of a type definition, so add it
to the base type. */
type_attr_list = tree_cons (attr_name, attr_args, type_attr_list);
if (decl != 0)
tree ident;
{
int ident_len, attr_len;
- char *p;
+ const char *p;
if (TREE_CODE (ident) != IDENTIFIER_NODE)
return 0;
/* One that completely contains the other? Take it. */
else if (a2 != 0 && ! attribute_list_contained (a1, a2))
- {
- if (attribute_list_contained (a2, a1))
- attributes = a2;
- else
- {
- /* Pick the longest list, and hang on the other list. */
- /* ??? For the moment we punt on the issue of attrs with args. */
-
- if (list_length (a1) < list_length (a2))
- attributes = a2, a2 = a1;
-
- for (; a2 != 0; a2 = TREE_CHAIN (a2))
- if (lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
- attributes) == NULL_TREE)
- {
- a1 = copy_node (a2);
- TREE_CHAIN (a1) = attributes;
- attributes = a1;
- }
- }
- }
+ {
+ if (attribute_list_contained (a2, a1))
+ attributes = a2;
+ else
+ {
+ /* Pick the longest list, and hang on the other list. */
+ /* ??? For the moment we punt on the issue of attrs with args. */
+
+ if (list_length (a1) < list_length (a2))
+ attributes = a2, a2 = a1;
+
+ for (; a2 != 0; a2 = TREE_CHAIN (a2))
+ if (lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
+ attributes) == NULL_TREE)
+ {
+ a1 = copy_node (a2);
+ TREE_CHAIN (a1) = attributes;
+ attributes = a1;
+ }
+ }
+ }
return attributes;
}
static void
set_type_quals (type, type_quals)
tree type;
- int type_quals;
+ int type_quals;
{
TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
int type_quals;
{
register tree t;
-
+
/* Search the chain of variants to see if there is already one there just
like the one we need to have. If so, use that existing one. We must
preserve the TYPE_NAME, since there is code that depends on this. */
type_hash_hash (item)
const void *item;
{
- return ((const struct type_hash*)item)->hash;
+ return ((const struct type_hash *) item)->hash;
}
/* Look in the type hash table for a type isomorphic to TYPE.
struct type_hash *h, in;
/* The TYPE_ALIGN field of a type is set by layout_type(), so we
- must call that routine before comparing TYPE_ALIGNs. */
+ must call that routine before comparing TYPE_ALIGNs. */
layout_type (type);
in.hash = hashcode;
h->hash = hashcode;
h->type = type;
loc = htab_find_slot_with_hash (type_hash_table, h, hashcode, INSERT);
- *(struct type_hash**) loc = h;
+ *(struct type_hash **) loc = h;
}
/* Given TYPE, and HASHCODE its hash code, return the canonical
void **entry;
void *param ATTRIBUTE_UNUSED;
{
- struct type_hash *p = *(struct type_hash **)entry;
+ struct type_hash *p = *(struct type_hash **) entry;
ggc_mark_tree (p->type);
/* First check the obvious, maybe the lists are identical. */
if (l1 == l2)
- return 1;
+ return 1;
/* Maybe the lists are similar. */
for (t1 = l1, t2 = l2;
return TREE_INT_CST_LOW (t);
else
abort ();
-}
+}
/* Return the most significant bit of the integer constant T. */
rshift_double (TREE_INT_CST_LOW (t), TREE_INT_CST_HIGH (t), prec,
2 * HOST_BITS_PER_WIDE_INT, &l, &h, 0);
return (l & 1) == 1;
- }
+}
/* Return an indication of the sign of the integer constant T.
The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
case CONST_DECL:
case FUNCTION_DECL:
return 0;
-
+
default:
break;
}
OP must have integer, real or enumeral type. Pointers are not allowed!
There are some cases where the obvious value we could return
- would regenerate to OP if converted to OP's type,
+ would regenerate to OP if converted to OP's type,
but would not extend like OP to wider types.
If FOR_TYPE indicates such extension is contemplated, we eschew such values.
For example, if OP is (unsigned short)(signed char)-1,
{
if (TREE_CODE (context) == BLOCK)
context = BLOCK_SUPERCONTEXT (context);
- else
+ else
context = get_containing_scope (context);
}
}
/* CALL is a CALL_EXPR. Return the declaration for the function
- called, or NULL_TREE if the called function cannot be
+ called, or NULL_TREE if the called function cannot be
determined. */
tree
template[6] = '\0';
}
+/* P is a string that will be used in a symbol. Mask out any characters
+ that are not valid in that context. */
+
+void
+clean_symbol_name (p)
+ char *p;
+{
+ for (; *p; p++)
+ if (! (ISDIGIT(*p)
+#ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */
+ || *p == '$'
+#endif
+#ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */
+ || *p == '.'
+#endif
+ || ISUPPER (*p)
+ || ISLOWER (*p)))
+ *p = '_';
+}
+
/* Generate a name for a function unique to this translation unit.
TYPE is some string to identify the purpose of this function to the
linker or collect2. */
buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p)
+ strlen (type));
- /* Set up the name of the file-level functions we may need.
+ /* Set up the name of the file-level functions we may need.
Use a global object (which is already required to be unique over
the program) rather than the file name (which imposes extra
constraints). */
/* Don't need to pull weird characters out of global names. */
if (p != first_global_object_name)
- {
- for (q = buf+11; *q; q++)
- if (! ( ISDIGIT(*q)
-#ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */
- || *q == '$'
-#endif
-#ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */
- || *q == '.'
-#endif
- || ISUPPER(*q)
- || ISLOWER(*q)))
- *q = '_';
- }
+ clean_symbol_name (buf + 11);
return get_identifier (buf);
}
for (i = 0; i < bit_size; i++)
buffer[i] = 0;
- for (vals = TREE_OPERAND (init, 1);
+ for (vals = TREE_OPERAND (init, 1);
vals != NULL_TREE; vals = TREE_CHAIN (vals))
{
if (TREE_CODE (TREE_VALUE (vals)) != INTEGER_CST
= TREE_INT_CST_LOW (TREE_VALUE (vals)) - domain_min;
if (lo_index < 0 || lo_index >= bit_size
- || hi_index < 0 || hi_index >= bit_size)
+ || hi_index < 0 || hi_index >= bit_size)
abort ();
- for ( ; lo_index <= hi_index; lo_index++)
+ for (; lo_index <= hi_index; lo_index++)
buffer[lo_index] = 1;
}
else
int bit_size = wd_size * set_word_size;
int bit_pos = 0;
unsigned char *bytep = buffer;
- char *bit_buffer = (char *) alloca(bit_size);
+ char *bit_buffer = (char *) alloca (bit_size);
tree non_const_bits = get_set_constructor_bits (init, bit_buffer, bit_size);
for (i = 0; i < wd_size; i++)
#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
/* Complain that the tree code of NODE does not match the expected CODE.
FILE, LINE, and FUNCTION are of the caller. */
+
void
tree_check_failed (node, code, file, line, function)
const tree node;
/* Similar to above, except that we check for a class of tree
code, given in CL. */
+
void
tree_class_check_failed (node, cl, file, line, function)
const tree node;
}
#endif /* ENABLE_TREE_CHECKING */
-
\f
/* For a new vector type node T, build the information necessary for
debuggint output. */
+
static void
finish_vector_type (t)
tree t;
/* Create nodes for all integer types (and error_mark_node) using the sizes
of C datatypes. The caller should call set_sizetype soon after calling
this function to select one of the types as sizetype. */
-
+
void
build_common_tree_nodes (signed_char)
int signed_char;
layout_type (complex_long_double_type_node);
#ifdef BUILD_VA_LIST_TYPE
- BUILD_VA_LIST_TYPE(va_list_type_node);
+ BUILD_VA_LIST_TYPE (va_list_type_node);
#else
va_list_type_node = ptr_type_node;
#endif
OSDN Git Service
