diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 823da542a693ea589cfd62346f9933e59859a4a7..dde91ceea5ba70db67f76560825b3718ff8f13b1 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,139 @@
+2017-08-08 Martin Liska <mliska@suse.cz>
+
+ * asan.c: Include header files.
+ * attribs.c (build_decl_attribute_variant): New function moved
+ from tree.[ch].
+ (build_type_attribute_qual_variant): Likewise.
+ (cmp_attrib_identifiers): Likewise.
+ (simple_cst_list_equal): Likewise.
+ (omp_declare_simd_clauses_equal): Likewise.
+ (attribute_value_equal): Likewise.
+ (comp_type_attributes): Likewise.
+ (build_type_attribute_variant): Likewise.
+ (lookup_ident_attribute): Likewise.
+ (remove_attribute): Likewise.
+ (merge_attributes): Likewise.
+ (merge_type_attributes): Likewise.
+ (merge_decl_attributes): Likewise.
+ (merge_dllimport_decl_attributes): Likewise.
+ (handle_dll_attribute): Likewise.
+ (attribute_list_equal): Likewise.
+ (attribute_list_contained): Likewise.
+ * attribs.h (lookup_attribute): New function moved from tree.[ch].
+ (lookup_attribute_by_prefix): Likewise.
+ * bb-reorder.c: Include header files.
+ * builtins.c: Likewise.
+ * calls.c: Likewise.
+ * cfgexpand.c: Likewise.
+ * cgraph.c: Likewise.
+ * cgraphunit.c: Likewise.
+ * convert.c: Likewise.
+ * dwarf2out.c: Likewise.
+ * final.c: Likewise.
+ * fold-const.c: Likewise.
+ * function.c: Likewise.
+ * gimple-expr.c: Likewise.
+ * gimple-fold.c: Likewise.
+ * gimple-pretty-print.c: Likewise.
+ * gimple.c: Likewise.
+ * gimplify.c: Likewise.
+ * hsa-common.c: Likewise.
+ * hsa-gen.c: Likewise.
+ * internal-fn.c: Likewise.
+ * ipa-chkp.c: Likewise.
+ * ipa-cp.c: Likewise.
+ * ipa-devirt.c: Likewise.
+ * ipa-fnsummary.c: Likewise.
+ * ipa-inline.c: Likewise.
+ * ipa-visibility.c: Likewise.
+ * ipa.c: Likewise.
+ * lto-cgraph.c: Likewise.
+ * omp-expand.c: Likewise.
+ * omp-general.c: Likewise.
+ * omp-low.c: Likewise.
+ * omp-offload.c: Likewise.
+ * omp-simd-clone.c: Likewise.
+ * opts-global.c: Likewise.
+ * passes.c: Likewise.
+ * predict.c: Likewise.
+ * sancov.c: Likewise.
+ * sanopt.c: Likewise.
+ * symtab.c: Likewise.
+ * toplev.c: Likewise.
+ * trans-mem.c: Likewise.
+ * tree-chkp.c: Likewise.
+ * tree-eh.c: Likewise.
+ * tree-into-ssa.c: Likewise.
+ * tree-object-size.c: Likewise.
+ * tree-parloops.c: Likewise.
+ * tree-profile.c: Likewise.
+ * tree-ssa-ccp.c: Likewise.
+ * tree-ssa-live.c: Likewise.
+ * tree-ssa-loop.c: Likewise.
+ * tree-ssa-sccvn.c: Likewise.
+ * tree-ssa-structalias.c: Likewise.
+ * tree-ssa.c: Likewise.
+ * tree-streamer-in.c: Likewise.
+ * tree-vectorizer.c: Likewise.
+ * tree-vrp.c: Likewise.
+ * tsan.c: Likewise.
+ * ubsan.c: Likewise.
+ * varasm.c: Likewise.
+ * varpool.c: Likewise.
+ * tree.c: Remove functions moved to attribs.[ch].
+ * tree.h: Likewise.
+ * config/aarch64/aarch64.c: Add attrs.h header file.
+ * config/alpha/alpha.c: Likewise.
+ * config/arc/arc.c: Likewise.
+ * config/arm/arm.c: Likewise.
+ * config/avr/avr.c: Likewise.
+ * config/bfin/bfin.c: Likewise.
+ * config/c6x/c6x.c: Likewise.
+ * config/cr16/cr16.c: Likewise.
+ * config/cris/cris.c: Likewise.
+ * config/darwin.c: Likewise.
+ * config/epiphany/epiphany.c: Likewise.
+ * config/fr30/fr30.c: Likewise.
+ * config/frv/frv.c: Likewise.
+ * config/ft32/ft32.c: Likewise.
+ * config/h8300/h8300.c: Likewise.
+ * config/i386/winnt.c: Likewise.
+ * config/ia64/ia64.c: Likewise.
+ * config/iq2000/iq2000.c: Likewise.
+ * config/lm32/lm32.c: Likewise.
+ * config/m32c/m32c.c: Likewise.
+ * config/m32r/m32r.c: Likewise.
+ * config/m68k/m68k.c: Likewise.
+ * config/mcore/mcore.c: Likewise.
+ * config/microblaze/microblaze.c: Likewise.
+ * config/mips/mips.c: Likewise.
+ * config/mmix/mmix.c: Likewise.
+ * config/mn10300/mn10300.c: Likewise.
+ * config/moxie/moxie.c: Likewise.
+ * config/msp430/msp430.c: Likewise.
+ * config/nds32/nds32-isr.c: Likewise.
+ * config/nds32/nds32.c: Likewise.
+ * config/nios2/nios2.c: Likewise.
+ * config/nvptx/nvptx.c: Likewise.
+ * config/pa/pa.c: Likewise.
+ * config/pdp11/pdp11.c: Likewise.
+ * config/powerpcspe/powerpcspe.c: Likewise.
+ * config/riscv/riscv.c: Likewise.
+ * config/rl78/rl78.c: Likewise.
+ * config/rx/rx.c: Likewise.
+ * config/s390/s390.c: Likewise.
+ * config/sh/sh.c: Likewise.
+ * config/sol2.c: Likewise.
+ * config/sparc/sparc.c: Likewise.
+ * config/spu/spu.c: Likewise.
+ * config/stormy16/stormy16.c: Likewise.
+ * config/tilegx/tilegx.c: Likewise.
+ * config/tilepro/tilepro.c: Likewise.
+ * config/v850/v850.c: Likewise.
+ * config/vax/vax.c: Likewise.
+ * config/visium/visium.c: Likewise.
+ * config/xtensa/xtensa.c: Likewise.
+
2017-08-07 Michael Meissner <meissner@linux.vnet.ibm.com>
PR target/81593
diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog
index dda51d423b633a605bdf1a8a731454cd76b4183b..b0b7cf351c3003d16cdab3c402c69f317f45333f 100644
--- a/gcc/ada/ChangeLog
+++ b/gcc/ada/ChangeLog
@@ -1,3 +1,7 @@
+2017-08-08 Martin Liska <mliska@suse.cz>
+
+ * gcc-interface/trans.c: Include header files.
+
2017-07-29 Jakub Jelinek <jakub@redhat.com>
* gcc-interface/utils.c (gnat_write_global_declarations): Pass false
diff --git a/gcc/ada/gcc-interface/trans.c b/gcc/ada/gcc-interface/trans.c
index 7844bd7c5a8c69fbdec88c329b8991e9b750c49d..67044b7b5748c38565939edc665478708130768c 100644
--- a/gcc/ada/gcc-interface/trans.c
+++ b/gcc/ada/gcc-interface/trans.c
@@ -46,6 +46,8 @@
#include "gimplify.h"
#include "opts.h"
#include "common/common-target.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "ada.h"
#include "adadecode.h"
diff --git a/gcc/asan.c b/gcc/asan.c
index 5f9275f6425a1c29b11b2873edd599716c61f7dc..f83ca65ffdbb12e0bd65719ff833539332540e02 100644
--- a/gcc/asan.c
+++ b/gcc/asan.c
@@ -47,6 +47,8 @@ along with GCC; see the file COPYING3. If not see
#include "varasm.h"
#include "stor-layout.h"
#include "tree-iterator.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
#include "dojump.h"
#include "explow.h"
diff --git a/gcc/attribs.c b/gcc/attribs.c
index 05fa8ef8692867556300e63e5e239004373e4de2..faa0649e190d6ea36a2ae6d3ce65c268966b3781 100644
--- a/gcc/attribs.c
+++ b/gcc/attribs.c
@@ -942,3 +942,636 @@ is_function_default_version (const tree decl)
return (TREE_CODE (attr) == STRING_CST
&& strcmp (TREE_STRING_POINTER (attr), "default") == 0);
}
+
+/* Return a declaration like DDECL except that its DECL_ATTRIBUTES
+ is ATTRIBUTE. */
+
+tree
+build_decl_attribute_variant (tree ddecl, tree attribute)
+{
+ DECL_ATTRIBUTES (ddecl) = attribute;
+ return ddecl;
+}
+
+/* Return a type like TTYPE except that its TYPE_ATTRIBUTE
+ is ATTRIBUTE and its qualifiers are QUALS.
+
+ Record such modified types already made so we don't make duplicates. */
+
+tree
+build_type_attribute_qual_variant (tree ttype, tree attribute, int quals)
+{
+ if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
+ {
+ tree ntype;
+
+ /* Building a distinct copy of a tagged type is inappropriate; it
+ causes breakage in code that expects there to be a one-to-one
+ relationship between a struct and its fields.
+ build_duplicate_type is another solution (as used in
+ handle_transparent_union_attribute), but that doesn't play well
+ with the stronger C++ type identity model. */
+ if (TREE_CODE (ttype) == RECORD_TYPE
+ || TREE_CODE (ttype) == UNION_TYPE
+ || TREE_CODE (ttype) == QUAL_UNION_TYPE
+ || TREE_CODE (ttype) == ENUMERAL_TYPE)
+ {
+ warning (OPT_Wattributes,
+ "ignoring attributes applied to %qT after definition",
+ TYPE_MAIN_VARIANT (ttype));
+ return build_qualified_type (ttype, quals);
+ }
+
+ ttype = build_qualified_type (ttype, TYPE_UNQUALIFIED);
+ ntype = build_distinct_type_copy (ttype);
+
+ TYPE_ATTRIBUTES (ntype) = attribute;
+
+ hashval_t hash = type_hash_canon_hash (ntype);
+ ntype = type_hash_canon (hash, ntype);
+
+ /* If the target-dependent attributes make NTYPE different from
+ its canonical type, we will need to use structural equality
+ checks for this type. */
+ if (TYPE_STRUCTURAL_EQUALITY_P (ttype)
+ || !comp_type_attributes (ntype, ttype))
+ SET_TYPE_STRUCTURAL_EQUALITY (ntype);
+ else if (TYPE_CANONICAL (ntype) == ntype)
+ TYPE_CANONICAL (ntype) = TYPE_CANONICAL (ttype);
+
+ ttype = build_qualified_type (ntype, quals);
+ }
+ else if (TYPE_QUALS (ttype) != quals)
+ ttype = build_qualified_type (ttype, quals);
+
+ return ttype;
+}
+
+/* Compare two identifier nodes representing attributes.
+ Return true if they are the same, false otherwise. */
+
+static bool
+cmp_attrib_identifiers (const_tree attr1, const_tree attr2)
+{
+ /* Make sure we're dealing with IDENTIFIER_NODEs. */
+ gcc_checking_assert (TREE_CODE (attr1) == IDENTIFIER_NODE
+ && TREE_CODE (attr2) == IDENTIFIER_NODE);
+
+ /* Identifiers can be compared directly for equality. */
+ if (attr1 == attr2)
+ return true;
+
+ return cmp_attribs (IDENTIFIER_POINTER (attr1), IDENTIFIER_LENGTH (attr1),
+ IDENTIFIER_POINTER (attr2), IDENTIFIER_LENGTH (attr2));
+}
+
+/* Compare two constructor-element-type constants. Return 1 if the lists
+ are known to be equal; otherwise return 0. */
+
+static bool
+simple_cst_list_equal (const_tree l1, const_tree l2)
+{
+ while (l1 != NULL_TREE && l2 != NULL_TREE)
+ {
+ if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
+ return false;
+
+ l1 = TREE_CHAIN (l1);
+ l2 = TREE_CHAIN (l2);
+ }
+
+ return l1 == l2;
+}
+
+/* Check if "omp declare simd" attribute arguments, CLAUSES1 and CLAUSES2, are
+ the same. */
+
+static bool
+omp_declare_simd_clauses_equal (tree clauses1, tree clauses2)
+{
+ tree cl1, cl2;
+ for (cl1 = clauses1, cl2 = clauses2;
+ cl1 && cl2;
+ cl1 = OMP_CLAUSE_CHAIN (cl1), cl2 = OMP_CLAUSE_CHAIN (cl2))
+ {
+ if (OMP_CLAUSE_CODE (cl1) != OMP_CLAUSE_CODE (cl2))
+ return false;
+ if (OMP_CLAUSE_CODE (cl1) != OMP_CLAUSE_SIMDLEN)
+ {
+ if (simple_cst_equal (OMP_CLAUSE_DECL (cl1),
+ OMP_CLAUSE_DECL (cl2)) != 1)
+ return false;
+ }
+ switch (OMP_CLAUSE_CODE (cl1))
+ {
+ case OMP_CLAUSE_ALIGNED:
+ if (simple_cst_equal (OMP_CLAUSE_ALIGNED_ALIGNMENT (cl1),
+ OMP_CLAUSE_ALIGNED_ALIGNMENT (cl2)) != 1)
+ return false;
+ break;
+ case OMP_CLAUSE_LINEAR:
+ if (simple_cst_equal (OMP_CLAUSE_LINEAR_STEP (cl1),
+ OMP_CLAUSE_LINEAR_STEP (cl2)) != 1)
+ return false;
+ break;
+ case OMP_CLAUSE_SIMDLEN:
+ if (simple_cst_equal (OMP_CLAUSE_SIMDLEN_EXPR (cl1),
+ OMP_CLAUSE_SIMDLEN_EXPR (cl2)) != 1)
+ return false;
+ default:
+ break;
+ }
+ }
+ return true;
+}
+
+
+/* Compare two attributes for their value identity. Return true if the
+ attribute values are known to be equal; otherwise return false. */
+
+bool
+attribute_value_equal (const_tree attr1, const_tree attr2)
+{
+ if (TREE_VALUE (attr1) == TREE_VALUE (attr2))
+ return true;
+
+ if (TREE_VALUE (attr1) != NULL_TREE
+ && TREE_CODE (TREE_VALUE (attr1)) == TREE_LIST
+ && TREE_VALUE (attr2) != NULL_TREE
+ && TREE_CODE (TREE_VALUE (attr2)) == TREE_LIST)
+ {
+ /* Handle attribute format. */
+ if (is_attribute_p ("format", get_attribute_name (attr1)))
+ {
+ attr1 = TREE_VALUE (attr1);
+ attr2 = TREE_VALUE (attr2);
+ /* Compare the archetypes (printf/scanf/strftime/...). */
+ if (!cmp_attrib_identifiers (TREE_VALUE (attr1), TREE_VALUE (attr2)))
+ return false;
+ /* Archetypes are the same. Compare the rest. */
+ return (simple_cst_list_equal (TREE_CHAIN (attr1),
+ TREE_CHAIN (attr2)) == 1);
+ }
+ return (simple_cst_list_equal (TREE_VALUE (attr1),
+ TREE_VALUE (attr2)) == 1);
+ }
+
+ if ((flag_openmp || flag_openmp_simd)
+ && TREE_VALUE (attr1) && TREE_VALUE (attr2)
+ && TREE_CODE (TREE_VALUE (attr1)) == OMP_CLAUSE
+ && TREE_CODE (TREE_VALUE (attr2)) == OMP_CLAUSE)
+ return omp_declare_simd_clauses_equal (TREE_VALUE (attr1),
+ TREE_VALUE (attr2));
+
+ return (simple_cst_equal (TREE_VALUE (attr1), TREE_VALUE (attr2)) == 1);
+}
+
+/* Return 0 if the attributes for two types are incompatible, 1 if they
+ are compatible, and 2 if they are nearly compatible (which causes a
+ warning to be generated). */
+int
+comp_type_attributes (const_tree type1, const_tree type2)
+{
+ const_tree a1 = TYPE_ATTRIBUTES (type1);
+ const_tree a2 = TYPE_ATTRIBUTES (type2);
+ const_tree a;
+
+ if (a1 == a2)
+ return 1;
+ for (a = a1; a != NULL_TREE; a = TREE_CHAIN (a))
+ {
+ const struct attribute_spec *as;
+ const_tree attr;
+
+ as = lookup_attribute_spec (get_attribute_name (a));
+ if (!as || as->affects_type_identity == false)
+ continue;
+
+ attr = lookup_attribute (as->name, CONST_CAST_TREE (a2));
+ if (!attr || !attribute_value_equal (a, attr))
+ break;
+ }
+ if (!a)
+ {
+ for (a = a2; a != NULL_TREE; a = TREE_CHAIN (a))
+ {
+ const struct attribute_spec *as;
+
+ as = lookup_attribute_spec (get_attribute_name (a));
+ if (!as || as->affects_type_identity == false)
+ continue;
+
+ if (!lookup_attribute (as->name, CONST_CAST_TREE (a1)))
+ break;
+ /* We don't need to compare trees again, as we did this
+ already in first loop. */
+ }
+ /* All types - affecting identity - are equal, so
+ there is no need to call target hook for comparison. */
+ if (!a)
+ return 1;
+ }
+ if (lookup_attribute ("transaction_safe", CONST_CAST_TREE (a)))
+ return 0;
+ /* As some type combinations - like default calling-convention - might
+ be compatible, we have to call the target hook to get the final result. */
+ return targetm.comp_type_attributes (type1, type2);
+}
+
+/* Return a type like TTYPE except that its TYPE_ATTRIBUTE
+ is ATTRIBUTE.
+
+ Record such modified types already made so we don't make duplicates. */
+
+tree
+build_type_attribute_variant (tree ttype, tree attribute)
+{
+ return build_type_attribute_qual_variant (ttype, attribute,
+ TYPE_QUALS (ttype));
+}
+
+/* A variant of lookup_attribute() that can be used with an identifier
+ as the first argument, and where the identifier can be either
+ 'text' or '__text__'.
+
+ Given an attribute ATTR_IDENTIFIER, and a list of attributes LIST,
+ return a pointer to the attribute's list element if the attribute
+ is part of the list, or NULL_TREE if not found. If the attribute
+ appears more than once, this only returns the first occurrence; the
+ TREE_CHAIN of the return value should be passed back in if further
+ occurrences are wanted. ATTR_IDENTIFIER must be an identifier but
+ can be in the form 'text' or '__text__'. */
+static tree
+lookup_ident_attribute (tree attr_identifier, tree list)
+{
+ gcc_checking_assert (TREE_CODE (attr_identifier) == IDENTIFIER_NODE);
+
+ while (list)
+ {
+ gcc_checking_assert (TREE_CODE (get_attribute_name (list))
+ == IDENTIFIER_NODE);
+
+ if (cmp_attrib_identifiers (attr_identifier,
+ get_attribute_name (list)))
+ /* Found it. */
+ break;
+ list = TREE_CHAIN (list);
+ }
+
+ return list;
+}
+
+/* Remove any instances of attribute ATTR_NAME in LIST and return the
+ modified list. */
+
+tree
+remove_attribute (const char *attr_name, tree list)
+{
+ tree *p;
+ gcc_checking_assert (attr_name[0] != '_');
+
+ for (p = &list; *p;)
+ {
+ tree l = *p;
+
+ tree attr = get_attribute_name (l);
+ if (is_attribute_p (attr_name, attr))
+ *p = TREE_CHAIN (l);
+ else
+ p = &TREE_CHAIN (l);
+ }
+
+ return list;
+}
+
+/* Return an attribute list that is the union of a1 and a2. */
+
+tree
+merge_attributes (tree a1, tree a2)
+{
+ tree attributes;
+
+ /* Either one unset? Take the set one. */
+
+ if ((attributes = a1) == 0)
+ attributes = a2;
+
+ /* 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. */
+
+ if (list_length (a1) < list_length (a2))
+ attributes = a2, a2 = a1;
+
+ for (; a2 != 0; a2 = TREE_CHAIN (a2))
+ {
+ tree a;
+ for (a = lookup_ident_attribute (get_attribute_name (a2),
+ attributes);
+ a != NULL_TREE && !attribute_value_equal (a, a2);
+ a = lookup_ident_attribute (get_attribute_name (a2),
+ TREE_CHAIN (a)))
+ ;
+ if (a == NULL_TREE)
+ {
+ a1 = copy_node (a2);
+ TREE_CHAIN (a1) = attributes;
+ attributes = a1;
+ }
+ }
+ }
+ }
+ return attributes;
+}
+
+/* Given types T1 and T2, merge their attributes and return
+ the result. */
+
+tree
+merge_type_attributes (tree t1, tree t2)
+{
+ return merge_attributes (TYPE_ATTRIBUTES (t1),
+ TYPE_ATTRIBUTES (t2));
+}
+
+/* Given decls OLDDECL and NEWDECL, merge their attributes and return
+ the result. */
+
+tree
+merge_decl_attributes (tree olddecl, tree newdecl)
+{
+ return merge_attributes (DECL_ATTRIBUTES (olddecl),
+ DECL_ATTRIBUTES (newdecl));
+}
+
+#if TARGET_DLLIMPORT_DECL_ATTRIBUTES
+
+/* Specialization of merge_decl_attributes for various Windows targets.
+
+ This handles the following situation:
+
+ __declspec (dllimport) int foo;
+ int foo;
+
+ The second instance of `foo' nullifies the dllimport. */
+
+tree
+merge_dllimport_decl_attributes (tree old, tree new_tree)
+{
+ tree a;
+ int delete_dllimport_p = 1;
+
+ /* What we need to do here is remove from `old' dllimport if it doesn't
+ appear in `new'. dllimport behaves like extern: if a declaration is
+ marked dllimport and a definition appears later, then the object
+ is not dllimport'd. We also remove a `new' dllimport if the old list
+ contains dllexport: dllexport always overrides dllimport, regardless
+ of the order of declaration. */
+ if (!VAR_OR_FUNCTION_DECL_P (new_tree))
+ delete_dllimport_p = 0;
+ else if (DECL_DLLIMPORT_P (new_tree)
+ && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old)))
+ {
+ DECL_DLLIMPORT_P (new_tree) = 0;
+ warning (OPT_Wattributes, "%q+D already declared with dllexport "
+ "attribute: dllimport ignored", new_tree);
+ }
+ else if (DECL_DLLIMPORT_P (old) && !DECL_DLLIMPORT_P (new_tree))
+ {
+ /* Warn about overriding a symbol that has already been used, e.g.:
+ extern int __attribute__ ((dllimport)) foo;
+ int* bar () {return &foo;}
+ int foo;
+ */
+ if (TREE_USED (old))
+ {
+ warning (0, "%q+D redeclared without dllimport attribute "
+ "after being referenced with dll linkage", new_tree);
+ /* If we have used a variable's address with dllimport linkage,
+ keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the
+ decl may already have had TREE_CONSTANT computed.
+ We still remove the attribute so that assembler code refers
+ to '&foo rather than '_imp__foo'. */
+ if (VAR_P (old) && TREE_ADDRESSABLE (old))
+ DECL_DLLIMPORT_P (new_tree) = 1;
+ }
+
+ /* Let an inline definition silently override the external reference,
+ but otherwise warn about attribute inconsistency. */
+ else if (VAR_P (new_tree) || !DECL_DECLARED_INLINE_P (new_tree))
+ warning (OPT_Wattributes, "%q+D redeclared without dllimport "
+ "attribute: previous dllimport ignored", new_tree);
+ }
+ else
+ delete_dllimport_p = 0;
+
+ a = merge_attributes (DECL_ATTRIBUTES (old), DECL_ATTRIBUTES (new_tree));
+
+ if (delete_dllimport_p)
+ a = remove_attribute ("dllimport", a);
+
+ return a;
+}
+
+/* Handle a "dllimport" or "dllexport" attribute; arguments as in
+ struct attribute_spec.handler. */
+
+tree
+handle_dll_attribute (tree * pnode, tree name, tree args, int flags,
+ bool *no_add_attrs)
+{
+ tree node = *pnode;
+ bool is_dllimport;
+
+ /* These attributes may apply to structure and union types being created,
+ but otherwise should pass to the declaration involved. */
+ if (!DECL_P (node))
+ {
+ if (flags & ((int) ATTR_FLAG_DECL_NEXT | (int) ATTR_FLAG_FUNCTION_NEXT
+ | (int) ATTR_FLAG_ARRAY_NEXT))
+ {
+ *no_add_attrs = true;
+ return tree_cons (name, args, NULL_TREE);
+ }
+ if (TREE_CODE (node) == RECORD_TYPE
+ || TREE_CODE (node) == UNION_TYPE)
+ {
+ node = TYPE_NAME (node);
+ if (!node)
+ return NULL_TREE;
+ }
+ else
+ {
+ warning (OPT_Wattributes, "%qE attribute ignored",
+ name);
+ *no_add_attrs = true;
+ return NULL_TREE;
+ }
+ }
+
+ if (!VAR_OR_FUNCTION_DECL_P (node) && TREE_CODE (node) != TYPE_DECL)
+ {
+ *no_add_attrs = true;
+ warning (OPT_Wattributes, "%qE attribute ignored",
+ name);
+ return NULL_TREE;
+ }
+
+ if (TREE_CODE (node) == TYPE_DECL
+ && TREE_CODE (TREE_TYPE (node)) != RECORD_TYPE
+ && TREE_CODE (TREE_TYPE (node)) != UNION_TYPE)
+ {
+ *no_add_attrs = true;
+ warning (OPT_Wattributes, "%qE attribute ignored",
+ name);
+ return NULL_TREE;
+ }
+
+ is_dllimport = is_attribute_p ("dllimport", name);
+
+ /* Report error on dllimport ambiguities seen now before they cause
+ any damage. */
+ if (is_dllimport)
+ {
+ /* Honor any target-specific overrides. */
+ if (!targetm.valid_dllimport_attribute_p (node))
+ *no_add_attrs = true;
+
+ else if (TREE_CODE (node) == FUNCTION_DECL
+ && DECL_DECLARED_INLINE_P (node))
+ {
+ warning (OPT_Wattributes, "inline function %q+D declared as "
+ " dllimport: attribute ignored", node);
+ *no_add_attrs = true;
+ }
+ /* Like MS, treat definition of dllimported variables and
+ non-inlined functions on declaration as syntax errors. */
+ else if (TREE_CODE (node) == FUNCTION_DECL && DECL_INITIAL (node))
+ {
+ error ("function %q+D definition is marked dllimport", node);
+ *no_add_attrs = true;
+ }
+
+ else if (VAR_P (node))
+ {
+ if (DECL_INITIAL (node))
+ {
+ error ("variable %q+D definition is marked dllimport",
+ node);
+ *no_add_attrs = true;
+ }
+
+ /* `extern' needn't be specified with dllimport.
+ Specify `extern' now and hope for the best. Sigh. */
+ DECL_EXTERNAL (node) = 1;
+ /* Also, implicitly give dllimport'd variables declared within
+ a function global scope, unless declared static. */
+ if (current_function_decl != NULL_TREE && !TREE_STATIC (node))
+ TREE_PUBLIC (node) = 1;
+ }
+
+ if (*no_add_attrs == false)
+ DECL_DLLIMPORT_P (node) = 1;
+ }
+ else if (TREE_CODE (node) == FUNCTION_DECL
+ && DECL_DECLARED_INLINE_P (node)
+ && flag_keep_inline_dllexport)
+ /* An exported function, even if inline, must be emitted. */
+ DECL_EXTERNAL (node) = 0;
+
+ /* Report error if symbol is not accessible at global scope. */
+ if (!TREE_PUBLIC (node) && VAR_OR_FUNCTION_DECL_P (node))
+ {
+ error ("external linkage required for symbol %q+D because of "
+ "%qE attribute", node, name);
+ *no_add_attrs = true;
+ }
+
+ /* A dllexport'd entity must have default visibility so that other
+ program units (shared libraries or the main executable) can see
+ it. A dllimport'd entity must have default visibility so that
+ the linker knows that undefined references within this program
+ unit can be resolved by the dynamic linker. */
+ if (!*no_add_attrs)
+ {
+ if (DECL_VISIBILITY_SPECIFIED (node)
+ && DECL_VISIBILITY (node) != VISIBILITY_DEFAULT)
+ error ("%qE implies default visibility, but %qD has already "
+ "been declared with a different visibility",
+ name, node);
+ DECL_VISIBILITY (node) = VISIBILITY_DEFAULT;
+ DECL_VISIBILITY_SPECIFIED (node) = 1;
+ }
+
+ return NULL_TREE;
+}
+
+#endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES */
+
+/* Given two lists of attributes, return true if list l2 is
+ equivalent to l1. */
+
+int
+attribute_list_equal (const_tree l1, const_tree l2)
+{
+ if (l1 == l2)
+ return 1;
+
+ return attribute_list_contained (l1, l2)
+ && attribute_list_contained (l2, l1);
+}
+
+/* Given two lists of attributes, return true if list L2 is
+ completely contained within L1. */
+/* ??? This would be faster if attribute names were stored in a canonicalized
+ form. Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
+ must be used to show these elements are equivalent (which they are). */
+/* ??? It's not clear that attributes with arguments will always be handled
+ correctly. */
+
+int
+attribute_list_contained (const_tree l1, const_tree l2)
+{
+ const_tree t1, t2;
+
+ /* First check the obvious, maybe the lists are identical. */
+ if (l1 == l2)
+ return 1;
+
+ /* Maybe the lists are similar. */
+ for (t1 = l1, t2 = l2;
+ t1 != 0 && t2 != 0
+ && get_attribute_name (t1) == get_attribute_name (t2)
+ && TREE_VALUE (t1) == TREE_VALUE (t2);
+ t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
+ ;
+
+ /* Maybe the lists are equal. */
+ if (t1 == 0 && t2 == 0)
+ return 1;
+
+ for (; t2 != 0; t2 = TREE_CHAIN (t2))
+ {
+ const_tree attr;
+ /* This CONST_CAST is okay because lookup_attribute does not
+ modify its argument and the return value is assigned to a
+ const_tree. */
+ for (attr = lookup_ident_attribute (get_attribute_name (t2),
+ CONST_CAST_TREE (l1));
+ attr != NULL_TREE && !attribute_value_equal (t2, attr);
+ attr = lookup_ident_attribute (get_attribute_name (t2),
+ TREE_CHAIN (attr)))
+ ;
+
+ if (attr == NULL_TREE)
+ return 0;
+ }
+
+ return 1;
+}
diff --git a/gcc/attribs.h b/gcc/attribs.h
index d4a790bb75346770847c27c038070151204633f1..06e6993e95820b12a0cb7a32a59b9ac47881b56e 100644
--- a/gcc/attribs.h
+++ b/gcc/attribs.h
@@ -47,6 +47,46 @@ extern char *make_unique_name (tree, const char *, bool);
extern tree make_dispatcher_decl (const tree);
extern bool is_function_default_version (const tree);
+/* Return a type like TTYPE except that its TYPE_ATTRIBUTES
+ is ATTRIBUTE.
+
+ Such modified types already made are recorded so that duplicates
+ are not made. */
+
+extern tree build_type_attribute_variant (tree, tree);
+extern tree build_decl_attribute_variant (tree, tree);
+extern tree build_type_attribute_qual_variant (tree, tree, int);
+
+extern bool attribute_value_equal (const_tree, const_tree);
+
+/* Return 0 if the attributes for two types are incompatible, 1 if they
+ are compatible, and 2 if they are nearly compatible (which causes a
+ warning to be generated). */
+extern int comp_type_attributes (const_tree, const_tree);
+
+/* Default versions of target-overridable functions. */
+extern tree merge_decl_attributes (tree, tree);
+extern tree merge_type_attributes (tree, tree);
+
+/* Remove any instances of attribute ATTR_NAME in LIST and return the
+ modified list. */
+
+extern tree remove_attribute (const char *, tree);
+
+/* Given two attributes lists, return a list of their union. */
+
+extern tree merge_attributes (tree, tree);
+
+/* Given two Windows decl attributes lists, possibly including
+ dllimport, return a list of their union . */
+extern tree merge_dllimport_decl_attributes (tree, tree);
+
+/* Handle a "dllimport" or "dllexport" attribute. */
+extern tree handle_dll_attribute (tree *, tree, tree, int, bool *);
+
+extern int attribute_list_equal (const_tree, const_tree);
+extern int attribute_list_contained (const_tree, const_tree);
+
/* For a given IDENTIFIER_NODE, strip leading and trailing '_' characters
so that we have a canonical form of attribute names. */
@@ -90,4 +130,77 @@ is_attribute_p (const char *attr_name, const_tree ident)
IDENTIFIER_POINTER (ident), IDENTIFIER_LENGTH (ident));
}
+/* Given an attribute name ATTR_NAME and a list of attributes LIST,
+ return a pointer to the attribute's list element if the attribute
+ is part of the list, or NULL_TREE if not found. If the attribute
+ appears more than once, this only returns the first occurrence; the
+ TREE_CHAIN of the return value should be passed back in if further
+ occurrences are wanted. ATTR_NAME must be in the form 'text' (not
+ '__text__'). */
+
+static inline tree
+lookup_attribute (const char *attr_name, tree list)
+{
+ gcc_checking_assert (attr_name[0] != '_');
+ /* In most cases, list is NULL_TREE. */
+ if (list == NULL_TREE)
+ return NULL_TREE;
+ else
+ {
+ size_t attr_len = strlen (attr_name);
+ /* Do the strlen() before calling the out-of-line implementation.
+ In most cases attr_name is a string constant, and the compiler
+ will optimize the strlen() away. */
+ while (list)
+ {
+ tree attr = get_attribute_name (list);
+ size_t ident_len = IDENTIFIER_LENGTH (attr);
+ if (cmp_attribs (attr_name, attr_len, IDENTIFIER_POINTER (attr),
+ ident_len))
+ break;
+ list = TREE_CHAIN (list);
+ }
+
+ return list;
+ }
+}
+
+/* Given an attribute name ATTR_NAME and a list of attributes LIST,
+ return a pointer to the attribute's list first element if the attribute
+ starts with ATTR_NAME. ATTR_NAME must be in the form 'text' (not
+ '__text__'). */
+
+static inline tree
+lookup_attribute_by_prefix (const char *attr_name, tree list)
+{
+ gcc_checking_assert (attr_name[0] != '_');
+ /* In most cases, list is NULL_TREE. */
+ if (list == NULL_TREE)
+ return NULL_TREE;
+ else
+ {
+ size_t attr_len = strlen (attr_name);
+ while (list)
+ {
+ size_t ident_len = IDENTIFIER_LENGTH (get_attribute_name (list));
+
+ if (attr_len > ident_len)
+ {
+ list = TREE_CHAIN (list);
+ continue;
+ }
+
+ const char *p = IDENTIFIER_POINTER (get_attribute_name (list));
+ gcc_checking_assert (attr_len == 0 || p[0] != '_');
+
+ if (strncmp (attr_name, p, attr_len) == 0)
+ break;
+
+ list = TREE_CHAIN (list);
+ }
+
+ return list;
+ }
+}
+
#endif // GCC_ATTRIBS_H
diff --git a/gcc/bb-reorder.c b/gcc/bb-reorder.c
index 3dbae819b1bf8bad5c03add2332d584a955cc490..4dad298fe596d103f6ad4289bc2426d3b8513a66 100644
--- a/gcc/bb-reorder.c
+++ b/gcc/bb-reorder.c
@@ -115,6 +115,8 @@
#include "bb-reorder.h"
#include "except.h"
#include "fibonacci_heap.h"
+#include "stringpool.h"
+#include "attribs.h"
/* The number of rounds. In most cases there will only be 4 rounds, but
when partitioning hot and cold basic blocks into separate sections of
diff --git a/gcc/builtins.c b/gcc/builtins.c
index 016f68d2cb610e8568d6709fd11878b84fca4db4..fa0f89c8f336f20051a88a99532a2e6fb3fba7c9 100644
--- a/gcc/builtins.c
+++ b/gcc/builtins.c
@@ -60,6 +60,8 @@ along with GCC; see the file COPYING3. If not see
#include "langhooks.h"
#include "value-prof.h"
#include "builtins.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
#include "cilk.h"
#include "tree-chkp.h"
diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog
index c27da8a3ed20e8621ca32155320804ed1e1d99fc..d1cf80e42cdd5a505f82ca03351a312f90f81833 100644
--- a/gcc/c-family/ChangeLog
+++ b/gcc/c-family/ChangeLog
@@ -1,3 +1,9 @@
+2017-08-08 Martin Liska <mliska@suse.cz>
+
+ * c-ada-spec.c: Include header files.
+ * c-ubsan.c: Likewise.
+ * c-warn.c: Likewise.
+
2017-08-07 Jakub Jelinek <jakub@redhat.com>
PR c/69389
diff --git a/gcc/c-family/c-ada-spec.c b/gcc/c-family/c-ada-spec.c
index 6c050fb673b9942f776248bda1999148e1d44ce3..0cd3d55b55b0f4a6343190dbfccaddea7e2208fc 100644
--- a/gcc/c-family/c-ada-spec.c
+++ b/gcc/c-family/c-ada-spec.c
@@ -28,6 +28,8 @@ along with GCC; see the file COPYING3. If not see
#include "fold-const.h"
#include "c-pragma.h"
#include "cpp-id-data.h"
+#include "stringpool.h"
+#include "attribs.h"
/* Local functions, macros and variables. */
static int dump_generic_ada_node (pretty_printer *, tree, tree, int, int,
diff --git a/gcc/c-family/c-ubsan.c b/gcc/c-family/c-ubsan.c
index 541b53009c2bb64c76513dcae3e619a6e055bb40..b1386db9c258570e10cb051f0ca488eb85ab051b 100644
--- a/gcc/c-family/c-ubsan.c
+++ b/gcc/c-family/c-ubsan.c
@@ -25,10 +25,12 @@ along with GCC; see the file COPYING3. If not see
#include "c-family/c-common.h"
#include "ubsan.h"
#include "c-family/c-ubsan.h"
-#include "asan.h"
#include "stor-layout.h"
#include "builtins.h"
#include "gimplify.h"
+#include "stringpool.h"
+#include "attribs.h"
+#include "asan.h"
/* Instrument division by zero and INT_MIN / -1. If not instrumenting,
return NULL_TREE. */
diff --git a/gcc/c-family/c-warn.c b/gcc/c-family/c-warn.c
index e970ab2a00d200efaacf50529d93cc418b032bfb..9c3073444cf50860f1b331ad2c09b06825857914 100644
--- a/gcc/c-family/c-warn.c
+++ b/gcc/c-family/c-warn.c
@@ -28,6 +28,8 @@ along with GCC; see the file COPYING3. If not see
#include "tm_p.h"
#include "diagnostic.h"
#include "intl.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
#include "gcc-rich-location.h"
#include "gimplify.h"
diff --git a/gcc/c/ChangeLog b/gcc/c/ChangeLog
index 06dd1b7f100fe0e7c9c097c8008660d996d61b62..d29f4444c817a050d9ee9bae6b01a6d70e7c4a4e 100644
--- a/gcc/c/ChangeLog
+++ b/gcc/c/ChangeLog
@@ -1,3 +1,8 @@
+2017-08-08 Martin Liska <mliska@suse.cz>
+
+ * c-convert.c: Include header files.
+ * c-typeck.c: Likewise.
+
2017-08-07 Martin Liska <mliska@suse.cz>
* c-parser.c (c_parser_attributes): Canonicalize name of an
diff --git a/gcc/c/c-convert.c b/gcc/c/c-convert.c
index bc649178f4c5d60eacf696fc3224e3808bf6a0ab..8752132d175bdc0a73bb6b799873219ce22af21c 100644
--- a/gcc/c/c-convert.c
+++ b/gcc/c/c-convert.c
@@ -31,6 +31,8 @@ along with GCC; see the file COPYING3. If not see
#include "convert.h"
#include "langhooks.h"
#include "ubsan.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
/* Change of width--truncation and extension of integers or reals--
diff --git a/gcc/c/c-typeck.c b/gcc/c/c-typeck.c
index 71d0135018619bafa0b118dd22dcc24ca6c223da..321c953e7f1367bbef4864b50b36043b77b6d59a 100644
--- a/gcc/c/c-typeck.c
+++ b/gcc/c/c-typeck.c
@@ -50,6 +50,8 @@ along with GCC; see the file COPYING3. If not see
#include "gomp-constants.h"
#include "spellcheck-tree.h"
#include "gcc-rich-location.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
/* Possible cases of implicit bad conversions. Used to select
diff --git a/gcc/calls.c b/gcc/calls.c
index 6405f482e918c36685ffa87443b9d0e8420f0942..7599928c7cb0eeb3d372fadeac571e2c47bec1c9 100644
--- a/gcc/calls.c
+++ b/gcc/calls.c
@@ -52,6 +52,8 @@ along with GCC; see the file COPYING3. If not see
#include "tree-ssanames.h"
#include "rtl-chkp.h"
#include "intl.h"
+#include "stringpool.h"
+#include "attribs.h"
/* Like PREFERRED_STACK_BOUNDARY but in units of bytes, not bits. */
#define STACK_BYTES (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT)
diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c
index c9d8118ed4526d9a307d5d3c25883b1c6cb60620..7f0130d0365f885fe04e01def7d6b9163f37837d 100644
--- a/gcc/cfgexpand.c
+++ b/gcc/cfgexpand.c
@@ -68,6 +68,8 @@ along with GCC; see the file COPYING3. If not see
#include "tree-outof-ssa.h"
#include "cfgloop.h"
#include "insn-attr.h" /* For INSN_SCHEDULING. */
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
#include "tree-ssa-address.h"
#include "output.h"
diff --git a/gcc/cgraph.c b/gcc/cgraph.c
index d7c9ba617955122de611c43a8dbadc0280be580a..c6ab7e38ff6a1a4f699a0df688638a737f4d6af3 100644
--- a/gcc/cgraph.c
+++ b/gcc/cgraph.c
@@ -61,6 +61,8 @@ along with GCC; see the file COPYING3. If not see
#include "tree-chkp.h"
#include "context.h"
#include "gimplify.h"
+#include "stringpool.h"
+#include "attribs.h"
/* FIXME: Only for PROP_loops, but cgraph shouldn't have to know about this. */
#include "tree-pass.h"
diff --git a/gcc/cgraphunit.c b/gcc/cgraphunit.c
index 6072c567bc36660cbf8b6f4d5fcba42544cef751..e8cc765095d44f22366e11f1c21c084ce70a85df 100644
--- a/gcc/cgraphunit.c
+++ b/gcc/cgraphunit.c
@@ -204,6 +204,8 @@ along with GCC; see the file COPYING3. If not see
#include "dbgcnt.h"
#include "tree-chkp.h"
#include "lto-section-names.h"
+#include "stringpool.h"
+#include "attribs.h"
/* Queue of cgraph nodes scheduled to be added into cgraph. This is a
secondary queue used during optimization to accommodate passes that
diff --git a/gcc/config/aarch64/aarch64.c b/gcc/config/aarch64/aarch64.c
index 79a396ec674d0138c81083b6c5b9b7bf758802f4..28c4e0e64766060851c0c7cd6b86995fae25353d 100644
--- a/gcc/config/aarch64/aarch64.c
+++ b/gcc/config/aarch64/aarch64.c
@@ -33,6 +33,7 @@
#include "df.h"
#include "tm_p.h"
#include "stringpool.h"
+#include "attribs.h"
#include "optabs.h"
#include "regs.h"
#include "emit-rtl.h"
diff --git a/gcc/config/alpha/alpha.c b/gcc/config/alpha/alpha.c
index 341ec20d340f849edd129d64a59cc1bb023541e4..e13c5f9fc5738fcadbf0cbdf6e6c66d80f392315 100644
--- a/gcc/config/alpha/alpha.c
+++ b/gcc/config/alpha/alpha.c
@@ -26,6 +26,8 @@ along with GCC; see the file COPYING3. If not see
#include "target.h"
#include "rtl.h"
#include "tree.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "memmodel.h"
#include "gimple.h"
#include "df.h"
diff --git a/gcc/config/arc/arc.c b/gcc/config/arc/arc.c
index be5f1bd200378d3abd936944463f98b23232555f..057f8756fba885df3af7ccb9f5620c7e6239ece7 100644
--- a/gcc/config/arc/arc.c
+++ b/gcc/config/arc/arc.c
@@ -40,6 +40,7 @@ along with GCC; see the file COPYING3. If not see
#include "df.h"
#include "tm_p.h"
#include "stringpool.h"
+#include "attribs.h"
#include "optabs.h"
#include "regs.h"
#include "emit-rtl.h"
diff --git a/gcc/config/arm/arm.c b/gcc/config/arm/arm.c
index 25677d19e20529971716f66366e2154e89483492..fa3e2fa6c765674bc56aed0352507daa39e84a3c 100644
--- a/gcc/config/arm/arm.c
+++ b/gcc/config/arm/arm.c
@@ -32,6 +32,7 @@
#include "df.h"
#include "tm_p.h"
#include "stringpool.h"
+#include "attribs.h"
#include "optabs.h"
#include "regs.h"
#include "emit-rtl.h"
diff --git a/gcc/config/avr/avr.c b/gcc/config/avr/avr.c
index 1f333ccc1b2dc25010e61b16a8772100bfdb41ac..e453bfb681468affd01ff40ab333505ad451292a 100644
--- a/gcc/config/avr/avr.c
+++ b/gcc/config/avr/avr.c
@@ -26,6 +26,8 @@
#include "target.h"
#include "rtl.h"
#include "tree.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "cgraph.h"
#include "c-family/c-common.h"
#include "cfghooks.h"
diff --git a/gcc/config/bfin/bfin.c b/gcc/config/bfin/bfin.c
index 9fe90fc37b4496f9172bed086151e6b7356f4bff..f04fe8747777dab061820b922284b267fa3c7368 100644
--- a/gcc/config/bfin/bfin.c
+++ b/gcc/config/bfin/bfin.c
@@ -25,6 +25,8 @@
#include "target.h"
#include "rtl.h"
#include "tree.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "cfghooks.h"
#include "df.h"
#include "memmodel.h"
diff --git a/gcc/config/c6x/c6x.c b/gcc/config/c6x/c6x.c
index 4529fd44aae5c867ad13a78f2dfc748255ec2601..a7083c12898b2de9c6ab86759dea535d30b00132 100644
--- a/gcc/config/c6x/c6x.c
+++ b/gcc/config/c6x/c6x.c
@@ -32,6 +32,7 @@
#include "memmodel.h"
#include "tm_p.h"
#include "stringpool.h"
+#include "attribs.h"
#include "optabs.h"
#include "regs.h"
#include "emit-rtl.h"
diff --git a/gcc/config/cr16/cr16.c b/gcc/config/cr16/cr16.c
index 93edd232af25b2717ff61a8133f66755098cd355..ab6ef7adf1d6c3bd5026a09f2b79fc69fe85cf2a 100644
--- a/gcc/config/cr16/cr16.c
+++ b/gcc/config/cr16/cr16.c
@@ -25,6 +25,8 @@
#include "target.h"
#include "rtl.h"
#include "tree.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "df.h"
#include "memmodel.h"
#include "tm_p.h"
diff --git a/gcc/config/cris/cris.c b/gcc/config/cris/cris.c
index 8c134a6bc8b205e90d212f4cc73086c74579e951..b57881ac04e8d0a291fbe6b0be3afbded3d75a34 100644
--- a/gcc/config/cris/cris.c
+++ b/gcc/config/cris/cris.c
@@ -25,6 +25,8 @@ along with GCC; see the file COPYING3. If not see
#include "target.h"
#include "rtl.h"
#include "tree.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "cfghooks.h"
#include "df.h"
#include "memmodel.h"
diff --git a/gcc/config/darwin.c b/gcc/config/darwin.c
index 9a8cf31d400bd50360b8c20bc1a73761383c1d2e..949db25c6500345bc66856a1ce9280143200fd71 100644
--- a/gcc/config/darwin.c
+++ b/gcc/config/darwin.c
@@ -31,6 +31,7 @@ along with GCC; see the file COPYING3. If not see
#include "memmodel.h"
#include "tm_p.h"
#include "stringpool.h"
+#include "attribs.h"
#include "insn-config.h"
#include "emit-rtl.h"
#include "cgraph.h"
diff --git a/gcc/config/epiphany/epiphany.c b/gcc/config/epiphany/epiphany.c
index b9ec0f40d12ab4ac78091535d6945c146f105d9a..4e27557d3ce9803f0551ada05d6d6203aa472c25 100644
--- a/gcc/config/epiphany/epiphany.c
+++ b/gcc/config/epiphany/epiphany.c
@@ -29,6 +29,7 @@ along with GCC; see the file COPYING3. If not see
#include "memmodel.h"
#include "tm_p.h"
#include "stringpool.h"
+#include "attribs.h"
#include "optabs.h"
#include "emit-rtl.h"
#include "recog.h"
diff --git a/gcc/config/fr30/fr30.c b/gcc/config/fr30/fr30.c
index 42bec9f733c2bb8197cfeb8e5c603af2575f5367..d83b2f31daa6a02cada95b776a9078fd863ea4f9 100644
--- a/gcc/config/fr30/fr30.c
+++ b/gcc/config/fr30/fr30.c
@@ -27,6 +27,8 @@
#include "target.h"
#include "rtl.h"
#include "tree.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "df.h"
#include "memmodel.h"
#include "emit-rtl.h"
diff --git a/gcc/config/frv/frv.c b/gcc/config/frv/frv.c
index c571d63f2c667807635b4714f9c92b49bceb3953..1cdbaa81c8de9ae8c7e79eb3da8b8757c92e1281 100644
--- a/gcc/config/frv/frv.c
+++ b/gcc/config/frv/frv.c
@@ -28,6 +28,7 @@ along with GCC; see the file COPYING3. If not see
#include "memmodel.h"
#include "tm_p.h"
#include "stringpool.h"
+#include "attribs.h"
#include "optabs.h"
#include "regs.h"
#include "emit-rtl.h"
diff --git a/gcc/config/ft32/ft32.c b/gcc/config/ft32/ft32.c
index db0365e92c1fadc9c1f272f701bc21a9c71a31dd..78c5edc8f098656a4776429056bd2fd057f3cd9a 100644
--- a/gcc/config/ft32/ft32.c
+++ b/gcc/config/ft32/ft32.c
@@ -25,6 +25,8 @@
#include "target.h"
#include "rtl.h"
#include "tree.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "df.h"
#include "memmodel.h"
#include "tm_p.h"
diff --git a/gcc/config/h8300/h8300.c b/gcc/config/h8300/h8300.c
index acdededeccc7e43598294ee47494b448776a8fa1..0e0bb57768d4f3d976ed0223aec24fe4cab69709 100644
--- a/gcc/config/h8300/h8300.c
+++ b/gcc/config/h8300/h8300.c
@@ -30,6 +30,7 @@ along with GCC; see the file COPYING3. If not see
#include "memmodel.h"
#include "tm_p.h"
#include "stringpool.h"
+#include "attribs.h"
#include "optabs.h"
#include "regs.h"
#include "emit-rtl.h"
diff --git a/gcc/config/i386/winnt.c b/gcc/config/i386/winnt.c
index 8272c7fddc1ff2aa0bc92b39aae35e753fba74d1..405f74a75974cd8cf43bd401912bd4ca62642534 100644
--- a/gcc/config/i386/winnt.c
+++ b/gcc/config/i386/winnt.c
@@ -30,6 +30,7 @@ along with GCC; see the file COPYING3. If not see
#include "memmodel.h"
#include "tm_p.h"
#include "stringpool.h"
+#include "attribs.h"
#include "emit-rtl.h"
#include "cgraph.h"
#include "lto-streamer.h"
diff --git a/gcc/config/ia64/ia64.c b/gcc/config/ia64/ia64.c
index c8e4c74bbdbe5cff7c2c0863a85b12a2290a2ca9..79c323f67ee9bfd2f8252632450b10ac430c0beb 100644
--- a/gcc/config/ia64/ia64.c
+++ b/gcc/config/ia64/ia64.c
@@ -31,6 +31,7 @@ along with GCC; see the file COPYING3. If not see
#include "df.h"
#include "tm_p.h"
#include "stringpool.h"
+#include "attribs.h"
#include "optabs.h"
#include "regs.h"
#include "emit-rtl.h"
diff --git a/gcc/config/iq2000/iq2000.c b/gcc/config/iq2000/iq2000.c
index 99abd76c5a69615e885d7ef4bda21db09e7767be..5a92164ef053f600653a0a34eae6148797aa846d 100644
--- a/gcc/config/iq2000/iq2000.c
+++ b/gcc/config/iq2000/iq2000.c
@@ -24,6 +24,8 @@ along with GCC; see the file COPYING3. If not see
#include "target.h"
#include "rtl.h"
#include "tree.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "df.h"
#include "memmodel.h"
#include "tm_p.h"
diff --git a/gcc/config/lm32/lm32.c b/gcc/config/lm32/lm32.c
index 2231412e56676e0861c10472bcac4ea3d5fd268b..214cc0ac5fde6d18056188e40db23495c0acb217 100644
--- a/gcc/config/lm32/lm32.c
+++ b/gcc/config/lm32/lm32.c
@@ -26,6 +26,8 @@
#include "target.h"
#include "rtl.h"
#include "tree.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "df.h"
#include "memmodel.h"
#include "tm_p.h"
diff --git a/gcc/config/m32r/m32r.c b/gcc/config/m32r/m32r.c
index 4efb4b9c28726ec3593116276709b095def23d1e..d7893d7550a0b21dfb55c3f468965bcdced5b0b3 100644
--- a/gcc/config/m32r/m32r.c
+++ b/gcc/config/m32r/m32r.c
@@ -28,6 +28,7 @@
#include "memmodel.h"
#include "tm_p.h"
#include "stringpool.h"
+#include "attribs.h"
#include "insn-config.h"
#include "emit-rtl.h"
#include "recog.h"
diff --git a/gcc/config/m68k/m68k.c b/gcc/config/m68k/m68k.c
index c14ce86d8102b41a891ca45ff7f2e2dbaf6f2fc5..89726655122e55f4c649db0fbeb48e3671c6c0b9 100644
--- a/gcc/config/m68k/m68k.c
+++ b/gcc/config/m68k/m68k.c
@@ -23,6 +23,8 @@ along with GCC; see the file COPYING3. If not see
#include "backend.h"
#include "cfghooks.h"
#include "tree.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "rtl.h"
#include "df.h"
#include "alias.h"
diff --git a/gcc/config/mcore/mcore.c b/gcc/config/mcore/mcore.c
index c4b7c4cf94f6635f049206bb20a6d2ddb6b757be..e67376fb6aa0956836013cdf5fee35f7ba71a2b1 100644
--- a/gcc/config/mcore/mcore.c
+++ b/gcc/config/mcore/mcore.c
@@ -28,6 +28,7 @@
#include "memmodel.h"
#include "tm_p.h"
#include "stringpool.h"
+#include "attribs.h"
#include "emit-rtl.h"
#include "diagnostic-core.h"
#include "stor-layout.h"
diff --git a/gcc/config/microblaze/microblaze.c b/gcc/config/microblaze/microblaze.c
index 15ceac0b346ddc756155fcb868593102dc557692..2cdd24056a5e4f052d71143f3b7e93b3fff3f38d 100644
--- a/gcc/config/microblaze/microblaze.c
+++ b/gcc/config/microblaze/microblaze.c
@@ -26,6 +26,8 @@
#include "target.h"
#include "rtl.h"
#include "tree.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "df.h"
#include "memmodel.h"
#include "tm_p.h"
diff --git a/gcc/config/mmix/mmix.c b/gcc/config/mmix/mmix.c
index 9849c19e0766b26e541093e766240d7ee5bec090..6ca2fd9441cadd162c3462498f642be17b51629e 100644
--- a/gcc/config/mmix/mmix.c
+++ b/gcc/config/mmix/mmix.c
@@ -25,6 +25,8 @@ along with GCC; see the file COPYING3. If not see
#include "target.h"
#include "rtl.h"
#include "tree.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "df.h"
#include "memmodel.h"
#include "tm_p.h"
diff --git a/gcc/config/mn10300/mn10300.c b/gcc/config/mn10300/mn10300.c
index 301207fa66a333983ca556e32ae36f9ac2fb0f17..f46caac7e94840e8af673cfedb5ba33123402335 100644
--- a/gcc/config/mn10300/mn10300.c
+++ b/gcc/config/mn10300/mn10300.c
@@ -25,6 +25,8 @@
#include "target.h"
#include "rtl.h"
#include "tree.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "cfghooks.h"
#include "cfgloop.h"
#include "df.h"
diff --git a/gcc/config/moxie/moxie.c b/gcc/config/moxie/moxie.c
index 70d6d7e2eaf47a4c1841ef40934059f3ac38e745..19cd83f519361a769b053b860a5fef22cbe577c1 100644
--- a/gcc/config/moxie/moxie.c
+++ b/gcc/config/moxie/moxie.c
@@ -25,6 +25,8 @@
#include "target.h"
#include "rtl.h"
#include "tree.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "df.h"
#include "regs.h"
#include "memmodel.h"
diff --git a/gcc/config/msp430/msp430.c b/gcc/config/msp430/msp430.c
index 6acab1e70cb6987ab4b52ff94b45af39c76d3b13..1ab79a722ed039e9e278edeaaace4fd163ac17f3 100644
--- a/gcc/config/msp430/msp430.c
+++ b/gcc/config/msp430/msp430.c
@@ -25,6 +25,8 @@
#include "target.h"
#include "rtl.h"
#include "tree.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "gimple-expr.h"
#include "df.h"
#include "memmodel.h"
diff --git a/gcc/config/nds32/nds32-isr.c b/gcc/config/nds32/nds32-isr.c
index 29e94d004c6ffa3eb76737c08c462e5745515570..7d7b9e27ca6c46603087bdb334526faa5a6df5be 100644
--- a/gcc/config/nds32/nds32-isr.c
+++ b/gcc/config/nds32/nds32-isr.c
@@ -27,6 +27,8 @@
#include "target.h"
#include "rtl.h"
#include "tree.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "diagnostic-core.h"
#include "output.h"
diff --git a/gcc/config/nds32/nds32.c b/gcc/config/nds32/nds32.c
index 705d223e496834a336cc56ec0fe9f1f928e52fb1..14310de86724dde5678254fb55a0b2e2f051b2f5 100644
--- a/gcc/config/nds32/nds32.c
+++ b/gcc/config/nds32/nds32.c
@@ -27,6 +27,8 @@
#include "target.h"
#include "rtl.h"
#include "tree.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "df.h"
#include "memmodel.h"
#include "tm_p.h"
diff --git a/gcc/config/nios2/nios2.c b/gcc/config/nios2/nios2.c
index 2fc9a080402fa6271d86b9769d342dfe6281d161..884b1dc367ee4a1113c25cb841dd60bf6754a7f3 100644
--- a/gcc/config/nios2/nios2.c
+++ b/gcc/config/nios2/nios2.c
@@ -27,6 +27,8 @@
#include "target.h"
#include "rtl.h"
#include "tree.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "df.h"
#include "memmodel.h"
#include "tm_p.h"
diff --git a/gcc/config/nvptx/nvptx.c b/gcc/config/nvptx/nvptx.c
index dddb9522dfae7c18c663e03816a06eb7cb2b977a..ffd50d781f032bde8c006c55be82d9392264ac10 100644
--- a/gcc/config/nvptx/nvptx.c
+++ b/gcc/config/nvptx/nvptx.c
@@ -62,6 +62,7 @@
#include "internal-fn.h"
#include "gimple-iterator.h"
#include "stringpool.h"
+#include "attribs.h"
#include "tree-vrp.h"
#include "tree-ssa-operands.h"
#include "tree-ssanames.h"
diff --git a/gcc/config/pa/pa.c b/gcc/config/pa/pa.c
index 2a78018650c24353c6db293d30256c0e89d3d24e..52f76cfd5f1955bc15c0061ea6a1577cc07a4dad 100644
--- a/gcc/config/pa/pa.c
+++ b/gcc/config/pa/pa.c
@@ -29,6 +29,7 @@ along with GCC; see the file COPYING3. If not see
#include "df.h"
#include "tm_p.h"
#include "stringpool.h"
+#include "attribs.h"
#include "optabs.h"
#include "regs.h"
#include "emit-rtl.h"
diff --git a/gcc/config/pdp11/pdp11.c b/gcc/config/pdp11/pdp11.c
index c2ce6e8abe5d9c09dcfe5ce859e1bc1dd6b7ed25..fbbb34390f4fc7de4b7119f4f51c8027f15c473c 100644
--- a/gcc/config/pdp11/pdp11.c
+++ b/gcc/config/pdp11/pdp11.c
@@ -25,6 +25,8 @@ along with GCC; see the file COPYING3. If not see
#include "target.h"
#include "rtl.h"
#include "tree.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "df.h"
#include "memmodel.h"
#include "tm_p.h"
diff --git a/gcc/config/powerpcspe/powerpcspe.c b/gcc/config/powerpcspe/powerpcspe.c
index b94afd5ca2e5e46a3565d4fe1bd20d80eb8b26e8..f2840894fc1b385762f39b372d17000c392034fd 100644
--- a/gcc/config/powerpcspe/powerpcspe.c
+++ b/gcc/config/powerpcspe/powerpcspe.c
@@ -31,6 +31,7 @@
#include "df.h"
#include "tm_p.h"
#include "stringpool.h"
+#include "attribs.h"
#include "expmed.h"
#include "optabs.h"
#include "regs.h"
diff --git a/gcc/config/riscv/riscv.c b/gcc/config/riscv/riscv.c
index 57b2edbcb4302727e424917926845a32962c3d8d..cbf2f79bc4d833a54cecb17448c55498bddbced7 100644
--- a/gcc/config/riscv/riscv.c
+++ b/gcc/config/riscv/riscv.c
@@ -31,6 +31,8 @@ along with GCC; see the file COPYING3. If not see
#include "output.h"
#include "alias.h"
#include "tree.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "varasm.h"
#include "stor-layout.h"
#include "calls.h"
diff --git a/gcc/config/rx/rx.c b/gcc/config/rx/rx.c
index 9d512b8959bbeef92b2e7cd39873f41f5249a367..daae27b404a5498f3e5f30782dd49bff6906d2ce 100644
--- a/gcc/config/rx/rx.c
+++ b/gcc/config/rx/rx.c
@@ -29,6 +29,8 @@
#include "target.h"
#include "rtl.h"
#include "tree.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "cfghooks.h"
#include "df.h"
#include "memmodel.h"
diff --git a/gcc/config/s390/s390.c b/gcc/config/s390/s390.c
index 9f422c88a99a3218a1562a48b1fa46df69761fc4..deced953d753812e397b8e4a31a7cef845c7fc33 100644
--- a/gcc/config/s390/s390.c
+++ b/gcc/config/s390/s390.c
@@ -35,6 +35,7 @@ along with GCC; see the file COPYING3. If not see
#include "memmodel.h"
#include "tm_p.h"
#include "stringpool.h"
+#include "attribs.h"
#include "expmed.h"
#include "optabs.h"
#include "regs.h"
diff --git a/gcc/config/sol2.c b/gcc/config/sol2.c
index cdabf24e24bcedfc8e2f84452b51386c96709e5b..b8ef3409942db66a9345d6cfa9ed54f9ccf94031 100644
--- a/gcc/config/sol2.c
+++ b/gcc/config/sol2.c
@@ -27,6 +27,7 @@ along with GCC; see the file COPYING3. If not see
#include "memmodel.h"
#include "tm_p.h"
#include "stringpool.h"
+#include "attribs.h"
#include "diagnostic-core.h"
#include "varasm.h"
#include "output.h"
diff --git a/gcc/config/sparc/sparc.c b/gcc/config/sparc/sparc.c
index 59761aac3106df84c021d5db5d5b3a363ccb8c58..d494ecf24103b2baea3452bb564f45f712ad4565 100644
--- a/gcc/config/sparc/sparc.c
+++ b/gcc/config/sparc/sparc.c
@@ -32,6 +32,7 @@ along with GCC; see the file COPYING3. If not see
#include "df.h"
#include "tm_p.h"
#include "stringpool.h"
+#include "attribs.h"
#include "expmed.h"
#include "optabs.h"
#include "regs.h"
diff --git a/gcc/config/spu/spu.c b/gcc/config/spu/spu.c
index ec20bd60e67787dd449a8548ec7f81ab250927ef..b6d03d7afd4c31c445955c45744e8a54ad69212e 100644
--- a/gcc/config/spu/spu.c
+++ b/gcc/config/spu/spu.c
@@ -28,6 +28,7 @@
#include "memmodel.h"
#include "tm_p.h"
#include "stringpool.h"
+#include "attribs.h"
#include "expmed.h"
#include "optabs.h"
#include "regs.h"
diff --git a/gcc/config/stormy16/stormy16.c b/gcc/config/stormy16/stormy16.c
index aee7742de89319c38d95838b4fcbe0e104cf9bbb..1a362524e8d24a8bfc9578579c4f30c4010f6739 100644
--- a/gcc/config/stormy16/stormy16.c
+++ b/gcc/config/stormy16/stormy16.c
@@ -25,6 +25,8 @@
#include "target.h"
#include "rtl.h"
#include "tree.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "gimple.h"
#include "df.h"
#include "memmodel.h"
diff --git a/gcc/config/tilegx/tilegx.c b/gcc/config/tilegx/tilegx.c
index dafb49daf1fd7fd92dd163b45e7a1bdca915b6b4..81559acfce001710738c8508685f4e921c394315 100644
--- a/gcc/config/tilegx/tilegx.c
+++ b/gcc/config/tilegx/tilegx.c
@@ -30,6 +30,7 @@
#include "df.h"
#include "tm_p.h"
#include "stringpool.h"
+#include "attribs.h"
#include "expmed.h"
#include "optabs.h"
#include "regs.h"
diff --git a/gcc/config/tilepro/tilepro.c b/gcc/config/tilepro/tilepro.c
index 80475b959eee5de1970d17c100030de674c36a3c..f03f0670ce9216f12eac987bf2e0fd19e98bc011 100644
--- a/gcc/config/tilepro/tilepro.c
+++ b/gcc/config/tilepro/tilepro.c
@@ -30,6 +30,7 @@
#include "memmodel.h"
#include "tm_p.h"
#include "stringpool.h"
+#include "attribs.h"
#include "expmed.h"
#include "optabs.h"
#include "regs.h"
diff --git a/gcc/config/vax/vax.c b/gcc/config/vax/vax.c
index 864eaeb853110a56111df9f16a893dc16f6b87f4..fad4849bc5a9e4974b9644203f08b19c0c87c284 100644
--- a/gcc/config/vax/vax.c
+++ b/gcc/config/vax/vax.c
@@ -24,6 +24,8 @@ along with GCC; see the file COPYING3. If not see
#include "target.h"
#include "rtl.h"
#include "tree.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "df.h"
#include "memmodel.h"
#include "tm_p.h"
diff --git a/gcc/config/visium/visium.c b/gcc/config/visium/visium.c
index e5d843e8d4c1e2bbac5d580546e78d9244103509..2c5b6734ae0ae5d3d9542945566bf2e4eaf4d601 100644
--- a/gcc/config/visium/visium.c
+++ b/gcc/config/visium/visium.c
@@ -30,6 +30,7 @@
#include "memmodel.h"
#include "tm_p.h"
#include "stringpool.h"
+#include "attribs.h"
#include "expmed.h"
#include "optabs.h"
#include "regs.h"
diff --git a/gcc/config/xtensa/xtensa.c b/gcc/config/xtensa/xtensa.c
index cf9a3a793885cf9599b2a8a14298fc0ad2e549a6..7c36e68b251f9cd2cd231f24a5eb9cde6cedf031 100644
--- a/gcc/config/xtensa/xtensa.c
+++ b/gcc/config/xtensa/xtensa.c
@@ -31,6 +31,7 @@ along with GCC; see the file COPYING3. If not see
#include "memmodel.h"
#include "tm_p.h"
#include "stringpool.h"
+#include "attribs.h"
#include "optabs.h"
#include "regs.h"
#include "emit-rtl.h"
diff --git a/gcc/convert.c b/gcc/convert.c
index 58d8054a724cfa690a69047c0ff3878820c09cac..b1a53afb81166c1e7b2dadec6888bfbd563fca15 100644
--- a/gcc/convert.c
+++ b/gcc/convert.c
@@ -33,6 +33,8 @@ along with GCC; see the file COPYING3. If not see
#include "langhooks.h"
#include "builtins.h"
#include "ubsan.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
#define maybe_fold_build1_loc(FOLD_P, LOC, CODE, TYPE, EXPR) \
diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 2e7f77a15d5e38312b242bdf3d32cf8b114362cf..23f6a1d2a7a1d2721fd61e40c6c217d91d0d14d5 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,14 @@
+2017-08-08 Martin Liska <mliska@suse.cz>
+
+ * call.c: Include header files.
+ * cp-gimplify.c: Likewise.
+ * cp-ubsan.c: Likewise.
+ * cvt.c: Likewise.
+ * init.c: Likewise.
+ * search.c: Likewise.
+ * semantics.c: Likewise.
+ * typeck.c: Likewise.
+
2017-08-07 Martin Liska <mliska@suse.cz>
* parser.c (cp_parser_gnu_attribute_list): Canonicalize name of an
diff --git a/gcc/cp/call.c b/gcc/cp/call.c
index f633fa5ad91f48b79b34bf2e8453b98305629287..fdd373116e0999f47f8bb90fec5511db1c272603 100644
--- a/gcc/cp/call.c
+++ b/gcc/cp/call.c
@@ -39,6 +39,8 @@ along with GCC; see the file COPYING3. If not see
#include "langhooks.h"
#include "c-family/c-objc.h"
#include "internal-fn.h"
+#include "stringpool.h"
+#include "attribs.h"
/* The various kinds of conversion. */
diff --git a/gcc/cp/cp-gimplify.c b/gcc/cp/cp-gimplify.c
index a9563b1a8cdff4dba169464290487bd0c67d3073..528e38816d368ad5da4f28136b3be07bb11bbb58 100644
--- a/gcc/cp/cp-gimplify.c
+++ b/gcc/cp/cp-gimplify.c
@@ -33,6 +33,8 @@ along with GCC; see the file COPYING3. If not see
#include "c-family/c-ubsan.h"
#include "cilk.h"
#include "cp-cilkplus.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
/* Forward declarations. */
diff --git a/gcc/cp/cp-ubsan.c b/gcc/cp/cp-ubsan.c
index 3be607c0a42edaa0efd00c26232a271b2a6f8ef8..cd2b60ad4889d0c97df6a9086d28f989de1b8064 100644
--- a/gcc/cp/cp-ubsan.c
+++ b/gcc/cp/cp-ubsan.c
@@ -23,6 +23,8 @@ along with GCC; see the file COPYING3. If not see
#include "coretypes.h"
#include "cp-tree.h"
#include "ubsan.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
/* Test if we should instrument vptr access. */
diff --git a/gcc/cp/cvt.c b/gcc/cp/cvt.c
index 631ff49673f0d659c704343ec6f1285641f3d338..fd758d3c2dc3614390d173c1369f07fd73d92a11 100644
--- a/gcc/cp/cvt.c
+++ b/gcc/cp/cvt.c
@@ -33,6 +33,8 @@ along with GCC; see the file COPYING3. If not see
#include "flags.h"
#include "intl.h"
#include "convert.h"
+#include "stringpool.h"
+#include "attribs.h"
static tree convert_to_pointer_force (tree, tree, tsubst_flags_t);
static tree build_type_conversion (tree, tree);
diff --git a/gcc/cp/init.c b/gcc/cp/init.c
index 3fe8f18b2a944cf3a827d1a0daea54fc31453228..81804112fd017954a6e3f4d96267aadd053a2ff2 100644
--- a/gcc/cp/init.c
+++ b/gcc/cp/init.c
@@ -30,6 +30,8 @@ along with GCC; see the file COPYING3. If not see
#include "gimplify.h"
#include "c-family/c-ubsan.h"
#include "intl.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
static bool begin_init_stmts (tree *, tree *);
diff --git a/gcc/cp/search.c b/gcc/cp/search.c
index 469a88b4c6f44ab3da2aa8af586926fbb127a53c..ced82da61178435e805e4ee8d1fd872ae524bea4 100644
--- a/gcc/cp/search.c
+++ b/gcc/cp/search.c
@@ -28,6 +28,8 @@ along with GCC; see the file COPYING3. If not see
#include "intl.h"
#include "toplev.h"
#include "spellcheck-tree.h"
+#include "stringpool.h"
+#include "attribs.h"
static int is_subobject_of_p (tree, tree);
static tree dfs_lookup_base (tree, void *);
diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
index f56d00fd8f388f21dc30789db04c09bfc94770d6..5401e78fbc6c801aa0429986a7478d03a96b9392 100644
--- a/gcc/cp/semantics.c
+++ b/gcc/cp/semantics.c
@@ -40,6 +40,8 @@ along with GCC; see the file COPYING3. If not see
#include "tree-iterator.h"
#include "omp-general.h"
#include "convert.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "gomp-constants.h"
#include "predict.h"
diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index a58de1d6206e8ca1afd32db584bb9480d9433a0f..074dae2dfee3325041b45e9b52e4bb357cb2acc1 100644
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -37,6 +37,8 @@ along with GCC; see the file COPYING3. If not see
#include "c-family/c-ubsan.h"
#include "params.h"
#include "gcc-rich-location.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
static tree cp_build_addr_expr_strict (tree, tsubst_flags_t);
diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index 4a3b3c1d0f494986c6d3f5c8e522dc7d53e61999..8e422279a61b730f598a8f287cd070cc54bd19b9 100644
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -92,6 +92,8 @@ along with GCC; see the file COPYING3. If not see
#include "tree-dfa.h"
#include "gdb/gdb-index.h"
#include "rtl-iter.h"
+#include "stringpool.h"
+#include "attribs.h"
static void dwarf2out_source_line (unsigned int, unsigned int, const char *,
int, bool);
diff --git a/gcc/final.c b/gcc/final.c
index 2a24f4fe10208306ab717cd1bad2774d7b6151ad..ad999f77fdd28810a676980f62cd9cd87d8bca8a 100644
--- a/gcc/final.c
+++ b/gcc/final.c
@@ -76,6 +76,8 @@ along with GCC; see the file COPYING3. If not see
#include "tree-ssa.h"
#include "cfgloop.h"
#include "params.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
#include "rtl-iter.h"
#include "print-rtl.h"
diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 8eaea6cce3a57d54df3e701530748654b679df33..5a118ca50a18cc3fbf03aadfad87b58d41c00e28 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -79,6 +79,8 @@ along with GCC; see the file COPYING3. If not see
#include "tree-vrp.h"
#include "tree-ssanames.h"
#include "selftest.h"
+#include "stringpool.h"
+#include "attribs.h"
/* Nonzero if we are folding constants inside an initializer; zero
otherwise. */
diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog
index e52bd0654aeb21d0baedfb9ca5ac664088240019..09138ab41adc66ea6812ad04312747cc766aca6e 100644
--- a/gcc/fortran/ChangeLog
+++ b/gcc/fortran/ChangeLog
@@ -1,3 +1,7 @@
+2017-08-08 Martin Liska <mliska@suse.cz>
+
+ * trans-types.c: Include header files.
+
2017-08-07 Thomas Koenig <tkoenig@gcc.gnu.org>
PR fortran/68829
diff --git a/gcc/fortran/trans-types.c b/gcc/fortran/trans-types.c
index 8617cd51a7c6f57c3ae138fe401fd5efa4ac3124..76ee97b81c04391efd7b5082f382e54cc7281946 100644
--- a/gcc/fortran/trans-types.c
+++ b/gcc/fortran/trans-types.c
@@ -36,6 +36,7 @@ along with GCC; see the file COPYING3. If not see
#include "trans-types.h"
#include "trans-const.h"
#include "dwarf2out.h" /* For struct array_descr_info. */
+#include "attribs.h"
#if (GFC_MAX_DIMENSIONS < 10)
diff --git a/gcc/function.c b/gcc/function.c
index 86f14847cfa1648aa6c03714d9bb5e0c58debb28..20c287bc8e01436831814ad7f375b37b3bb49895 100644
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -77,6 +77,8 @@ along with GCC; see the file COPYING3. If not see
#include "rtl-chkp.h"
#include "tree-dfa.h"
#include "tree-ssa.h"
+#include "stringpool.h"
+#include "attribs.h"
/* So we can assign to cfun in this file. */
#undef cfun
diff --git a/gcc/gimple-expr.c b/gcc/gimple-expr.c
index 13e55ef55fe6adcab0ec8db1058418219e8306d7..c1771fcf1d0551a7fb398a2e080e401e8ba05c33 100644
--- a/gcc/gimple-expr.c
+++ b/gcc/gimple-expr.c
@@ -35,6 +35,8 @@ along with GCC; see the file COPYING3. If not see
#include "hash-set.h"
#include "rtl.h"
#include "tree-pass.h"
+#include "stringpool.h"
+#include "attribs.h"
/* ----- Type related ----- */
diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c
index d82d0606cbeff6c20fc500007e3397e4f8b8ccfc..251446c5b828db0c9e6f99e44a1e798b4b95db82 100644
--- a/gcc/gimple-fold.c
+++ b/gcc/gimple-fold.c
@@ -56,6 +56,8 @@ along with GCC; see the file COPYING3. If not see
#include "ipa-chkp.h"
#include "tree-cfg.h"
#include "fold-const-call.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
/* Return true when DECL can be referenced from current unit.
diff --git a/gcc/gimple-pretty-print.c b/gcc/gimple-pretty-print.c
index 8b69b72e9e224ee8e1ad320fb6030b34637b83fb..5727d14777a234372037006702cfd1cd25ca9460 100644
--- a/gcc/gimple-pretty-print.c
+++ b/gcc/gimple-pretty-print.c
@@ -38,6 +38,8 @@ along with GCC; see the file COPYING3. If not see
#include "value-prof.h"
#include "trans-mem.h"
#include "cfganal.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
#define INDENT(SPACE) \
diff --git a/gcc/gimple.c b/gcc/gimple.c
index 3a32b530cce6ad16e40fbc90304614dda20c737a..c4e6f8176b9a4c11f9252cacdd083ea83c464c4e 100644
--- a/gcc/gimple.c
+++ b/gcc/gimple.c
@@ -41,6 +41,8 @@ along with GCC; see the file COPYING3. If not see
#include "builtins.h"
#include "selftest.h"
#include "gimple-pretty-print.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
diff --git a/gcc/gimplify.c b/gcc/gimplify.c
index ed2ec646da2ec451f5879d62c5b7fab01fa6cb44..86623e09f5d8ab898b1e497d321717e3778606ed 100644
--- a/gcc/gimplify.c
+++ b/gcc/gimplify.c
@@ -60,6 +60,8 @@ along with GCC; see the file COPYING3. If not see
#include "gimple-walk.h"
#include "langhooks-def.h" /* FIXME: for lhd_set_decl_assembler_name */
#include "builtins.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
#include "dbgcnt.h"
diff --git a/gcc/hsa-common.c b/gcc/hsa-common.c
index 95636ebc9a83d0afa076f1b55dcb2a2c64834424..c8c12afb04ceaad8b911f7e89151edd31658ff9a 100644
--- a/gcc/hsa-common.c
+++ b/gcc/hsa-common.c
@@ -40,6 +40,8 @@ along with GCC; see the file COPYING3. If not see
#include "internal-fn.h"
#include "ctype.h"
#include "builtins.h"
+#include "stringpool.h"
+#include "attribs.h"
/* Structure containing intermediate HSA representation of the generated
function. */
diff --git a/gcc/hsa-gen.c b/gcc/hsa-gen.c
index 6ec8c348eb453393d2c30a6221d8ceb5a1c0afe1..bd227626e838f8318a61ab8e95271ef7eed0e107 100644
--- a/gcc/hsa-gen.c
+++ b/gcc/hsa-gen.c
@@ -60,6 +60,8 @@ along with GCC; see the file COPYING3. If not see
#include "internal-fn.h"
#include "builtins.h"
#include "stor-layout.h"
+#include "stringpool.h"
+#include "attribs.h"
/* Print a warning message and set that we have seen an error. */
diff --git a/gcc/internal-fn.c b/gcc/internal-fn.c
index e24ed1695159bdf8db1a424499d24265f6d714ab..2b72367a1d396ac5151c6142072231bb8ce76548 100644
--- a/gcc/internal-fn.c
+++ b/gcc/internal-fn.c
@@ -39,6 +39,8 @@ along with GCC; see the file COPYING3. If not see
#include "stor-layout.h"
#include "dojump.h"
#include "expr.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
#include "ubsan.h"
#include "recog.h"
diff --git a/gcc/ipa-chkp.c b/gcc/ipa-chkp.c
index 753673c8f66845a9ab12ecdacdd3aa361554dc1d..704ef6e4550460b53074e25941b4bb2caff043dd 100644
--- a/gcc/ipa-chkp.c
+++ b/gcc/ipa-chkp.c
@@ -34,6 +34,8 @@ along with GCC; see the file COPYING3. If not see
#include "tree-chkp.h"
#include "tree-inline.h"
#include "ipa-chkp.h"
+#include "stringpool.h"
+#include "attribs.h"
/* Pointer Bounds Checker has two IPA passes to support code instrumentation.
diff --git a/gcc/ipa-cp.c b/gcc/ipa-cp.c
index 3b9eab41672dd8da81f25244ec7549d2b030a1f6..6b3d8d7364ced456288f5fee9332875bd7133dd4 100644
--- a/gcc/ipa-cp.c
+++ b/gcc/ipa-cp.c
@@ -122,6 +122,8 @@ along with GCC; see the file COPYING3. If not see
#include "ipa-fnsummary.h"
#include "ipa-utils.h"
#include "tree-ssa-ccp.h"
+#include "stringpool.h"
+#include "attribs.h"
template <typename valtype> class ipcp_value;
diff --git a/gcc/ipa-devirt.c b/gcc/ipa-devirt.c
index 9781acd0766334a644a133c2f94b09b48fbe7f9d..f0aecfbc455d1c1d25bfe10800b98619d01816eb 100644
--- a/gcc/ipa-devirt.c
+++ b/gcc/ipa-devirt.c
@@ -129,6 +129,8 @@ along with GCC; see the file COPYING3. If not see
#include "dbgcnt.h"
#include "gimple-pretty-print.h"
#include "intl.h"
+#include "stringpool.h"
+#include "attribs.h"
/* Hash based set of pairs of types. */
struct type_pair
diff --git a/gcc/ipa-fnsummary.c b/gcc/ipa-fnsummary.c
index 27e8d73f9df3bb6bd479193e5618147647c195f9..076ccd40bd7d74817f5bbb02408d0c7073c1a319 100644
--- a/gcc/ipa-fnsummary.c
+++ b/gcc/ipa-fnsummary.c
@@ -82,6 +82,8 @@ along with GCC; see the file COPYING3. If not see
#include "cilk.h"
#include "cfgexpand.h"
#include "gimplify.h"
+#include "stringpool.h"
+#include "attribs.h"
/* Summaries. */
function_summary <ipa_fn_summary *> *ipa_fn_summaries;
diff --git a/gcc/ipa-inline.c b/gcc/ipa-inline.c
index 608db8f8857ac556e9cc507a58f5ea19c4f8c334..dd46cb613624c5eb7de0a1313a707ec19428eef9 100644
--- a/gcc/ipa-inline.c
+++ b/gcc/ipa-inline.c
@@ -117,6 +117,8 @@ along with GCC; see the file COPYING3. If not see
#include "auto-profile.h"
#include "builtins.h"
#include "fibonacci_heap.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
typedef fibonacci_heap <sreal, cgraph_edge> edge_heap_t;
diff --git a/gcc/ipa-visibility.c b/gcc/ipa-visibility.c
index 3033f20e3f14e17956d56b1a5ded1b9d54216925..998024893a5d159a91031b857f4e1c4ef1bdb019 100644
--- a/gcc/ipa-visibility.c
+++ b/gcc/ipa-visibility.c
@@ -84,6 +84,8 @@ along with GCC; see the file COPYING3. If not see
#include "calls.h"
#include "varasm.h"
#include "ipa-utils.h"
+#include "stringpool.h"
+#include "attribs.h"
/* Return true when NODE can not be local. Worker for cgraph_local_node_p. */
diff --git a/gcc/ipa.c b/gcc/ipa.c
index 00cd3084f660c9ad764e9544fba369f3d371d26a..16df4cacedd4093d6952f8987da6eb527df57936 100644
--- a/gcc/ipa.c
+++ b/gcc/ipa.c
@@ -37,7 +37,8 @@ along with GCC; see the file COPYING3. If not see
#include "ipa-fnsummary.h"
#include "dbgcnt.h"
#include "debug.h"
-
+#include "stringpool.h"
+#include "attribs.h"
/* Return true when NODE has ADDR reference. */
diff --git a/gcc/lto-cgraph.c b/gcc/lto-cgraph.c
index e2680277bb5f2ccfcb8b695578ad8b3381c9e615..15f0eaadf206e5a5f566947874fa9ceeb99b7f50 100644
--- a/gcc/lto-cgraph.c
+++ b/gcc/lto-cgraph.c
@@ -38,6 +38,8 @@ along with GCC; see the file COPYING3. If not see
#include "ipa-utils.h"
#include "omp-offload.h"
#include "ipa-chkp.h"
+#include "stringpool.h"
+#include "attribs.h"
/* True when asm nodes has been output. */
bool asm_nodes_output = false;
diff --git a/gcc/lto/ChangeLog b/gcc/lto/ChangeLog
index 9861e98d24f21b2870599233185211c803da8e29..cd9de758ec37550fb5d448d4c911127f21f7207c 100644
--- a/gcc/lto/ChangeLog
+++ b/gcc/lto/ChangeLog
@@ -1,3 +1,8 @@
+2017-08-08 Martin Liska <mliska@suse.cz>
+
+ * lto-lang.c: Include header files.
+ * lto-symtab.c: Likewise.
+
2017-08-03 Richard Biener <rguenther@suse.de>
* lto-symtab.h (lto_symtab_prevail_decl): Do not use
diff --git a/gcc/lto/lto-lang.c b/gcc/lto/lto-lang.c
index 6e9a138fa3b6ce4f4d63f39de8f8a646e4d86057..375cdd1a90be74534abbd53e02de4bf554618612 100644
--- a/gcc/lto/lto-lang.c
+++ b/gcc/lto/lto-lang.c
@@ -35,6 +35,8 @@ along with GCC; see the file COPYING3. If not see
#include "lto-tree.h"
#include "lto.h"
#include "cilk.h"
+#include "stringpool.h"
+#include "attribs.h"
static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
static tree handle_leaf_attribute (tree *, tree, tree, int, bool *);
diff --git a/gcc/lto/lto-symtab.c b/gcc/lto/lto-symtab.c
index 019677eaf95e906d5dfc15f609f70fadfa1b3856..70190d0fda27b38c3202a3ed9dc425f0783b7c0b 100644
--- a/gcc/lto/lto-symtab.c
+++ b/gcc/lto/lto-symtab.c
@@ -32,6 +32,8 @@ along with GCC; see the file COPYING3. If not see
#include "builtins.h"
#include "alias.h"
#include "lto-symtab.h"
+#include "stringpool.h"
+#include "attribs.h"
/* Replace the cgraph node NODE with PREVAILING_NODE in the cgraph, merging
all edges and removing the old node. */
diff --git a/gcc/objc/ChangeLog b/gcc/objc/ChangeLog
index 27bb0600626cafb3a209b02d6b5ebb62fea6357f..5d632a68b73985d565b292ec90d6e81fff343707 100644
--- a/gcc/objc/ChangeLog
+++ b/gcc/objc/ChangeLog
@@ -1,3 +1,9 @@
+2017-08-08 Martin Liska <mliska@suse.cz>
+
+ * objc-gnu-runtime-abi-01.c: Include header files.
+ * objc-next-runtime-abi-01.c: Likewise.
+ * objc-next-runtime-abi-02.c: Likewise.
+
2017-07-20 Nathan Sidwell <nathan@acm.org>
Remove TYPE_METHODS.
diff --git a/gcc/objc/objc-gnu-runtime-abi-01.c b/gcc/objc/objc-gnu-runtime-abi-01.c
index d1686e659bdb4f8b12b1796f080b58bcb18a90b6..b53d1820db3e700d0a7ec3ced42bd425b4aa236d 100644
--- a/gcc/objc/objc-gnu-runtime-abi-01.c
+++ b/gcc/objc/objc-gnu-runtime-abi-01.c
@@ -22,7 +22,9 @@ along with GCC; see the file COPYING3. If not see
#include "system.h"
#include "coretypes.h"
#include "options.h"
+#include "tree.h"
#include "stringpool.h"
+#include "attribs.h"
#ifdef OBJCPLUS
#include "cp/cp-tree.h"
diff --git a/gcc/objc/objc-next-runtime-abi-01.c b/gcc/objc/objc-next-runtime-abi-01.c
index 7aff7883f211790cc114a2eb3be5a7ed854d3a80..686d9285482cd6a70efd13d6ea5d681826067874 100644
--- a/gcc/objc/objc-next-runtime-abi-01.c
+++ b/gcc/objc/objc-next-runtime-abi-01.c
@@ -26,7 +26,9 @@ along with GCC; see the file COPYING3. If not see
#include "config.h"
#include "system.h"
#include "coretypes.h"
+#include "tree.h"
#include "stringpool.h"
+#include "attribs.h"
#ifdef OBJCPLUS
#include "cp/cp-tree.h"
diff --git a/gcc/objc/objc-next-runtime-abi-02.c b/gcc/objc/objc-next-runtime-abi-02.c
index 97314860e015adbfb029350b182ca3eae50fd8bc..a2245a4c3393d77e5bee32bc39ea21ed827473ec 100644
--- a/gcc/objc/objc-next-runtime-abi-02.c
+++ b/gcc/objc/objc-next-runtime-abi-02.c
@@ -28,7 +28,9 @@ along with GCC; see the file COPYING3. If not see
#include "config.h"
#include "system.h"
#include "coretypes.h"
+#include "tree.h"
#include "stringpool.h"
+#include "attribs.h"
#ifdef OBJCPLUS
#include "cp/cp-tree.h"
diff --git a/gcc/omp-expand.c b/gcc/omp-expand.c
index 0f635070a2136b44b61e4db9bf407f7aa9c7b3fd..ac83ba168d23ab7bf387cadf8d786a3bf6989b53 100644
--- a/gcc/omp-expand.c
+++ b/gcc/omp-expand.c
@@ -58,7 +58,8 @@ along with GCC; see the file COPYING3. If not see
#include "gimple-pretty-print.h"
#include "hsa-common.h"
#include "debug.h"
-
+#include "stringpool.h"
+#include "attribs.h"
/* OMP region information. Every parallel and workshare
directive is enclosed between two markers, the OMP_* directive
diff --git a/gcc/omp-general.c b/gcc/omp-general.c
index ed94668559b3babf672dba328a79e671b8a016af..af955bce7832e138521308189786d54107cbd525 100644
--- a/gcc/omp-general.c
+++ b/gcc/omp-general.c
@@ -33,7 +33,8 @@ along with GCC; see the file COPYING3. If not see
#include "fold-const.h"
#include "langhooks.h"
#include "omp-general.h"
-
+#include "stringpool.h"
+#include "attribs.h"
tree
omp_find_clause (tree clauses, enum omp_clause_code kind)
diff --git a/gcc/omp-low.c b/gcc/omp-low.c
index 2e0973e06d16489d5ac041cb6ae2204151275805..3df60561d5bba8ea7124d562b0861573ed345364 100644
--- a/gcc/omp-low.c
+++ b/gcc/omp-low.c
@@ -58,6 +58,8 @@ along with GCC; see the file COPYING3. If not see
#include "gomp-constants.h"
#include "gimple-pretty-print.h"
#include "hsa-common.h"
+#include "stringpool.h"
+#include "attribs.h"
/* Lowering of OMP parallel and workshare constructs proceeds in two
phases. The first phase scans the function looking for OMP statements
diff --git a/gcc/omp-offload.c b/gcc/omp-offload.c
index 54a4e90f70ca2853181699a75aa0a34e6246d994..2d4fd41168054a5894fe346a5c8ea2d12bed9de6 100644
--- a/gcc/omp-offload.c
+++ b/gcc/omp-offload.c
@@ -49,6 +49,8 @@ along with GCC; see the file COPYING3. If not see
#include "gomp-constants.h"
#include "gimple-pretty-print.h"
#include "intl.h"
+#include "stringpool.h"
+#include "attribs.h"
/* Describe the OpenACC looping structure of a function. The entire
function is held in a 'NULL' loop. */
diff --git a/gcc/omp-simd-clone.c b/gcc/omp-simd-clone.c
index fbb122cd1e0898a40e001396b8b6e07df3cb42a4..0a3a386f33dfea64829b208017c255641d40600c 100644
--- a/gcc/omp-simd-clone.c
+++ b/gcc/omp-simd-clone.c
@@ -48,7 +48,8 @@ along with GCC; see the file COPYING3. If not see
#include "ipa-prop.h"
#include "tree-eh.h"
#include "varasm.h"
-
+#include "stringpool.h"
+#include "attribs.h"
/* Allocate a fresh `simd_clone' and return it. NARGS is the number
of arguments to reserve space for. */
diff --git a/gcc/opts-global.c b/gcc/opts-global.c
index 50bad77c34716aeb4d97e9adc1c5e98c06cffb7d..fc55512e5542d79187381244fc0739812e950dda 100644
--- a/gcc/opts-global.c
+++ b/gcc/opts-global.c
@@ -35,6 +35,8 @@ along with GCC; see the file COPYING3. If not see
#include "plugin.h"
#include "toplev.h"
#include "context.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
typedef const char *const_char_p; /* For DEF_VEC_P. */
diff --git a/gcc/passes.c b/gcc/passes.c
index f5791ac806afb8a251549a2c2e27dca1d2295686..2c9add84c1d883de7de90872c4ef862f84320180 100644
--- a/gcc/passes.c
+++ b/gcc/passes.c
@@ -61,6 +61,8 @@ along with GCC; see the file COPYING3. If not see
#include "tree-cfgcleanup.h"
#include "insn-addr.h" /* for INSN_ADDRESSES_ALLOC. */
#include "diagnostic-core.h" /* for fnotice */
+#include "stringpool.h"
+#include "attribs.h"
using namespace gcc;
diff --git a/gcc/predict.c b/gcc/predict.c
index 609c099d7b5cf2d519e7447400cba171475c571b..80c2c1966d84c20ddc227d101aaf29e72d2ef35d 100644
--- a/gcc/predict.c
+++ b/gcc/predict.c
@@ -59,6 +59,8 @@ along with GCC; see the file COPYING3. If not see
#include "gimple-pretty-print.h"
#include "selftest.h"
#include "cfgrtl.h"
+#include "stringpool.h"
+#include "attribs.h"
/* Enum with reasons why a predictor is ignored. */
diff --git a/gcc/sancov.c b/gcc/sancov.c
index 1651989ea2429ec372149835bb4636a8048051ce..b19de8bbbc5fc99416b4440c98dca0e9a3dfc8ea 100644
--- a/gcc/sancov.c
+++ b/gcc/sancov.c
@@ -32,6 +32,8 @@ along with GCC; see the file COPYING3. If not see
#include "tree-cfg.h"
#include "tree-pass.h"
#include "tree-iterator.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
namespace {
diff --git a/gcc/sanopt.c b/gcc/sanopt.c
index f6dd14da00d451c49a6571729a902b69e1e60d19..d17c7db3321b37acf1fe3be813425ae3a7850e79 100644
--- a/gcc/sanopt.c
+++ b/gcc/sanopt.c
@@ -30,6 +30,8 @@ along with GCC; see the file COPYING3. If not see
#include "gimple-pretty-print.h"
#include "fold-const.h"
#include "gimple-iterator.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
#include "ubsan.h"
#include "params.h"
diff --git a/gcc/symtab.c b/gcc/symtab.c
index 0145910023fefa3d128fdf99f7f249ce6b0d99ae..7e5eb7d6416b2b50dc288b3f4477061862012028 100644
--- a/gcc/symtab.c
+++ b/gcc/symtab.c
@@ -35,6 +35,8 @@ along with GCC; see the file COPYING3. If not see
#include "output.h"
#include "ipa-utils.h"
#include "calls.h"
+#include "stringpool.h"
+#include "attribs.h"
static const char *ipa_ref_use_name[] = {"read","write","addr","alias","chkp"};
diff --git a/gcc/toplev.c b/gcc/toplev.c
index 48a79e28d99a1843beb12b84c02ff7d36eace312..d23714c47738d0c5f8f98d2e6ad3dfd88ff47681 100644
--- a/gcc/toplev.c
+++ b/gcc/toplev.c
@@ -63,6 +63,8 @@ along with GCC; see the file COPYING3. If not see
#include "hosthooks.h"
#include "opts.h"
#include "opts-diagnostic.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
#include "tsan.h"
#include "plugin.h"
diff --git a/gcc/trans-mem.c b/gcc/trans-mem.c
index eb03560be260d696f401a162c6f38cdd6a9b2051..40b5368118664bdaaeb06546c390924feb1763f8 100644
--- a/gcc/trans-mem.c
+++ b/gcc/trans-mem.c
@@ -50,7 +50,8 @@
#include "langhooks.h"
#include "cfgloop.h"
#include "tree-ssa-address.h"
-
+#include "stringpool.h"
+#include "attribs.h"
#define A_RUNINSTRUMENTEDCODE 0x0001
#define A_RUNUNINSTRUMENTEDCODE 0x0002
diff --git a/gcc/tree-chkp.c b/gcc/tree-chkp.c
index e241f50f308413c0d4ab5b6b8367cded7099c332..12af458fb90d79a0df94125075c1a3db2b98e5f2 100644
--- a/gcc/tree-chkp.c
+++ b/gcc/tree-chkp.c
@@ -52,6 +52,8 @@ along with GCC; see the file COPYING3. If not see
#include "tree-dfa.h"
#include "ipa-chkp.h"
#include "params.h"
+#include "stringpool.h"
+#include "attribs.h"
/* Pointer Bounds Checker instruments code with memory checks to find
out-of-bounds memory accesses. Checks are performed by computing
diff --git a/gcc/tree-eh.c b/gcc/tree-eh.c
index c68d71a5e54403189f4d88ee9d0c3fb12d51a8bc..938197992ceb386592496cf63dcd55db1efa59bd 100644
--- a/gcc/tree-eh.c
+++ b/gcc/tree-eh.c
@@ -43,6 +43,8 @@ along with GCC; see the file COPYING3. If not see
#include "langhooks.h"
#include "cfgloop.h"
#include "gimple-low.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
/* In some instances a tree and a gimple need to be stored in a same table,
diff --git a/gcc/tree-into-ssa.c b/gcc/tree-into-ssa.c
index d4056373f318dfee0714363de5f11c5e1a437005..28f72e4ce3204d7cad7c2311c3e828fedcfaf099 100644
--- a/gcc/tree-into-ssa.c
+++ b/gcc/tree-into-ssa.c
@@ -38,6 +38,8 @@ along with GCC; see the file COPYING3. If not see
#include "tree-ssa.h"
#include "domwalk.h"
#include "statistics.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
#define PERCENT(x,y) ((float)(x) * 100.0 / (float)(y))
diff --git a/gcc/tree-object-size.c b/gcc/tree-object-size.c
index 723a5283da60232beffdd0d91f6dc8b9a0b63d6d..a56b78a4510388f075fa2aeb23f4c4703565f944 100644
--- a/gcc/tree-object-size.c
+++ b/gcc/tree-object-size.c
@@ -32,6 +32,8 @@ along with GCC; see the file COPYING3. If not see
#include "gimple-fold.h"
#include "gimple-iterator.h"
#include "tree-cfg.h"
+#include "stringpool.h"
+#include "attribs.h"
struct object_size_info
{
diff --git a/gcc/tree-parloops.c b/gcc/tree-parloops.c
index 59e261d2aaa35a063cf73d6bf2d94daf718e3d9e..cfc143f3c025c43d0b9c9772f170d26638c16cd6 100644
--- a/gcc/tree-parloops.c
+++ b/gcc/tree-parloops.c
@@ -58,6 +58,8 @@ along with GCC; see the file COPYING3. If not see
#include "tree-eh.h"
#include "gomp-constants.h"
#include "tree-dfa.h"
+#include "stringpool.h"
+#include "attribs.h"
/* This pass tries to distribute iterations of loops into several threads.
The implementation is straightforward -- for each loop we test whether its
diff --git a/gcc/tree-profile.c b/gcc/tree-profile.c
index b1ee7f2b3f53d4f7c54c385fbce76fe133b1ea89..4b73255018c984d27e1f8e14c62daa85eee40d15 100644
--- a/gcc/tree-profile.c
+++ b/gcc/tree-profile.c
@@ -50,6 +50,8 @@ along with GCC; see the file COPYING3. If not see
#include "profile.h"
#include "tree-cfgcleanup.h"
#include "params.h"
+#include "stringpool.h"
+#include "attribs.h"
static GTY(()) tree gcov_type_node;
static GTY(()) tree tree_interval_profiler_fn;
diff --git a/gcc/tree-ssa-ccp.c b/gcc/tree-ssa-ccp.c
index f18f2e0c2a4ca4b73ba9cdf3343eb374043eb4a3..3940d538ca77997a43e2a02b803c5c5f1ded9763 100644
--- a/gcc/tree-ssa-ccp.c
+++ b/gcc/tree-ssa-ccp.c
@@ -145,6 +145,8 @@ along with GCC; see the file COPYING3. If not see
#include "tree-ssa-ccp.h"
#include "tree-dfa.h"
#include "diagnostic-core.h"
+#include "stringpool.h"
+#include "attribs.h"
/* Possible lattice values. */
typedef enum
diff --git a/gcc/tree-ssa-live.c b/gcc/tree-ssa-live.c
index c77075e4ac6b11efdaaa84dfc3eecc53b8216749..8738fe21a6e137973559287ce3075680fee62e71 100644
--- a/gcc/tree-ssa-live.c
+++ b/gcc/tree-ssa-live.c
@@ -38,6 +38,8 @@ along with GCC; see the file COPYING3. If not see
#include "tree-ssa.h"
#include "ipa-utils.h"
#include "cfgloop.h"
+#include "stringpool.h"
+#include "attribs.h"
static void verify_live_on_entry (tree_live_info_p);
diff --git a/gcc/tree-ssa-loop.c b/gcc/tree-ssa-loop.c
index 19a0f30c525cc98a0eb9ddd7c70712e88f94180c..1e8491757a6d663d69e99712511add2b5dfaecd8 100644
--- a/gcc/tree-ssa-loop.c
+++ b/gcc/tree-ssa-loop.c
@@ -38,6 +38,8 @@ along with GCC; see the file COPYING3. If not see
#include "tree-vectorizer.h"
#include "omp-general.h"
#include "diagnostic-core.h"
+#include "stringpool.h"
+#include "attribs.h"
/* A pass making sure loops are fixed up. */
diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c
index ca43f01b1f5054b5b4a7fc0f7832ee7b4ccd7036..d62a49d2d1e55ce7219a2a0c8c595f3d38574158 100644
--- a/gcc/tree-ssa-sccvn.c
+++ b/gcc/tree-ssa-sccvn.c
@@ -60,6 +60,8 @@ along with GCC; see the file COPYING3. If not see
#include "domwalk.h"
#include "gimple-iterator.h"
#include "gimple-match.h"
+#include "stringpool.h"
+#include "attribs.h"
/* This algorithm is based on the SCC algorithm presented by Keith
Cooper and L. Taylor Simpson in "SCC-Based Value numbering"
diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c
index e743e35033eadcf9461ff322c6690bfcf21034a6..c120ce4030307b45fd897bab2169b671b01bf8cc 100644
--- a/gcc/tree-ssa-structalias.c
+++ b/gcc/tree-ssa-structalias.c
@@ -40,7 +40,8 @@
#include "params.h"
#include "gimple-walk.h"
#include "varasm.h"
-
+#include "stringpool.h"
+#include "attribs.h"
/* The idea behind this analyzer is to generate set constraints from the
program, then solve the resulting constraints in order to generate the
diff --git a/gcc/tree-ssa.c b/gcc/tree-ssa.c
index a67012c043faaac4a5967aa2ad3d143b0bece4d4..8b6da9645ce020f73b02c2c56676ff022459151d 100644
--- a/gcc/tree-ssa.c
+++ b/gcc/tree-ssa.c
@@ -41,6 +41,8 @@ along with GCC; see the file COPYING3. If not see
#include "cfgexpand.h"
#include "tree-cfg.h"
#include "tree-dfa.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
/* Pointer map of variable mappings, keyed by edge. */
diff --git a/gcc/tree-streamer-in.c b/gcc/tree-streamer-in.c
index eb41e7556d00a2d09b2c6e07bdbfddd92edf2ec6..600470080aadad638bf95b3ee7d8ce32dc1a3ac3 100644
--- a/gcc/tree-streamer-in.c
+++ b/gcc/tree-streamer-in.c
@@ -32,6 +32,8 @@ along with GCC; see the file COPYING3. If not see
#include "builtins.h"
#include "ipa-chkp.h"
#include "gomp-constants.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
#include "opts.h"
diff --git a/gcc/tree-vectorizer.c b/gcc/tree-vectorizer.c
index 129129f6b68dbaaba9227c3d86edfabe98ac3800..feddfa2287c259c01e7daeb10412886dd5a89d62 100644
--- a/gcc/tree-vectorizer.c
+++ b/gcc/tree-vectorizer.c
@@ -76,6 +76,8 @@ along with GCC; see the file COPYING3. If not see
#include "tree-ssa-propagate.h"
#include "dbgcnt.h"
#include "tree-scalar-evolution.h"
+#include "stringpool.h"
+#include "attribs.h"
/* Loop or bb location. */
diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
index 79a29bf0efb7f261a248633fe2c753627ef04939..657a8d186c868cc68f2f33e80cdbc2313bfb04e9 100644
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -62,6 +62,8 @@ along with GCC; see the file COPYING3. If not see
#include "alloc-pool.h"
#include "domwalk.h"
#include "tree-cfgcleanup.h"
+#include "stringpool.h"
+#include "attribs.h"
#define VR_INITIALIZER { VR_UNDEFINED, NULL_TREE, NULL_TREE, NULL }
diff --git a/gcc/tree.c b/gcc/tree.c
index 2b65cb1d125cf4834460f340d940131f0ce0f6b5..c493edd561d5400bf37b0baaad84d281c3a65a88 100644
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -62,6 +62,8 @@ along with GCC; see the file COPYING3. If not see
#include "print-tree.h"
#include "ipa-utils.h"
#include "selftest.h"
+#include "stringpool.h"
+#include "attribs.h"
/* Tree code classes. */
@@ -4822,254 +4824,6 @@ protected_set_expr_location (tree t, location_t loc)
SET_EXPR_LOCATION (t, loc);
}
-/* Return a declaration like DDECL except that its DECL_ATTRIBUTES
- is ATTRIBUTE. */
-
-tree
-build_decl_attribute_variant (tree ddecl, tree attribute)
-{
- DECL_ATTRIBUTES (ddecl) = attribute;
- return ddecl;
-}
-
-/* Return a type like TTYPE except that its TYPE_ATTRIBUTE
- is ATTRIBUTE and its qualifiers are QUALS.
-
- Record such modified types already made so we don't make duplicates. */
-
-tree
-build_type_attribute_qual_variant (tree ttype, tree attribute, int quals)
-{
- if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
- {
- tree ntype;
-
- /* Building a distinct copy of a tagged type is inappropriate; it
- causes breakage in code that expects there to be a one-to-one
- relationship between a struct and its fields.
- build_duplicate_type is another solution (as used in
- handle_transparent_union_attribute), but that doesn't play well
- with the stronger C++ type identity model. */
- if (TREE_CODE (ttype) == RECORD_TYPE
- || TREE_CODE (ttype) == UNION_TYPE
- || TREE_CODE (ttype) == QUAL_UNION_TYPE
- || TREE_CODE (ttype) == ENUMERAL_TYPE)
- {
- warning (OPT_Wattributes,
- "ignoring attributes applied to %qT after definition",
- TYPE_MAIN_VARIANT (ttype));
- return build_qualified_type (ttype, quals);
- }
-
- ttype = build_qualified_type (ttype, TYPE_UNQUALIFIED);
- ntype = build_distinct_type_copy (ttype);
-
- TYPE_ATTRIBUTES (ntype) = attribute;
-
- hashval_t hash = type_hash_canon_hash (ntype);
- ntype = type_hash_canon (hash, ntype);
-
- /* If the target-dependent attributes make NTYPE different from
- its canonical type, we will need to use structural equality
- checks for this type. */
- if (TYPE_STRUCTURAL_EQUALITY_P (ttype)
- || !comp_type_attributes (ntype, ttype))
- SET_TYPE_STRUCTURAL_EQUALITY (ntype);
- else if (TYPE_CANONICAL (ntype) == ntype)
- TYPE_CANONICAL (ntype) = TYPE_CANONICAL (ttype);
-
- ttype = build_qualified_type (ntype, quals);
- }
- else if (TYPE_QUALS (ttype) != quals)
- ttype = build_qualified_type (ttype, quals);
-
- return ttype;
-}
-
-/* Check if "omp declare simd" attribute arguments, CLAUSES1 and CLAUSES2, are
- the same. */
-
-static bool
-omp_declare_simd_clauses_equal (tree clauses1, tree clauses2)
-{
- tree cl1, cl2;
- for (cl1 = clauses1, cl2 = clauses2;
- cl1 && cl2;
- cl1 = OMP_CLAUSE_CHAIN (cl1), cl2 = OMP_CLAUSE_CHAIN (cl2))
- {
- if (OMP_CLAUSE_CODE (cl1) != OMP_CLAUSE_CODE (cl2))
- return false;
- if (OMP_CLAUSE_CODE (cl1) != OMP_CLAUSE_SIMDLEN)
- {
- if (simple_cst_equal (OMP_CLAUSE_DECL (cl1),
- OMP_CLAUSE_DECL (cl2)) != 1)
- return false;
- }
- switch (OMP_CLAUSE_CODE (cl1))
- {
- case OMP_CLAUSE_ALIGNED:
- if (simple_cst_equal (OMP_CLAUSE_ALIGNED_ALIGNMENT (cl1),
- OMP_CLAUSE_ALIGNED_ALIGNMENT (cl2)) != 1)
- return false;
- break;
- case OMP_CLAUSE_LINEAR:
- if (simple_cst_equal (OMP_CLAUSE_LINEAR_STEP (cl1),
- OMP_CLAUSE_LINEAR_STEP (cl2)) != 1)
- return false;
- break;
- case OMP_CLAUSE_SIMDLEN:
- if (simple_cst_equal (OMP_CLAUSE_SIMDLEN_EXPR (cl1),
- OMP_CLAUSE_SIMDLEN_EXPR (cl2)) != 1)
- return false;
- default:
- break;
- }
- }
- return true;
-}
-
-/* Compare two constructor-element-type constants. Return 1 if the lists
- are known to be equal; otherwise return 0. */
-
-static bool
-simple_cst_list_equal (const_tree l1, const_tree l2)
-{
- while (l1 != NULL_TREE && l2 != NULL_TREE)
- {
- if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
- return false;
-
- l1 = TREE_CHAIN (l1);
- l2 = TREE_CHAIN (l2);
- }
-
- return l1 == l2;
-}
-
-/* Compare two identifier nodes representing attributes.
- Return true if they are the same, false otherwise. */
-
-static bool
-cmp_attrib_identifiers (const_tree attr1, const_tree attr2)
-{
- /* Make sure we're dealing with IDENTIFIER_NODEs. */
- gcc_checking_assert (TREE_CODE (attr1) == IDENTIFIER_NODE
- && TREE_CODE (attr2) == IDENTIFIER_NODE);
-
- /* Identifiers can be compared directly for equality. */
- if (attr1 == attr2)
- return true;
-
- return cmp_attribs (IDENTIFIER_POINTER (attr1), IDENTIFIER_LENGTH (attr1),
- IDENTIFIER_POINTER (attr2), IDENTIFIER_LENGTH (attr2));
-}
-
-/* Compare two attributes for their value identity. Return true if the
- attribute values are known to be equal; otherwise return false. */
-
-bool
-attribute_value_equal (const_tree attr1, const_tree attr2)
-{
- if (TREE_VALUE (attr1) == TREE_VALUE (attr2))
- return true;
-
- if (TREE_VALUE (attr1) != NULL_TREE
- && TREE_CODE (TREE_VALUE (attr1)) == TREE_LIST
- && TREE_VALUE (attr2) != NULL_TREE
- && TREE_CODE (TREE_VALUE (attr2)) == TREE_LIST)
- {
- /* Handle attribute format. */
- if (is_attribute_p ("format", get_attribute_name (attr1)))
- {
- attr1 = TREE_VALUE (attr1);
- attr2 = TREE_VALUE (attr2);
- /* Compare the archetypes (printf/scanf/strftime/...). */
- if (!cmp_attrib_identifiers (TREE_VALUE (attr1),
- TREE_VALUE (attr2)))
- return false;
- /* Archetypes are the same. Compare the rest. */
- return (simple_cst_list_equal (TREE_CHAIN (attr1),
- TREE_CHAIN (attr2)) == 1);
- }
- return (simple_cst_list_equal (TREE_VALUE (attr1),
- TREE_VALUE (attr2)) == 1);
- }
-
- if ((flag_openmp || flag_openmp_simd)
- && TREE_VALUE (attr1) && TREE_VALUE (attr2)
- && TREE_CODE (TREE_VALUE (attr1)) == OMP_CLAUSE
- && TREE_CODE (TREE_VALUE (attr2)) == OMP_CLAUSE)
- return omp_declare_simd_clauses_equal (TREE_VALUE (attr1),
- TREE_VALUE (attr2));
-
- return (simple_cst_equal (TREE_VALUE (attr1), TREE_VALUE (attr2)) == 1);
-}
-
-/* Return 0 if the attributes for two types are incompatible, 1 if they
- are compatible, and 2 if they are nearly compatible (which causes a
- warning to be generated). */
-int
-comp_type_attributes (const_tree type1, const_tree type2)
-{
- const_tree a1 = TYPE_ATTRIBUTES (type1);
- const_tree a2 = TYPE_ATTRIBUTES (type2);
- const_tree a;
-
- if (a1 == a2)
- return 1;
- for (a = a1; a != NULL_TREE; a = TREE_CHAIN (a))
- {
- const struct attribute_spec *as;
- const_tree attr;
-
- as = lookup_attribute_spec (get_attribute_name (a));
- if (!as || as->affects_type_identity == false)
- continue;
-
- attr = lookup_attribute (as->name, CONST_CAST_TREE (a2));
- if (!attr || !attribute_value_equal (a, attr))
- break;
- }
- if (!a)
- {
- for (a = a2; a != NULL_TREE; a = TREE_CHAIN (a))
- {
- const struct attribute_spec *as;
-
- as = lookup_attribute_spec (get_attribute_name (a));
- if (!as || as->affects_type_identity == false)
- continue;
-
- if (!lookup_attribute (as->name, CONST_CAST_TREE (a1)))
- break;
- /* We don't need to compare trees again, as we did this
- already in first loop. */
- }
- /* All types - affecting identity - are equal, so
- there is no need to call target hook for comparison. */
- if (!a)
- return 1;
- }
- if (lookup_attribute ("transaction_safe", CONST_CAST_TREE (a)))
- return 0;
- /* As some type combinations - like default calling-convention - might
- be compatible, we have to call the target hook to get the final result. */
- return targetm.comp_type_attributes (type1, type2);
-}
-
-/* Return a type like TTYPE except that its TYPE_ATTRIBUTE
- is ATTRIBUTE.
-
- Record such modified types already made so we don't make duplicates. */
-
-tree
-build_type_attribute_variant (tree ttype, tree attribute)
-{
- return build_type_attribute_qual_variant (ttype, attribute,
- TYPE_QUALS (ttype));
-}
-
-
/* Reset the expression *EXPR_P, a size or position.
??? We could reset all non-constant sizes or positions. But it's cheap
@@ -6023,379 +5777,6 @@ make_pass_ipa_free_lang_data (gcc::context *ctxt)
{
return new pass_ipa_free_lang_data (ctxt);
}
-
-/* The backbone of lookup_attribute(). ATTR_LEN is the string length
- of ATTR_NAME, and LIST is not NULL_TREE. */
-tree
-private_lookup_attribute (const char *attr_name, size_t attr_len, tree list)
-{
- while (list)
- {
- tree attr = get_attribute_name (list);
- size_t ident_len = IDENTIFIER_LENGTH (attr);
- if (cmp_attribs (attr_name, attr_len, IDENTIFIER_POINTER (attr),
- ident_len))
- break;
- list = TREE_CHAIN (list);
- }
-
- return list;
-}
-
-/* Given an attribute name ATTR_NAME and a list of attributes LIST,
- return a pointer to the attribute's list first element if the attribute
- starts with ATTR_NAME. */
-
-tree
-private_lookup_attribute_by_prefix (const char *attr_name, size_t attr_len,
- tree list)
-{
- while (list)
- {
- size_t ident_len = IDENTIFIER_LENGTH (get_attribute_name (list));
-
- if (attr_len > ident_len)
- {
- list = TREE_CHAIN (list);
- continue;
- }
-
- const char *p = IDENTIFIER_POINTER (get_attribute_name (list));
- gcc_checking_assert (attr_len == 0 || p[0] != '_');
-
- if (strncmp (attr_name, p, attr_len) == 0)
- break;
-
- list = TREE_CHAIN (list);
- }
-
- return list;
-}
-
-
-/* A variant of lookup_attribute() that can be used with an identifier
- as the first argument, and where the identifier can be either
- 'text' or '__text__'.
-
- Given an attribute ATTR_IDENTIFIER, and a list of attributes LIST,
- return a pointer to the attribute's list element if the attribute
- is part of the list, or NULL_TREE if not found. If the attribute
- appears more than once, this only returns the first occurrence; the
- TREE_CHAIN of the return value should be passed back in if further
- occurrences are wanted. ATTR_IDENTIFIER must be an identifier but
- can be in the form 'text' or '__text__'. */
-static tree
-lookup_ident_attribute (tree attr_identifier, tree list)
-{
- gcc_checking_assert (TREE_CODE (attr_identifier) == IDENTIFIER_NODE);
-
- while (list)
- {
- gcc_checking_assert (TREE_CODE (get_attribute_name (list))
- == IDENTIFIER_NODE);
-
- if (cmp_attrib_identifiers (attr_identifier,
- get_attribute_name (list)))
- /* Found it. */
- break;
- list = TREE_CHAIN (list);
- }
-
- return list;
-}
-
-/* Remove any instances of attribute ATTR_NAME in LIST and return the
- modified list. */
-
-tree
-remove_attribute (const char *attr_name, tree list)
-{
- tree *p;
- gcc_checking_assert (attr_name[0] != '_');
-
- for (p = &list; *p; )
- {
- tree l = *p;
-
- tree attr = get_attribute_name (l);
- if (is_attribute_p (attr_name, attr))
- *p = TREE_CHAIN (l);
- else
- p = &TREE_CHAIN (l);
- }
-
- return list;
-}
-
-/* Return an attribute list that is the union of a1 and a2. */
-
-tree
-merge_attributes (tree a1, tree a2)
-{
- tree attributes;
-
- /* Either one unset? Take the set one. */
-
- if ((attributes = a1) == 0)
- attributes = a2;
-
- /* 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. */
-
- if (list_length (a1) < list_length (a2))
- attributes = a2, a2 = a1;
-
- for (; a2 != 0; a2 = TREE_CHAIN (a2))
- {
- tree a;
- for (a = lookup_ident_attribute (get_attribute_name (a2),
- attributes);
- a != NULL_TREE && !attribute_value_equal (a, a2);
- a = lookup_ident_attribute (get_attribute_name (a2),
- TREE_CHAIN (a)))
- ;
- if (a == NULL_TREE)
- {
- a1 = copy_node (a2);
- TREE_CHAIN (a1) = attributes;
- attributes = a1;
- }
- }
- }
- }
- return attributes;
-}
-
-/* Given types T1 and T2, merge their attributes and return
- the result. */
-
-tree
-merge_type_attributes (tree t1, tree t2)
-{
- return merge_attributes (TYPE_ATTRIBUTES (t1),
- TYPE_ATTRIBUTES (t2));
-}
-
-/* Given decls OLDDECL and NEWDECL, merge their attributes and return
- the result. */
-
-tree
-merge_decl_attributes (tree olddecl, tree newdecl)
-{
- return merge_attributes (DECL_ATTRIBUTES (olddecl),
- DECL_ATTRIBUTES (newdecl));
-}
-
-#if TARGET_DLLIMPORT_DECL_ATTRIBUTES
-
-/* Specialization of merge_decl_attributes for various Windows targets.
-
- This handles the following situation:
-
- __declspec (dllimport) int foo;
- int foo;
-
- The second instance of `foo' nullifies the dllimport. */
-
-tree
-merge_dllimport_decl_attributes (tree old, tree new_tree)
-{
- tree a;
- int delete_dllimport_p = 1;
-
- /* What we need to do here is remove from `old' dllimport if it doesn't
- appear in `new'. dllimport behaves like extern: if a declaration is
- marked dllimport and a definition appears later, then the object
- is not dllimport'd. We also remove a `new' dllimport if the old list
- contains dllexport: dllexport always overrides dllimport, regardless
- of the order of declaration. */
- if (!VAR_OR_FUNCTION_DECL_P (new_tree))
- delete_dllimport_p = 0;
- else if (DECL_DLLIMPORT_P (new_tree)
- && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old)))
- {
- DECL_DLLIMPORT_P (new_tree) = 0;
- warning (OPT_Wattributes, "%q+D already declared with dllexport attribute: "
- "dllimport ignored", new_tree);
- }
- else if (DECL_DLLIMPORT_P (old) && !DECL_DLLIMPORT_P (new_tree))
- {
- /* Warn about overriding a symbol that has already been used, e.g.:
- extern int __attribute__ ((dllimport)) foo;
- int* bar () {return &foo;}
- int foo;
- */
- if (TREE_USED (old))
- {
- warning (0, "%q+D redeclared without dllimport attribute "
- "after being referenced with dll linkage", new_tree);
- /* If we have used a variable's address with dllimport linkage,
- keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the
- decl may already have had TREE_CONSTANT computed.
- We still remove the attribute so that assembler code refers
- to '&foo rather than '_imp__foo'. */
- if (VAR_P (old) && TREE_ADDRESSABLE (old))
- DECL_DLLIMPORT_P (new_tree) = 1;
- }
-
- /* Let an inline definition silently override the external reference,
- but otherwise warn about attribute inconsistency. */
- else if (VAR_P (new_tree) || !DECL_DECLARED_INLINE_P (new_tree))
- warning (OPT_Wattributes, "%q+D redeclared without dllimport attribute: "
- "previous dllimport ignored", new_tree);
- }
- else
- delete_dllimport_p = 0;
-
- a = merge_attributes (DECL_ATTRIBUTES (old), DECL_ATTRIBUTES (new_tree));
-
- if (delete_dllimport_p)
- a = remove_attribute ("dllimport", a);
-
- return a;
-}
-
-/* Handle a "dllimport" or "dllexport" attribute; arguments as in
- struct attribute_spec.handler. */
-
-tree
-handle_dll_attribute (tree * pnode, tree name, tree args, int flags,
- bool *no_add_attrs)
-{
- tree node = *pnode;
- bool is_dllimport;
-
- /* These attributes may apply to structure and union types being created,
- but otherwise should pass to the declaration involved. */
- if (!DECL_P (node))
- {
- if (flags & ((int) ATTR_FLAG_DECL_NEXT | (int) ATTR_FLAG_FUNCTION_NEXT
- | (int) ATTR_FLAG_ARRAY_NEXT))
- {
- *no_add_attrs = true;
- return tree_cons (name, args, NULL_TREE);
- }
- if (TREE_CODE (node) == RECORD_TYPE
- || TREE_CODE (node) == UNION_TYPE)
- {
- node = TYPE_NAME (node);
- if (!node)
- return NULL_TREE;
- }
- else
- {
- warning (OPT_Wattributes, "%qE attribute ignored",
- name);
- *no_add_attrs = true;
- return NULL_TREE;
- }
- }
-
- if (!VAR_OR_FUNCTION_DECL_P (node) && TREE_CODE (node) != TYPE_DECL)
- {
- *no_add_attrs = true;
- warning (OPT_Wattributes, "%qE attribute ignored",
- name);
- return NULL_TREE;
- }
-
- if (TREE_CODE (node) == TYPE_DECL
- && TREE_CODE (TREE_TYPE (node)) != RECORD_TYPE
- && TREE_CODE (TREE_TYPE (node)) != UNION_TYPE)
- {
- *no_add_attrs = true;
- warning (OPT_Wattributes, "%qE attribute ignored",
- name);
- return NULL_TREE;
- }
-
- is_dllimport = is_attribute_p ("dllimport", name);
-
- /* Report error on dllimport ambiguities seen now before they cause
- any damage. */
- if (is_dllimport)
- {
- /* Honor any target-specific overrides. */
- if (!targetm.valid_dllimport_attribute_p (node))
- *no_add_attrs = true;
-
- else if (TREE_CODE (node) == FUNCTION_DECL
- && DECL_DECLARED_INLINE_P (node))
- {
- warning (OPT_Wattributes, "inline function %q+D declared as "
- " dllimport: attribute ignored", node);
- *no_add_attrs = true;
- }
- /* Like MS, treat definition of dllimported variables and
- non-inlined functions on declaration as syntax errors. */
- else if (TREE_CODE (node) == FUNCTION_DECL && DECL_INITIAL (node))
- {
- error ("function %q+D definition is marked dllimport", node);
- *no_add_attrs = true;
- }
-
- else if (VAR_P (node))
- {
- if (DECL_INITIAL (node))
- {
- error ("variable %q+D definition is marked dllimport",
- node);
- *no_add_attrs = true;
- }
-
- /* `extern' needn't be specified with dllimport.
- Specify `extern' now and hope for the best. Sigh. */
- DECL_EXTERNAL (node) = 1;
- /* Also, implicitly give dllimport'd variables declared within
- a function global scope, unless declared static. */
- if (current_function_decl != NULL_TREE && !TREE_STATIC (node))
- TREE_PUBLIC (node) = 1;
- }
-
- if (*no_add_attrs == false)
- DECL_DLLIMPORT_P (node) = 1;
- }
- else if (TREE_CODE (node) == FUNCTION_DECL
- && DECL_DECLARED_INLINE_P (node)
- && flag_keep_inline_dllexport)
- /* An exported function, even if inline, must be emitted. */
- DECL_EXTERNAL (node) = 0;
-
- /* Report error if symbol is not accessible at global scope. */
- if (!TREE_PUBLIC (node) && VAR_OR_FUNCTION_DECL_P (node))
- {
- error ("external linkage required for symbol %q+D because of "
- "%qE attribute", node, name);
- *no_add_attrs = true;
- }
-
- /* A dllexport'd entity must have default visibility so that other
- program units (shared libraries or the main executable) can see
- it. A dllimport'd entity must have default visibility so that
- the linker knows that undefined references within this program
- unit can be resolved by the dynamic linker. */
- if (!*no_add_attrs)
- {
- if (DECL_VISIBILITY_SPECIFIED (node)
- && DECL_VISIBILITY (node) != VISIBILITY_DEFAULT)
- error ("%qE implies default visibility, but %qD has already "
- "been declared with a different visibility",
- name, node);
- DECL_VISIBILITY (node) = VISIBILITY_DEFAULT;
- DECL_VISIBILITY_SPECIFIED (node) = 1;
- }
-
- return NULL_TREE;
-}
-
-#endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES */
/* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
of the various TYPE_QUAL values. */
@@ -7155,68 +6536,6 @@ print_type_hash_statistics (void)
type_hash_table->collisions ());
}
-/* Given two lists of attributes, return true if list l2 is
- equivalent to l1. */
-
-int
-attribute_list_equal (const_tree l1, const_tree l2)
-{
- if (l1 == l2)
- return 1;
-
- return attribute_list_contained (l1, l2)
- && attribute_list_contained (l2, l1);
-}
-
-/* Given two lists of attributes, return true if list L2 is
- completely contained within L1. */
-/* ??? This would be faster if attribute names were stored in a canonicalized
- form. Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
- must be used to show these elements are equivalent (which they are). */
-/* ??? It's not clear that attributes with arguments will always be handled
- correctly. */
-
-int
-attribute_list_contained (const_tree l1, const_tree l2)
-{
- const_tree t1, t2;
-
- /* First check the obvious, maybe the lists are identical. */
- if (l1 == l2)
- return 1;
-
- /* Maybe the lists are similar. */
- for (t1 = l1, t2 = l2;
- t1 != 0 && t2 != 0
- && get_attribute_name (t1) == get_attribute_name (t2)
- && TREE_VALUE (t1) == TREE_VALUE (t2);
- t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
- ;
-
- /* Maybe the lists are equal. */
- if (t1 == 0 && t2 == 0)
- return 1;
-
- for (; t2 != 0; t2 = TREE_CHAIN (t2))
- {
- const_tree attr;
- /* This CONST_CAST is okay because lookup_attribute does not
- modify its argument and the return value is assigned to a
- const_tree. */
- for (attr = lookup_ident_attribute (get_attribute_name (t2),
- CONST_CAST_TREE (l1));
- attr != NULL_TREE && !attribute_value_equal (t2, attr);
- attr = lookup_ident_attribute (get_attribute_name (t2),
- TREE_CHAIN (attr)))
- ;
-
- if (attr == NULL_TREE)
- return 0;
- }
-
- return 1;
-}
-
/* Given two lists of types
(chains of TREE_LIST nodes with types in the TREE_VALUE slots)
return 1 if the lists contain the same types in the same order.
diff --git a/gcc/tree.h b/gcc/tree.h
index 1e89809804c9c033c881f0ac5c72483307cd91e2..46debc12a845300d36965f175744a0389d82225b 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -4088,8 +4088,6 @@ extern tree purpose_member (const_tree, tree);
extern bool vec_member (const_tree, vec<tree, va_gc> *);
extern tree chain_index (int, tree);
-extern int attribute_list_equal (const_tree, const_tree);
-extern int attribute_list_contained (const_tree, const_tree);
extern int tree_int_cst_equal (const_tree, const_tree);
extern bool tree_fits_shwi_p (const_tree)
@@ -4127,90 +4125,6 @@ extern bool valid_constant_size_p (const_tree);
extern tree make_tree (tree, rtx);
-/* Return a type like TTYPE except that its TYPE_ATTRIBUTES
- is ATTRIBUTE.
-
- Such modified types already made are recorded so that duplicates
- are not made. */
-
-extern tree build_type_attribute_variant (tree, tree);
-extern tree build_decl_attribute_variant (tree, tree);
-extern tree build_type_attribute_qual_variant (tree, tree, int);
-
-extern bool attribute_value_equal (const_tree, const_tree);
-
-/* Return 0 if the attributes for two types are incompatible, 1 if they
- are compatible, and 2 if they are nearly compatible (which causes a
- warning to be generated). */
-extern int comp_type_attributes (const_tree, const_tree);
-
-/* Default versions of target-overridable functions. */
-extern tree merge_decl_attributes (tree, tree);
-extern tree merge_type_attributes (tree, tree);
-
-/* This function is a private implementation detail of lookup_attribute()
- and you should never call it directly. */
-extern tree private_lookup_attribute (const char *, size_t, tree);
-
-/* This function is a private implementation detail
- of lookup_attribute_by_prefix() and you should never call it directly. */
-extern tree private_lookup_attribute_by_prefix (const char *, size_t, tree);
-
-/* Given an attribute name ATTR_NAME and a list of attributes LIST,
- return a pointer to the attribute's list element if the attribute
- is part of the list, or NULL_TREE if not found. If the attribute
- appears more than once, this only returns the first occurrence; the
- TREE_CHAIN of the return value should be passed back in if further
- occurrences are wanted. ATTR_NAME must be in the form 'text' (not
- '__text__'). */
-
-static inline tree
-lookup_attribute (const char *attr_name, tree list)
-{
- gcc_checking_assert (attr_name[0] != '_');
- /* In most cases, list is NULL_TREE. */
- if (list == NULL_TREE)
- return NULL_TREE;
- else
- /* Do the strlen() before calling the out-of-line implementation.
- In most cases attr_name is a string constant, and the compiler
- will optimize the strlen() away. */
- return private_lookup_attribute (attr_name, strlen (attr_name), list);
-}
-
-/* Given an attribute name ATTR_NAME and a list of attributes LIST,
- return a pointer to the attribute's list first element if the attribute
- starts with ATTR_NAME. ATTR_NAME must be in the form 'text' (not
- '__text__'). */
-
-static inline tree
-lookup_attribute_by_prefix (const char *attr_name, tree list)
-{
- gcc_checking_assert (attr_name[0] != '_');
- /* In most cases, list is NULL_TREE. */
- if (list == NULL_TREE)
- return NULL_TREE;
- else
- return private_lookup_attribute_by_prefix (attr_name, strlen (attr_name),
- list);
-}
-
-/* Remove any instances of attribute ATTR_NAME in LIST and return the
- modified list. */
-
-extern tree remove_attribute (const char *, tree);
-
-/* Given two attributes lists, return a list of their union. */
-
-extern tree merge_attributes (tree, tree);
-
-/* Given two Windows decl attributes lists, possibly including
- dllimport, return a list of their union . */
-extern tree merge_dllimport_decl_attributes (tree, tree);
-
-/* Handle a "dllimport" or "dllexport" attribute. */
-extern tree handle_dll_attribute (tree *, tree, tree, int, bool *);
-
/* Returns true iff CAND and BASE have equivalent language-specific
qualifiers. */
diff --git a/gcc/tsan.c b/gcc/tsan.c
index 2f98b936c03345321b1635fdb7df640ed1295c49..51b5821deb33c84bc51c23b6fa65f678ddb9c2ce 100644
--- a/gcc/tsan.c
+++ b/gcc/tsan.c
@@ -40,6 +40,8 @@ along with GCC; see the file COPYING3. If not see
#include "tree-ssa-loop-ivopts.h"
#include "tree-eh.h"
#include "tsan.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
#include "builtins.h"
#include "target.h"
diff --git a/gcc/ubsan.c b/gcc/ubsan.c
index 2580a58b6ebe0257ba1ad58efb9b78a2d1df501f..49e38fa6c09a69432c134b08a2cdf591ae68d58c 100644
--- a/gcc/ubsan.c
+++ b/gcc/ubsan.c
@@ -39,6 +39,8 @@ along with GCC; see the file COPYING3. If not see
#include "cfgloop.h"
#include "ubsan.h"
#include "expr.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
#include "gimplify-me.h"
#include "dfp.h"
diff --git a/gcc/varasm.c b/gcc/varasm.c
index 6eccbe4b3f72d88f0542373026fc0d3fde9bf8ff..e0834a1ff3b074087ee791616efd59d599f3bf10 100644
--- a/gcc/varasm.c
+++ b/gcc/varasm.c
@@ -51,6 +51,8 @@ along with GCC; see the file COPYING3. If not see
#include "langhooks.h"
#include "debug.h"
#include "common/common-target.h"
+#include "stringpool.h"
+#include "attribs.h"
#include "asan.h"
#include "rtl-iter.h"
diff --git a/gcc/varpool.c b/gcc/varpool.c
index ab59c80406ba7ff0b8d4af024c358f1de81b3991..b005f529cc0b95a3888fdfda47f24ad18781cd92 100644
--- a/gcc/varpool.c
+++ b/gcc/varpool.c
@@ -33,6 +33,8 @@ along with GCC; see the file COPYING3. If not see
#include "output.h"
#include "omp-offload.h"
#include "context.h"
+#include "stringpool.h"
+#include "attribs.h"
const char * const tls_model_names[]={"none", "emulated",
"global-dynamic", "local-dynamic",