static GTY ((if_marked ("tree_decl_map_marked_p"), param_is (struct tree_decl_map)))
htab_t value_expr_for_decl;
+static GTY ((if_marked ("tree_vec_map_marked_p"), param_is (struct tree_vec_map)))
+ htab_t debug_args_for_decl;
+
static GTY ((if_marked ("tree_priority_map_marked_p"),
param_is (struct tree_priority_map)))
htab_t init_priority_for_decl;
0, /* OMP_CLAUSE_ORDERED */
0, /* OMP_CLAUSE_DEFAULT */
3, /* OMP_CLAUSE_COLLAPSE */
- 0 /* OMP_CLAUSE_UNTIED */
+ 0, /* OMP_CLAUSE_UNTIED */
+ 1, /* OMP_CLAUSE_FINAL */
+ 0 /* OMP_CLAUSE_MERGEABLE */
};
const char * const omp_clause_code_name[] =
"ordered",
"default",
"collapse",
- "untied"
+ "untied",
+ "final",
+ "mergeable"
};
if (!uns)
return 0;
- /* Note that using TYPE_PRECISION here is wrong. We care about the
- actual bits, not the (arbitrary) range of the type. */
- prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)));
+ prec = TYPE_PRECISION (TREE_TYPE (expr));
if (prec >= HOST_BITS_PER_WIDE_INT)
{
HOST_WIDE_INT high_value;
if (code == POINTER_PLUS_EXPR && arg0 && arg1 && tt)
gcc_assert (POINTER_TYPE_P (tt) && POINTER_TYPE_P (TREE_TYPE (arg0))
- && INTEGRAL_TYPE_P (TREE_TYPE (arg1))
- && useless_type_conversion_p (sizetype, TREE_TYPE (arg1)));
+ && ptrofftype_p (TREE_TYPE (arg1)));
t = make_node_stat (code PASS_MEM_STAT);
TREE_TYPE (t) = tt;
/* Reset all the fields in a binfo node BINFO. We only keep
- BINFO_VIRTUALS, which is used by gimple_fold_obj_type_ref. */
+ BINFO_VTABLE, which is used by gimple_fold_obj_type_ref. */
static void
free_lang_data_in_binfo (tree binfo)
gcc_assert (TREE_CODE (binfo) == TREE_BINFO);
- BINFO_VTABLE (binfo) = NULL_TREE;
+ BINFO_VIRTUALS (binfo) = NULL_TREE;
BINFO_BASE_ACCESSES (binfo) = NULL;
BINFO_INHERITANCE_CHAIN (binfo) = NULL_TREE;
BINFO_SUBVTT_INDEX (binfo) = NULL_TREE;
&& DECL_INITIAL (decl)
&& TREE_CODE (DECL_INITIAL (decl)) == BLOCK)
{
- /* Strip builtins from the translation-unit BLOCK. We still have
- targets without builtin_decl support and also builtins are
- shared nodes and thus we can't use TREE_CHAIN in multiple
- lists. */
+ /* Strip builtins from the translation-unit BLOCK. We still have targets
+ without builtin_decl_explicit support and also builtins are shared
+ nodes and thus we can't use TREE_CHAIN in multiple lists. */
tree *nextp = &BLOCK_VARS (DECL_INITIAL (decl));
while (*nextp)
{
*(struct tree_decl_map **) loc = h;
}
+/* Lookup a vector of debug arguments for FROM, and return it if we
+ find one. */
+
+VEC(tree, gc) **
+decl_debug_args_lookup (tree from)
+{
+ struct tree_vec_map *h, in;
+
+ if (!DECL_HAS_DEBUG_ARGS_P (from))
+ return NULL;
+ gcc_checking_assert (debug_args_for_decl != NULL);
+ in.base.from = from;
+ h = (struct tree_vec_map *)
+ htab_find_with_hash (debug_args_for_decl, &in, DECL_UID (from));
+ if (h)
+ return &h->to;
+ return NULL;
+}
+
+/* Insert a mapping FROM->empty vector of debug arguments in the value
+ expression hashtable. */
+
+VEC(tree, gc) **
+decl_debug_args_insert (tree from)
+{
+ struct tree_vec_map *h;
+ void **loc;
+
+ if (DECL_HAS_DEBUG_ARGS_P (from))
+ return decl_debug_args_lookup (from);
+ if (debug_args_for_decl == NULL)
+ debug_args_for_decl = htab_create_ggc (64, tree_vec_map_hash,
+ tree_vec_map_eq, 0);
+ h = ggc_alloc_tree_vec_map ();
+ h->base.from = from;
+ h->to = NULL;
+ loc = htab_find_slot_with_hash (debug_args_for_decl, h, DECL_UID (from),
+ INSERT);
+ *(struct tree_vec_map **) loc = h;
+ DECL_HAS_DEBUG_ARGS_P (from) = 1;
+ return &h->to;
+}
+
/* Hashing of types so that we don't make duplicates.
The entry point is `type_hash_canon'. */
t1 != 0 && t2 != 0
&& TREE_PURPOSE (t1) == TREE_PURPOSE (t2)
&& TREE_VALUE (t1) == TREE_VALUE (t2);
- t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2));
+ t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
+ ;
/* Maybe the lists are equal. */
if (t1 == 0 && t2 == 0)
return TREE_INT_CST_LOW (t);
}
-/* Return the most significant bit of the integer constant T. */
+/* Return the most significant (sign) bit of T. */
int
-tree_int_cst_msb (const_tree t)
+tree_int_cst_sign_bit (const_tree t)
{
- int prec;
- HOST_WIDE_INT h;
- unsigned HOST_WIDE_INT l;
+ unsigned bitno = TYPE_PRECISION (TREE_TYPE (t)) - 1;
+ unsigned HOST_WIDE_INT w;
+
+ if (bitno < HOST_BITS_PER_WIDE_INT)
+ w = TREE_INT_CST_LOW (t);
+ else
+ {
+ w = TREE_INT_CST_HIGH (t);
+ bitno -= HOST_BITS_PER_WIDE_INT;
+ }
- /* Note that using TYPE_PRECISION here is wrong. We care about the
- actual bits, not the (arbitrary) range of the type. */
- prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (t))) - 1;
- 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 (w >> bitno) & 1;
}
/* Return an indication of the sign of the integer constant T.
or front end builtins, since the function code is overloaded in those
cases. */
if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL
- && built_in_decls[DECL_FUNCTION_CODE (t)])
+ && builtin_decl_explicit_p (DECL_FUNCTION_CODE (t)))
{
- t = built_in_decls[DECL_FUNCTION_CODE (t)];
+ t = builtin_decl_explicit (DECL_FUNCTION_CODE (t));
code = TREE_CODE (t);
}
/* FALL THROUGH */
file = input_filename;
len = strlen (file);
- q = (char *) alloca (9 * 2 + len + 1);
+ q = (char *) alloca (9 + 17 + len + 1);
memcpy (q, file, len + 1);
- sprintf (q + len, "_%08X_%08X", crc32_string (0, name),
- crc32_string (0, get_random_seed (false)));
+ snprintf (q + len, 9 + 17 + 1, "_%08X_" HOST_WIDE_INT_PRINT_HEX,
+ crc32_string (0, name), get_random_seed (false));
p = q;
}
}
/* Create nodes for all integer types (and error_mark_node) using the sizes
- of C datatypes. */
+ of C datatypes. SIGNED_CHAR specifies whether char is signed,
+ SHORT_DOUBLE specifies whether double should be of the same precision
+ as float. */
void
-build_common_tree_nodes (bool signed_char)
+build_common_tree_nodes (bool signed_char, bool short_double)
{
error_mark_node = make_node (ERROR_MARK);
TREE_TYPE (error_mark_node) = error_mark_node;
size_type_node = long_unsigned_type_node;
else if (strcmp (SIZE_TYPE, "long long unsigned int") == 0)
size_type_node = long_long_unsigned_type_node;
+ else if (strcmp (SIZE_TYPE, "short unsigned int") == 0)
+ size_type_node = short_unsigned_type_node;
else
gcc_unreachable ();
access_public_node = get_identifier ("public");
access_protected_node = get_identifier ("protected");
access_private_node = get_identifier ("private");
-}
-
-/* Call this function after calling build_common_tree_nodes.
- It will create several other common tree nodes. */
-void
-build_common_tree_nodes_2 (int short_double)
-{
/* Define these next since types below may used them. */
integer_zero_node = build_int_cst (integer_type_node, 0);
integer_one_node = build_int_cst (integer_type_node, 1);
DECL_ATTRIBUTES (decl) = tree_cons (get_identifier ("leaf"),
NULL, DECL_ATTRIBUTES (decl));
- built_in_decls[code] = decl;
- implicit_built_in_decls[code] = decl;
+ set_builtin_decl (code, decl, true);
}
/* Call this function after instantiating all builtins that the language
{
tree tmp, ftype;
- if (built_in_decls[BUILT_IN_MEMCPY] == NULL
- || built_in_decls[BUILT_IN_MEMMOVE] == NULL)
+ if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY)
+ || !builtin_decl_explicit_p (BUILT_IN_MEMMOVE))
{
ftype = build_function_type_list (ptr_type_node,
ptr_type_node, const_ptr_type_node,
size_type_node, NULL_TREE);
- if (built_in_decls[BUILT_IN_MEMCPY] == NULL)
+ if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY))
local_define_builtin ("__builtin_memcpy", ftype, BUILT_IN_MEMCPY,
"memcpy", ECF_NOTHROW | ECF_LEAF);
- if (built_in_decls[BUILT_IN_MEMMOVE] == NULL)
+ if (!builtin_decl_explicit_p (BUILT_IN_MEMMOVE))
local_define_builtin ("__builtin_memmove", ftype, BUILT_IN_MEMMOVE,
"memmove", ECF_NOTHROW | ECF_LEAF);
}
- if (built_in_decls[BUILT_IN_MEMCMP] == NULL)
+ if (!builtin_decl_explicit_p (BUILT_IN_MEMCMP))
{
ftype = build_function_type_list (integer_type_node, const_ptr_type_node,
const_ptr_type_node, size_type_node,
"memcmp", ECF_PURE | ECF_NOTHROW | ECF_LEAF);
}
- if (built_in_decls[BUILT_IN_MEMSET] == NULL)
+ if (!builtin_decl_explicit_p (BUILT_IN_MEMSET))
{
ftype = build_function_type_list (ptr_type_node,
ptr_type_node, integer_type_node,
"memset", ECF_NOTHROW | ECF_LEAF);
}
- if (built_in_decls[BUILT_IN_ALLOCA] == NULL)
+ if (!builtin_decl_explicit_p (BUILT_IN_ALLOCA))
{
ftype = build_function_type_list (ptr_type_node,
size_type_node, NULL_TREE);
"alloca", ECF_MALLOC | ECF_NOTHROW | ECF_LEAF);
}
+ ftype = build_function_type_list (ptr_type_node, size_type_node,
+ size_type_node, NULL_TREE);
+ local_define_builtin ("__builtin_alloca_with_align", ftype,
+ BUILT_IN_ALLOCA_WITH_ALIGN, "alloca",
+ ECF_MALLOC | ECF_NOTHROW | ECF_LEAF);
+
/* If we're checking the stack, `alloca' can throw. */
if (flag_stack_check)
- TREE_NOTHROW (built_in_decls[BUILT_IN_ALLOCA]) = 0;
+ {
+ TREE_NOTHROW (builtin_decl_explicit (BUILT_IN_ALLOCA)) = 0;
+ TREE_NOTHROW (builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN)) = 0;
+ }
ftype = build_function_type_list (void_type_node,
ptr_type_node, ptr_type_node,
? "_Unwind_SjLj_Resume" : "_Unwind_Resume"),
ECF_NORETURN);
+ if (builtin_decl_explicit (BUILT_IN_RETURN_ADDRESS) == NULL_TREE)
+ {
+ ftype = build_function_type_list (ptr_type_node, integer_type_node,
+ NULL_TREE);
+ local_define_builtin ("__builtin_return_address", ftype,
+ BUILT_IN_RETURN_ADDRESS,
+ "__builtin_return_address",
+ ECF_NOTHROW);
+ }
+
+ if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER)
+ || !builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT))
+ {
+ ftype = build_function_type_list (void_type_node, ptr_type_node,
+ ptr_type_node, NULL_TREE);
+ if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER))
+ local_define_builtin ("__cyg_profile_func_enter", ftype,
+ BUILT_IN_PROFILE_FUNC_ENTER,
+ "__cyg_profile_func_enter", 0);
+ if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT))
+ local_define_builtin ("__cyg_profile_func_exit", ftype,
+ BUILT_IN_PROFILE_FUNC_EXIT,
+ "__cyg_profile_func_exit", 0);
+ }
+
/* The exception object and filter values from the runtime. The argument
must be zero before exception lowering, i.e. from the front end. After
exception lowering, it will be the region number for the exception
return make_vector_type (innertype, nunits, VOIDmode);
}
-/* Similarly, but takes the inner type and number of units, which must be
- a power of two. */
+/* Similarly, but builds a variant type with TYPE_VECTOR_OPAQUE set. */
tree
build_opaque_vector_type (tree innertype, int nunits)
{
- tree t;
- innertype = build_distinct_type_copy (innertype);
- t = make_vector_type (innertype, nunits, VOIDmode);
- TYPE_VECTOR_OPAQUE (t) = true;
- return t;
+ tree t = make_vector_type (innertype, nunits, VOIDmode);
+ tree cand;
+ /* We always build the non-opaque variant before the opaque one,
+ so if it already exists, it is TYPE_NEXT_VARIANT of this one. */
+ cand = TYPE_NEXT_VARIANT (t);
+ if (cand
+ && TYPE_VECTOR_OPAQUE (cand)
+ && check_qualified_type (cand, t, TYPE_QUALS (t)))
+ return cand;
+ /* Othewise build a variant type and make sure to queue it after
+ the non-opaque type. */
+ cand = build_distinct_type_copy (t);
+ TYPE_VECTOR_OPAQUE (cand) = true;
+ TYPE_CANONICAL (cand) = TYPE_CANONICAL (t);
+ TYPE_NEXT_VARIANT (cand) = TYPE_NEXT_VARIANT (t);
+ TYPE_NEXT_VARIANT (t) = cand;
+ TYPE_MAIN_VARIANT (cand) = TYPE_MAIN_VARIANT (t);
+ return cand;
}
case OMP_CLAUSE_FIRSTPRIVATE:
case OMP_CLAUSE_COPYIN:
case OMP_CLAUSE_COPYPRIVATE:
+ case OMP_CLAUSE_FINAL:
case OMP_CLAUSE_IF:
case OMP_CLAUSE_NUM_THREADS:
case OMP_CLAUSE_SCHEDULE:
case OMP_CLAUSE_ORDERED:
case OMP_CLAUSE_DEFAULT:
case OMP_CLAUSE_UNTIED:
+ case OMP_CLAUSE_MERGEABLE:
WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
case OMP_CLAUSE_LASTPRIVATE:
if (result || !walk_subtrees)
return result;
- result = walk_type_fields (*type_p, func, data, pset, lh);
- if (result)
- return result;
+ /* But do not walk a pointed-to type since it may itself need to
+ be walked in the declaration case if it isn't anonymous. */
+ if (!POINTER_TYPE_P (*type_p))
+ {
+ result = walk_type_fields (*type_p, func, data, pset, lh);
+ if (result)
+ return result;
+ }
/* If this is a record type, also walk the fields. */
if (RECORD_OR_UNION_TYPE_P (*type_p))
OSDN Git Service
