/* 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",
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;
}
|| 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);
}
/* FALLTHRU */
case OMP_CLAUSE_DEVICE_RESIDENT:
- case OMP_CLAUSE_USE_DEVICE:
case OMP_CLAUSE_ASYNC:
case OMP_CLAUSE_WAIT:
case OMP_CLAUSE_WORKER:
{
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;
}
}
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. */
projects / gcc.git / blobdiff