/* Language-independent node constructors for parse phase of GNU compiler.
- Copyright (C) 1987-2015 Free Software Foundation, Inc.
+ Copyright (C) 1987-2016 Free Software Foundation, Inc.
This file is part of GCC.
1, /* OMP_CLAUSE_IS_DEVICE_PTR */
2, /* OMP_CLAUSE__CACHE_ */
1, /* OMP_CLAUSE_DEVICE_RESIDENT */
- 1, /* OMP_CLAUSE_USE_DEVICE */
2, /* OMP_CLAUSE_GANG */
1, /* OMP_CLAUSE_ASYNC */
1, /* OMP_CLAUSE_WAIT */
"is_device_ptr",
"_cache_",
"device_resident",
- "use_device",
"gang",
"async",
"wait",
return t;
}
+
+/* Free tree node. */
+
+void
+free_node (tree node)
+{
+ enum tree_code code = TREE_CODE (node);
+ if (GATHER_STATISTICS)
+ {
+ tree_code_counts[(int) TREE_CODE (node)]--;
+ tree_node_counts[(int) t_kind]--;
+ tree_node_sizes[(int) t_kind] -= tree_code_size (TREE_CODE (node));
+ }
+ if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
+ vec_free (CONSTRUCTOR_ELTS (node));
+ else if (code == BLOCK)
+ vec_free (BLOCK_NONLOCALIZED_VARS (node));
+ else if (code == TREE_BINFO)
+ vec_free (BINFO_BASE_ACCESSES (node));
+ ggc_free (node);
+}
\f
/* Return a new node with the same contents as NODE except that its
TREE_CHAIN, if it has one, is zero and it has a fresh uid. */
get_int_cst_ext_nunits (tree type, const wide_int &cst)
{
gcc_checking_assert (cst.get_precision () == TYPE_PRECISION (type));
- /* We need an extra zero HWI if CST is an unsigned integer with its
- upper bit set, and if CST occupies a whole number of HWIs. */
- if (TYPE_UNSIGNED (type)
- && wi::neg_p (cst)
- && (cst.get_precision () % HOST_BITS_PER_WIDE_INT) == 0)
+ /* We need extra HWIs if CST is an unsigned integer with its
+ upper bit set. */
+ if (TYPE_UNSIGNED (type) && wi::neg_p (cst))
return cst.get_precision () / HOST_BITS_PER_WIDE_INT + 1;
return cst.get_len ();
}
if (len < ext_len)
{
--ext_len;
- TREE_INT_CST_ELT (nt, ext_len) = 0;
+ TREE_INT_CST_ELT (nt, ext_len)
+ = zext_hwi (-1, cst.get_precision () % HOST_BITS_PER_WIDE_INT);
for (unsigned int i = len; i < ext_len; ++i)
TREE_INT_CST_ELT (nt, i) = -1;
}
int
integer_zerop (const_tree expr)
{
- STRIP_NOPS (expr);
-
switch (TREE_CODE (expr))
{
case INTEGER_CST:
int
integer_onep (const_tree expr)
{
- STRIP_NOPS (expr);
-
switch (TREE_CODE (expr))
{
case INTEGER_CST:
int
integer_each_onep (const_tree expr)
{
- STRIP_NOPS (expr);
-
if (TREE_CODE (expr) == COMPLEX_CST)
return (integer_onep (TREE_REALPART (expr))
&& integer_onep (TREE_IMAGPART (expr)));
int
integer_all_onesp (const_tree expr)
{
- STRIP_NOPS (expr);
-
if (TREE_CODE (expr) == COMPLEX_CST
&& integer_all_onesp (TREE_REALPART (expr))
&& integer_all_onesp (TREE_IMAGPART (expr)))
int
integer_minus_onep (const_tree expr)
{
- STRIP_NOPS (expr);
-
if (TREE_CODE (expr) == COMPLEX_CST)
return (integer_all_onesp (TREE_REALPART (expr))
&& integer_zerop (TREE_IMAGPART (expr)));
int
integer_pow2p (const_tree expr)
{
- STRIP_NOPS (expr);
-
if (TREE_CODE (expr) == COMPLEX_CST
&& integer_pow2p (TREE_REALPART (expr))
&& integer_zerop (TREE_IMAGPART (expr)))
int
integer_nonzerop (const_tree expr)
{
- STRIP_NOPS (expr);
-
return ((TREE_CODE (expr) == INTEGER_CST
&& !wi::eq_p (expr, 0))
|| (TREE_CODE (expr) == COMPLEX_CST
int
integer_truep (const_tree expr)
{
- STRIP_NOPS (expr);
-
if (TREE_CODE (expr) == VECTOR_CST)
return integer_all_onesp (expr);
return integer_onep (expr);
int
tree_log2 (const_tree expr)
{
- STRIP_NOPS (expr);
-
if (TREE_CODE (expr) == COMPLEX_CST)
return tree_log2 (TREE_REALPART (expr));
int
tree_floor_log2 (const_tree expr)
{
- STRIP_NOPS (expr);
-
if (TREE_CODE (expr) == COMPLEX_CST)
return tree_log2 (TREE_REALPART (expr));
int
real_zerop (const_tree expr)
{
- STRIP_NOPS (expr);
-
switch (TREE_CODE (expr))
{
case REAL_CST:
int
real_onep (const_tree expr)
{
- STRIP_NOPS (expr);
-
switch (TREE_CODE (expr))
{
case REAL_CST:
int
real_minus_onep (const_tree expr)
{
- STRIP_NOPS (expr);
-
switch (TREE_CODE (expr))
{
case REAL_CST:
not handle arithmetic; that's handled in skip_simple_arithmetic and
tree_invariant_p). */
-static bool tree_invariant_p (tree t);
-
static bool
tree_invariant_p_1 (tree t)
{
/* Return true if T is function-invariant. */
-static bool
+bool
tree_invariant_p (tree t)
{
tree inner = skip_simple_arithmetic (t);
|| CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type)));
case ARRAY_TYPE:
- /* We have already checked the component type above, so just check the
- domain type. */
- return type_contains_placeholder_p (TYPE_DOMAIN (type));
+ /* We have already checked the component type above, so just check
+ the domain type. Flexible array members have a null domain. */
+ return TYPE_DOMAIN (type) ?
+ type_contains_placeholder_p (TYPE_DOMAIN (type)) : false;
case RECORD_TYPE:
case UNION_TYPE:
while (member)
{
if (TREE_CODE (member) == FIELD_DECL
- || TREE_CODE (member) == TYPE_DECL)
+ || (TREE_CODE (member) == TYPE_DECL
+ && !DECL_IGNORED_P (member)
+ && debug_info_level > DINFO_LEVEL_TERSE
+ && !is_redundant_typedef (member)))
{
if (prev)
TREE_CHAIN (prev) = member;
/* Remove TYPE_METHODS list. While it would be nice to keep it
to enable ODR warnings about different method lists, doing so
seems to impractically increase size of LTO data streamed.
- Keep the infrmation if TYPE_METHODS was non-NULL. This is used
+ Keep the information if TYPE_METHODS was non-NULL. This is used
by function.c and pretty printers. */
if (TYPE_METHODS (type))
TYPE_METHODS (type) = error_mark_node;
while (tem)
{
if (TREE_CODE (tem) == FIELD_DECL
- || TREE_CODE (tem) == TYPE_DECL)
+ || (TREE_CODE (tem) == TYPE_DECL
+ && !DECL_IGNORED_P (tem)
+ && debug_info_level > DINFO_LEVEL_TERSE
+ && !is_redundant_typedef (tem)))
fld_worklist_push (tem, fld);
tem = TREE_CHAIN (tem);
}
/* Since we're building a variant, assume that it is a non-semantic
variant. This also propagates TYPE_STRUCTURAL_EQUALITY_P. */
TYPE_CANONICAL (t) = TYPE_CANONICAL (type);
+ /* Type variants have no alias set defined. */
+ TYPE_ALIAS_SET (t) = -1;
/* Add the new type to the chain of variants of TYPE. */
TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
{
tree t1 = ((type_hash *) *loc)->type;
gcc_assert (TYPE_MAIN_VARIANT (t1) == t1);
- if (GATHER_STATISTICS)
- {
- tree_code_counts[(int) TREE_CODE (type)]--;
- tree_node_counts[(int) t_kind]--;
- tree_node_sizes[(int) t_kind] -= sizeof (struct tree_type_non_common);
- }
+ free_node (type);
return t1;
}
else
TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (to_type);
TYPE_POINTER_TO (to_type) = t;
- if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
+ /* During LTO we do not set TYPE_CANONICAL of pointers and references. */
+ if (TYPE_STRUCTURAL_EQUALITY_P (to_type) || in_lto_p)
SET_TYPE_STRUCTURAL_EQUALITY (t);
else if (TYPE_CANONICAL (to_type) != to_type || could_alias)
TYPE_CANONICAL (t)
TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (to_type);
TYPE_REFERENCE_TO (to_type) = t;
- if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
+ /* During LTO we do not set TYPE_CANONICAL of pointers and references. */
+ if (TYPE_STRUCTURAL_EQUALITY_P (to_type) || in_lto_p)
SET_TYPE_STRUCTURAL_EQUALITY (t);
else if (TYPE_CANONICAL (to_type) != to_type || could_alias)
TYPE_CANONICAL (t)
if (TYPE_CANONICAL (t) == t)
{
if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
- || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type)))
+ || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type))
+ || in_lto_p)
SET_TYPE_STRUCTURAL_EQUALITY (t);
else if (TYPE_CANONICAL (elt_type) != elt_type
|| (index_type && TYPE_CANONICAL (index_type) != index_type))
return NULL_TREE;
}
+/* If CALL_EXPR CALL calls a normal built-in function or an internal function,
+ return the associated function code, otherwise return CFN_LAST. */
+
+combined_fn
+get_call_combined_fn (const_tree call)
+{
+ /* It's invalid to call this function with anything but a CALL_EXPR. */
+ gcc_assert (TREE_CODE (call) == CALL_EXPR);
+
+ if (!CALL_EXPR_FN (call))
+ return as_combined_fn (CALL_EXPR_IFN (call));
+
+ tree fndecl = get_callee_fndecl (call);
+ if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
+ return as_combined_fn (DECL_FUNCTION_CODE (fndecl));
+
+ return CFN_LAST;
+}
+
#define TREE_MEM_USAGE_SPACES 40
/* Print debugging information about tree nodes generated during the compile,
{
tree t;
inchash::hash hstate;
+ tree mv_innertype = TYPE_MAIN_VARIANT (innertype);
t = make_node (VECTOR_TYPE);
- TREE_TYPE (t) = TYPE_MAIN_VARIANT (innertype);
+ TREE_TYPE (t) = mv_innertype;
SET_TYPE_VECTOR_SUBPARTS (t, nunits);
SET_TYPE_MODE (t, mode);
- if (TYPE_STRUCTURAL_EQUALITY_P (innertype))
+ if (TYPE_STRUCTURAL_EQUALITY_P (mv_innertype) || in_lto_p)
SET_TYPE_STRUCTURAL_EQUALITY (t);
- else if ((TYPE_CANONICAL (innertype) != innertype
+ else if ((TYPE_CANONICAL (mv_innertype) != innertype
|| mode != VOIDmode)
&& !VECTOR_BOOLEAN_TYPE_P (t))
TYPE_CANONICAL (t)
- = make_vector_type (TYPE_CANONICAL (innertype), nunits, VOIDmode);
+ = make_vector_type (TYPE_CANONICAL (mv_innertype), nunits, VOIDmode);
layout_type (t);
return build_call_expr_loc_array (UNKNOWN_LOCATION, fndecl, n, argarray);
}
+/* Build an internal call to IFN, with arguments ARGS[0:N-1] and with return
+ type TYPE. This is just like CALL_EXPR, except its CALL_EXPR_FN is NULL.
+ It will get gimplified later into an ordinary internal function. */
+
+tree
+build_call_expr_internal_loc_array (location_t loc, internal_fn ifn,
+ tree type, int n, const tree *args)
+{
+ tree t = build_call_1 (type, NULL_TREE, n);
+ for (int i = 0; i < n; ++i)
+ CALL_EXPR_ARG (t, i) = args[i];
+ SET_EXPR_LOCATION (t, loc);
+ CALL_EXPR_IFN (t) = ifn;
+ return t;
+}
+
/* Build internal call expression. This is just like CALL_EXPR, except
its CALL_EXPR_FN is NULL. It will get gimplified later into ordinary
internal function. */
tree type, int n, ...)
{
va_list ap;
+ tree *argarray = XALLOCAVEC (tree, n);
int i;
- tree fn = build_call_1 (type, NULL_TREE, n);
va_start (ap, n);
for (i = 0; i < n; i++)
- CALL_EXPR_ARG (fn, i) = va_arg (ap, tree);
+ argarray[i] = va_arg (ap, tree);
+ va_end (ap);
+ return build_call_expr_internal_loc_array (loc, ifn, type, n, argarray);
+}
+
+/* Return a function call to FN, if the target is guaranteed to support it,
+ or null otherwise.
+
+ N is the number of arguments, passed in the "...", and TYPE is the
+ type of the return value. */
+
+tree
+maybe_build_call_expr_loc (location_t loc, combined_fn fn, tree type,
+ int n, ...)
+{
+ va_list ap;
+ tree *argarray = XALLOCAVEC (tree, n);
+ int i;
+
+ va_start (ap, n);
+ for (i = 0; i < n; i++)
+ argarray[i] = va_arg (ap, tree);
va_end (ap);
- SET_EXPR_LOCATION (fn, loc);
- CALL_EXPR_IFN (fn) = ifn;
- return fn;
+ if (internal_fn_p (fn))
+ {
+ internal_fn ifn = as_internal_fn (fn);
+ if (direct_internal_fn_p (ifn))
+ {
+ tree_pair types = direct_internal_fn_types (ifn, type, argarray);
+ if (!direct_internal_fn_supported_p (ifn, types,
+ OPTIMIZE_FOR_BOTH))
+ return NULL_TREE;
+ }
+ return build_call_expr_internal_loc_array (loc, ifn, type, n, argarray);
+ }
+ else
+ {
+ tree fndecl = builtin_decl_implicit (as_builtin_fn (fn));
+ if (!fndecl)
+ return NULL_TREE;
+ return build_call_expr_loc_array (loc, fndecl, n, argarray);
+ }
}
/* Create a new constant string literal and return a char* pointer to it.
/* FALLTHRU */
case OMP_CLAUSE_DEVICE_RESIDENT:
- case OMP_CLAUSE_USE_DEVICE:
case OMP_CLAUSE_ASYNC:
case OMP_CLAUSE_WAIT:
case OMP_CLAUSE_WORKER:
if ((!in_lto_p || !TYPE_FILE_SCOPE_P (t)) && 0)
verify_variant_match (TYPE_CONTEXT);
verify_variant_match (TYPE_STRING_FLAG);
- if (TYPE_ALIAS_SET_KNOWN_P (t) && TYPE_ALIAS_SET_KNOWN_P (tv))
- verify_variant_match (TYPE_ALIAS_SET);
+ if (TYPE_ALIAS_SET_KNOWN_P (t))
+ {
+ error ("type variant with TYPE_ALIAS_SET_KNOWN_P");
+ debug_tree (tv);
+ return false;
+ }
/* tree_type_non_common checks. */
TBAA is concerned.
This function is used both by lto.c canonical type merging and by the
verifier. If TRUST_TYPE_CANONICAL we do not look into structure of types
- that have TYPE_CANONICAL defined and assume them equivalent. */
+ that have TYPE_CANONICAL defined and assume them equivalent. This is useful
+ only for LTO because only in these cases TYPE_CANONICAL equivalence
+ correspond to one defined by gimple_canonical_types_compatible_p. */
bool
gimple_canonical_types_compatible_p (const_tree t1, const_tree t2,
|| (type_with_alias_set_p (t1) && type_with_alias_set_p (t2)));
/* If the types have been previously registered and found equal
they still are. */
+
if (TYPE_CANONICAL (t1) && TYPE_CANONICAL (t2)
&& trust_type_canonical)
- return TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2);
+ {
+ /* Do not use TYPE_CANONICAL of pointer types. For LTO streamed types
+ they are always NULL, but they are set to non-NULL for types
+ constructed by build_pointer_type and variants. In this case the
+ TYPE_CANONICAL is more fine grained than the equivalnce we test (where
+ all pointers are considered equal. Be sure to not return false
+ negatives. */
+ gcc_checking_assert (canonical_type_used_p (t1)
+ && canonical_type_used_p (t2));
+ return TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2);
+ }
/* Can't be the same type if the types don't have the same code. */
enum tree_code code = tree_code_for_canonical_type_merging (TREE_CODE (t1));
{
tree f1, f2;
+ /* Don't try to compare variants of an incomplete type, before
+ TYPE_FIELDS has been copied around. */
+ if (!COMPLETE_TYPE_P (t1) && !COMPLETE_TYPE_P (t2))
+ return true;
+
+
if (TYPE_REVERSE_STORAGE_ORDER (t1) != TYPE_REVERSE_STORAGE_ORDER (t2))
return false;
debug_tree (ct);
error_found = true;
}
+ if (TYPE_MAIN_VARIANT (t) == t && ct && TYPE_MAIN_VARIANT (ct) != ct)
+ {
+ error ("TYPE_CANONICAL of main variant is not main variant");
+ debug_tree (ct);
+ debug_tree (TYPE_MAIN_VARIANT (ct));
+ error_found = true;
+ }
/* Check various uses of TYPE_MINVAL. */
}
}
else if (RECORD_OR_UNION_TYPE_P (t))
- for (tree fld = TYPE_FIELDS (t); fld; fld = TREE_CHAIN (fld))
- {
- /* TODO: verify properties of decls. */
- if (TREE_CODE (fld) == FIELD_DECL)
- ;
- else if (TREE_CODE (fld) == TYPE_DECL)
- ;
- else if (TREE_CODE (fld) == CONST_DECL)
- ;
- else if (TREE_CODE (fld) == VAR_DECL)
- ;
- else if (TREE_CODE (fld) == TEMPLATE_DECL)
- ;
- else if (TREE_CODE (fld) == USING_DECL)
- ;
- else
- {
- error ("Wrong tree in TYPE_FIELDS list");
- debug_tree (fld);
- error_found = true;
- }
- }
+ {
+ if (TYPE_FIELDS (t) && !COMPLETE_TYPE_P (t) && in_lto_p)
+ {
+ error ("TYPE_FIELDS defined in incomplete type");
+ error_found = true;
+ }
+ for (tree fld = TYPE_FIELDS (t); fld; fld = TREE_CHAIN (fld))
+ {
+ /* TODO: verify properties of decls. */
+ if (TREE_CODE (fld) == FIELD_DECL)
+ ;
+ else if (TREE_CODE (fld) == TYPE_DECL)
+ ;
+ else if (TREE_CODE (fld) == CONST_DECL)
+ ;
+ else if (TREE_CODE (fld) == VAR_DECL)
+ ;
+ else if (TREE_CODE (fld) == TEMPLATE_DECL)
+ ;
+ else if (TREE_CODE (fld) == USING_DECL)
+ ;
+ else
+ {
+ error ("Wrong tree in TYPE_FIELDS list");
+ debug_tree (fld);
+ error_found = true;
+ }
+ }
+ }
else if (TREE_CODE (t) == INTEGER_TYPE
|| TREE_CODE (t) == BOOLEAN_TYPE
|| TREE_CODE (t) == OFFSET_TYPE
tree t, attrs, fntype;
unsigned HOST_WIDE_INT arg_num;
- gcc_assert (TREE_CODE (arg) == PARM_DECL && POINTER_TYPE_P (TREE_TYPE (arg)));
+ gcc_assert (TREE_CODE (arg) == PARM_DECL
+ && (POINTER_TYPE_P (TREE_TYPE (arg))
+ || TREE_CODE (TREE_TYPE (arg)) == OFFSET_TYPE));
/* The static chain decl is always non null. */
if (arg == cfun->static_chain_decl)
/* Given location LOC, strip away any packed range information
or ad-hoc information. */
-static location_t
+location_t
get_pure_location (location_t loc)
{
if (IS_ADHOC_LOC (loc))
return COMBINE_LOCATION_DATA (line_table, pure_loc, src_range, block);
}
-void
+location_t
set_source_range (tree expr, location_t start, location_t finish)
{
source_range src_range;
src_range.m_start = start;
src_range.m_finish = finish;
- set_source_range (expr, src_range);
+ return set_source_range (expr, src_range);
}
-void
+location_t
set_source_range (tree expr, source_range src_range)
{
if (!EXPR_P (expr))
- return;
+ return UNKNOWN_LOCATION;
location_t pure_loc = get_pure_location (EXPR_LOCATION (expr));
location_t adhoc = COMBINE_LOCATION_DATA (line_table,
src_range,
NULL);
SET_EXPR_LOCATION (expr, adhoc);
+ return adhoc;
+}
+
+location_t
+make_location (location_t caret, location_t start, location_t finish)
+{
+ location_t pure_loc = get_pure_location (caret);
+ source_range src_range;
+ src_range.m_start = start;
+ src_range.m_finish = finish;
+ location_t combined_loc = COMBINE_LOCATION_DATA (line_table,
+ pure_loc,
+ src_range,
+ NULL);
+ return combined_loc;
+}
+
+/* Return the name of combined function FN, for debugging purposes. */
+
+const char *
+combined_fn_name (combined_fn fn)
+{
+ if (builtin_fn_p (fn))
+ {
+ tree fndecl = builtin_decl_explicit (as_builtin_fn (fn));
+ return IDENTIFIER_POINTER (DECL_NAME (fndecl));
+ }
+ else
+ return internal_fn_name (as_internal_fn (fn));
}
#include "gt-tree.h"
projects / gcc.git / blobdiff