From 9c6ce143b31137a4799d3ebc0aa8901ed9d75404 Mon Sep 17 00:00:00 2001 From: huzife <634763349@qq.com> Date: Fri, 11 Jul 2025 15:46:47 +0800 Subject: [PATCH] Fix build error in bootstrap --- SOURCES/gcc8-fix-build-error.patch | 1433 ++++++++++++++++++++++++++++ SPECS/gcc.spec | 2 + 2 files changed, 1435 insertions(+) create mode 100644 SOURCES/gcc8-fix-build-error.patch diff --git a/SOURCES/gcc8-fix-build-error.patch b/SOURCES/gcc8-fix-build-error.patch new file mode 100644 index 0000000..ac9c75e --- /dev/null +++ b/SOURCES/gcc8-fix-build-error.patch @@ -0,0 +1,1433 @@ +diff --git a/gcc/ipa-alignment-propagation.c b/gcc/ipa-alignment-propagation.c +index c634f3237..2ed6553df 100644 +--- a/gcc/ipa-alignment-propagation.c ++++ b/gcc/ipa-alignment-propagation.c +@@ -58,7 +58,7 @@ private: + bool candidate_stmt_p (gimple *stmt); + + private: +- cgraph_node *node = nullptr; ++ cgraph_node *node = NULL; + hash_map alignment_map; + }; + +@@ -109,7 +109,7 @@ alignment_propagator::transform () + basic_block bb; + FOR_EACH_BB_FN (bb, cfun) + { +- for (auto gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) ++ for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) + { + gimple *stmt = gsi_stmt (gsi); + if (!candidate_stmt_p (stmt)) +@@ -140,7 +140,7 @@ size_t + alignment_propagator::get_param_alignment (unsigned param_index) + { + size_t alignment = 0; +- for (auto e = node->callers; e; e = e->next_caller) ++ for (cgraph_edge *e = node->callers; e; e = e->next_caller) + { + if (e->caller == node) + continue; +@@ -276,7 +276,7 @@ alignment_propagator::check_param (tree t, auto_vec &worklist, + worklist.safe_push (arg); + else + { +- auto *align = alignment_map.get (SSA_NAME_VAR (t)); ++ size_t *align = alignment_map.get (SSA_NAME_VAR (t)); + if (!align) + return false; + +@@ -317,8 +317,8 @@ alignment_propagator::get_arg_alignment (cgraph_node *caller, tree arg) + + cfun_saver save (caller); + +- tree base = nullptr; +- tree offset = nullptr; ++ tree base = NULL; ++ tree offset = NULL; + + /* Extract base and offset. */ + if (TREE_CODE (arg) == ADDR_EXPR) +@@ -365,7 +365,7 @@ alignment_propagator::get_arg_alignment (cgraph_node *caller, tree arg) + if (TREE_CODE (offset) != INTEGER_CST) + return 0; + +- auto value = abs_value (offset); ++ unsigned HOST_WIDE_INT value = abs_value (offset); + if (!pow2_or_zerop (value)) + return 0; + +@@ -397,7 +397,7 @@ size_t + alignment_propagator::abs_value (tree t) + { + gcc_assert (TREE_CODE (t) == INTEGER_CST); +- auto value = TREE_INT_CST_LOW (t); ++ unsigned HOST_WIDE_INT value = TREE_INT_CST_LOW (t); + + return std::abs (static_cast (value)); + } +@@ -432,7 +432,7 @@ ipa_propagate_alignment (void) + candidate_nodes.safe_push (cnode); + } + +- for (auto *node : candidate_nodes) ++ for (cgraph_node *node : candidate_nodes) + alignment_propagator (node).execute (); + + return 0; +diff --git a/gcc/ipa-array-dse.c b/gcc/ipa-array-dse.c +index bdf8599d2..c1c42e7a2 100644 +--- a/gcc/ipa-array-dse.c ++++ b/gcc/ipa-array-dse.c +@@ -63,7 +63,7 @@ static tree + strip_base (tree addr) + { + tree base = get_base_address (addr); +- return TREE_CODE (base) == MEM_REF ? TREE_OPERAND (base, 0) : nullptr; ++ return TREE_CODE (base) == MEM_REF ? TREE_OPERAND (base, 0) : NULL; + } + + static tree +@@ -129,7 +129,7 @@ opposite_cond_code (tree_code code) + + static int + calc_loop_var_step (tree loop_var, tree iterate_var, +- hash_set *iterate_stmts = nullptr) ++ hash_set *iterate_stmts = NULL) + { + int step = 0; + auto_bitmap visited; +@@ -224,19 +224,19 @@ infinite_p (tree value) + { + tree type = TREE_TYPE (value); + if (TREE_CODE (value) != INTEGER_CST || TYPE_PRECISION (type) == 1) +- return infinite_kind::NON_INF; ++ return IK_NON_INF; + + wide_int type_min = wi::min_value (TYPE_PRECISION (type), TYPE_SIGN (type)); + wide_int type_max = wi::max_value (TYPE_PRECISION (type), TYPE_SIGN (type)); + + if (INTEGRAL_TYPE_P (type) && !TYPE_UNSIGNED (type) + && wi::to_wide (value) == type_min) +- return infinite_kind::NINF; ++ return IK_NINF; + + if (wi::to_wide (value) == type_max) +- return infinite_kind::INF; ++ return IK_INF; + +- return infinite_kind::NON_INF; ++ return IK_NON_INF; + } + + static inline HOST_WIDE_INT +@@ -279,11 +279,11 @@ static tree + negate_tree (tree t) + { + if (!t) +- return nullptr; ++ return NULL; + +- if (infinite_p (t) == infinite_kind::INF) ++ if (infinite_p (t) == IK_INF) + return build_value (RANGE_NINF); +- else if (infinite_p (t) == infinite_kind::NINF) ++ else if (infinite_p (t) == IK_NINF) + return build_value (RANGE_INF); + else + return fold_build1 (NEGATE_EXPR, RANGE_TYPE, t); +@@ -293,19 +293,19 @@ static tree + plus_tree (tree t1, tree t2) + { + if (!t1 || !t2) +- return nullptr; ++ return NULL; + + infinite_kind inf1 = infinite_p (t1); + infinite_kind inf2 = infinite_p (t2); + +- if ((inf1 == infinite_kind::INF && inf2 == infinite_kind::NINF) +- || (inf1 == infinite_kind::NINF && inf2 == infinite_kind::INF)) +- return nullptr; ++ if ((inf1 == IK_INF && inf2 == IK_NINF) ++ || (inf1 == IK_NINF && inf2 == IK_INF)) ++ return NULL; + +- if (inf1 == infinite_kind::NINF || inf2 == infinite_kind::NINF) ++ if (inf1 == IK_NINF || inf2 == IK_NINF) + return build_value (RANGE_NINF); + +- if (inf1 == infinite_kind::INF || inf2 == infinite_kind::INF) ++ if (inf1 == IK_INF || inf2 == IK_INF) + return build_value (RANGE_INF); + + tree ret = fold_build2 (PLUS_EXPR, RANGE_TYPE, t1, t2); +@@ -318,19 +318,19 @@ static tree + minus_tree (tree t1, tree t2) + { + if (!t1 || !t2) +- return nullptr; ++ return NULL; + + infinite_kind inf1 = infinite_p (t1); + infinite_kind inf2 = infinite_p (t2); + +- if ((inf1 == infinite_kind::INF && inf2 == infinite_kind::INF) +- || (inf1 == infinite_kind::NINF && inf2 == infinite_kind::NINF)) +- return nullptr; ++ if ((inf1 == IK_INF && inf2 == IK_INF) ++ || (inf1 == IK_NINF && inf2 == IK_NINF)) ++ return NULL; + +- if (inf1 == infinite_kind::NINF || inf2 == infinite_kind::INF) ++ if (inf1 == IK_NINF || inf2 == IK_INF) + return build_value (RANGE_NINF); + +- if (inf1 == infinite_kind::INF || inf2 == infinite_kind::NINF) ++ if (inf1 == IK_INF || inf2 == IK_NINF) + return build_value (RANGE_INF); + + tree ret = fold_build2 (MINUS_EXPR, RANGE_TYPE, t1, t2); +@@ -340,7 +340,7 @@ minus_tree (tree t1, tree t2) + } + + /* Callback for walk_tree, usage: +- walk_tree (&A, sub_expr_p, B, nullptr) ++ walk_tree (&A, sub_expr_p, B, NULL) + + Check if B is sub expr of A. + */ +@@ -417,7 +417,7 @@ addr_analyzer::get_address (tree var) + tree + addr_analyzer::analyze_address (tree var) + { +- tree addr = nullptr; ++ tree addr = NULL; + auto_bitmap visited; + auto_vec worklist; + worklist.safe_push (var); +@@ -426,7 +426,7 @@ addr_analyzer::analyze_address (tree var) + { + tree t = worklist.pop (); + if (TREE_CODE (t) != SSA_NAME || !POINTER_TYPE_P (TREE_TYPE (t))) +- return nullptr; ++ return NULL; + + if (!bitmap_set_bit (visited, SSA_NAME_VERSION (t))) + continue; +@@ -435,7 +435,7 @@ addr_analyzer::analyze_address (tree var) + { + tree new_addr = SSA_NAME_VAR (t); + if (!new_addr || (addr && addr != new_addr)) +- return nullptr; ++ return NULL; + + addr = new_addr; + continue; +@@ -447,7 +447,7 @@ addr_analyzer::analyze_address (tree var) + if (!gimple_assign_single_p (def_stmt) + && !gimple_assign_cast_p (def_stmt) + && gimple_assign_rhs_code (def_stmt) != POINTER_PLUS_EXPR) +- return nullptr; ++ return NULL; + + worklist.safe_push (gimple_assign_rhs1 (def_stmt)); + } +@@ -457,7 +457,7 @@ addr_analyzer::analyze_address (tree var) + worklist.safe_push (gimple_phi_arg_def (def_stmt, i)); + } + else +- return nullptr; ++ return NULL; + } + + return addr; +@@ -489,18 +489,18 @@ tree + array_dse_callee::mult_tree (basic_block bb, tree t1, tree t2) + { + if (!bb || !t1 || !t2 || !integer_cst_p (t2) +- || infinite_p (t2) != infinite_kind::NON_INF) +- return nullptr; ++ || infinite_p (t2) != IK_NON_INF) ++ return NULL; + + if (integer_zerop (t1) || integer_zerop (t2)) + return integer_zero_node; + + int_range range1 = calc_tree_range (bb, t1); + if (tree_to_shwi (range1.min ()) < 0) +- return nullptr; ++ return NULL; + + HOST_WIDE_INT multiplier = tree_to_shwi (t2); +- if (infinite_p (t1) != infinite_kind::NON_INF) ++ if (infinite_p (t1) != IK_NON_INF) + return build_value (multiplier > 0 ? RANGE_INF : RANGE_NINF); + + return fold_build2 (MULT_EXPR, RANGE_TYPE, t1, t2); +@@ -510,22 +510,22 @@ tree + array_dse_callee::div_tree (basic_block bb, tree t1, tree t2) + { + if (!bb || !t1 || !t2 || !integer_cst_p (t2) +- || infinite_p (t2) != infinite_kind::NON_INF) +- return nullptr; ++ || infinite_p (t2) != IK_NON_INF) ++ return NULL; + + if (integer_zerop (t2)) +- return nullptr; ++ return NULL; + + if (integer_zerop (t1)) + return integer_zero_node; + + int_range range1 = calc_tree_range (bb, t1); + if (tree_to_shwi (range1.min ()) < 0) +- return nullptr; ++ return NULL; + + HOST_WIDE_INT divisor = tree_to_shwi (t2); + +- if (infinite_p (t1) != infinite_kind::NON_INF) ++ if (infinite_p (t1) != IK_NON_INF) + return build_value (divisor > 0 ? RANGE_INF : RANGE_NINF); + + return fold_build2 (TRUNC_DIV_EXPR, RANGE_TYPE, t1, t2); +@@ -535,9 +535,9 @@ tree + array_dse_callee::lshift_tree (tree t1, tree t2) + { + if (!t1 || !t2 || !integer_cst_p (t2)) +- return nullptr; ++ return NULL; + +- if (infinite_p (t1) != infinite_kind::NON_INF) ++ if (infinite_p (t1) != IK_NON_INF) + return t1; + + return fold_build2 (LSHIFT_EXPR, RANGE_TYPE, t1, t2); +@@ -547,9 +547,9 @@ tree + array_dse_callee::rshift_tree (tree t1, tree t2) + { + if (!t1 || !t2 || !integer_cst_p (t2)) +- return nullptr; ++ return NULL; + +- if (infinite_p (t1) != infinite_kind::NON_INF) ++ if (infinite_p (t1) != IK_NON_INF) + return t1; + + return fold_build2 (RSHIFT_EXPR, RANGE_TYPE, t1, t2); +@@ -559,7 +559,7 @@ tree + array_dse_callee::max_tree (basic_block bb, tree t1, tree t2) + { + if (!bb || !t1 || !t2) +- return nullptr; ++ return NULL; + + switch (compare_tree (bb, t1, t2)) + { +@@ -568,7 +568,7 @@ array_dse_callee::max_tree (basic_block bb, tree t1, tree t2) + case GE: return t1; + case LT: return t2; + case LE: return t2; +- default: return nullptr; ++ default: return NULL; + } + } + +@@ -576,7 +576,7 @@ tree + array_dse_callee::min_tree (basic_block bb, tree t1, tree t2) + { + if (!bb || !t1 || !t2) +- return nullptr; ++ return NULL; + + switch (compare_tree (bb, t1, t2)) + { +@@ -585,7 +585,7 @@ array_dse_callee::min_tree (basic_block bb, tree t1, tree t2) + case GE: return t2; + case LT: return t1; + case LE: return t1; +- default: return nullptr; ++ default: return NULL; + } + } + +@@ -687,8 +687,8 @@ int_range + array_dse_callee::build_range (basic_block bb, tree_code op, + const int_range &r1, const int_range &r2) + { +- tree min = nullptr; +- tree max = nullptr; ++ tree min = NULL; ++ tree max = NULL; + switch (op) + { + case NEGATE_EXPR: +@@ -696,13 +696,11 @@ array_dse_callee::build_range (basic_block bb, tree_code op, + max = negate_tree (r1.min ()); + break; + case PLUS_EXPR: +- [[fallthrough]]; + case POINTER_PLUS_EXPR: + min = plus_tree (r1.min (), r2.min ()); + max = plus_tree (r1.max (), r2.max ()); + break; + case MINUS_EXPR: +- [[fallthrough]]; + case POINTER_DIFF_EXPR: + min = minus_tree (r1.min(), r2.max ()); + max = minus_tree (r1.max(), r2.min ()); +@@ -821,7 +819,7 @@ bool + array_dse_callee::find_main_vars () + { + auto_bitmap visited; +- tree default_def[PARAM_NUM] = {nullptr, nullptr}; ++ tree default_def[PARAM_NUM] = {NULL, NULL}; + + /* Collect all params' default def. */ + unsigned i; +@@ -862,15 +860,15 @@ array_dse_callee::find_main_vars () + void + array_dse_callee::find_tail_recursive_loop (tree *default_def) + { +- tree main_loop_var[PARAM_NUM] = {nullptr, nullptr}; +- loop_p unique_loop = nullptr; ++ tree main_loop_var[PARAM_NUM] = {NULL, NULL}; ++ loop_p unique_loop = NULL; + + for (unsigned i = 0; i < PARAM_NUM; i++) + { + tree name = default_def[i]; + + use_operand_p use_p; +- gimple *stmt = nullptr; ++ gimple *stmt = NULL; + if (!single_imm_use (name, &use_p, &stmt) + || gimple_code (stmt) != GIMPLE_PHI) + return; +@@ -910,7 +908,7 @@ array_dse_callee::find_tail_recursive_loop (tree *default_def) + bool + array_dse_callee::find_candidate_array () + { +- tree unique_array = nullptr; ++ tree unique_array = NULL; + basic_block bb; + FOR_EACH_BB_FN (bb, cfun) + { +@@ -974,7 +972,7 @@ array_dse_callee::find_length_param () + { + collect_read_write_ptrs (); + +- tree len = nullptr; ++ tree len = NULL; + unsigned size = 0; + for (tree ptr : all_ptrs) + if (!check_pointer (ptr, len, size)) +@@ -1146,11 +1144,8 @@ array_dse_callee::check_offset (tree var, tree &len, unsigned &size, + switch (gimple_assign_rhs_code (stmt)) + { + case MAX_EXPR: +- [[fallthrough]]; + case MIN_EXPR: +- [[fallthrough]]; + case PLUS_EXPR: +- [[fallthrough]]; + case MINUS_EXPR: + return check_offset (gimple_assign_rhs1 (stmt), len, size, worklist) + && check_offset (gimple_assign_rhs2 (stmt), len, size, +@@ -1286,8 +1281,8 @@ array_dse_callee::calc_len_range () + if (cond_range.undefined_p ()) + continue; + +- edge true_edge = nullptr; +- edge false_edge = nullptr; ++ edge true_edge = NULL; ++ edge false_edge = NULL; + extract_true_false_edges_from_block (bb, &true_edge, &false_edge); + update_len_range (true_edge->dest, cond_range); + update_len_range (false_edge->dest, invert_range (cond_range)); +@@ -1405,7 +1400,7 @@ array_dse_callee::get_var_range (basic_block bb, tree var) + return range; + + tree rhs1 = gimple_assign_rhs1 (stmt); +- tree rhs2 = gimple_num_ops (stmt) > 2 ? gimple_assign_rhs2 (stmt) : nullptr; ++ tree rhs2 = gimple_num_ops (stmt) > 2 ? gimple_assign_rhs2 (stmt) : NULL; + int_range range1 = get_var_range (bb, rhs1); + int_range range2 = int_range{RANGE_TYPE}; + if (rhs2) +@@ -1577,12 +1572,12 @@ array_dse_callee::collect_recursive_call_args ( + auto_vec &array_args, auto_vec &len_args, + auto_vec &blocks, auto_vec &is_tail_recursive_call) + { +- for (cgraph_edge *edge = node->callees; edge; edge = edge->next_callee) ++ for (cgraph_edge *e = node->callees; e; e = e->next_callee) + { +- if (node != edge->callee) ++ if (node != e->callee) + continue; + +- gcall *call = edge->call_stmt; ++ gcall *call = e->call_stmt; + tree array_arg = gimple_call_arg (call, array_param_index); + tree len_arg = gimple_call_arg (call, len_param_index); + +@@ -1638,13 +1633,11 @@ array_dse_callee::update_branch_range (basic_block bb) + { + case LT_EXPR: + value--; +- [[fallthrough]]; + case LE_EXPR: + max = min_tree (bb, max, build_value (value)); + break; + case GT_EXPR: + value++; +- [[fallthrough]]; + case GE_EXPR: + min = max_tree (bb, min, build_value (value)); + break; +@@ -1669,44 +1662,44 @@ tree + array_dse_callee::build_recursive_offset (tree len_arg) + { + if (TREE_CODE (len_arg) != SSA_NAME) +- return nullptr; ++ return NULL; + + gimple *stmt = SSA_NAME_DEF_STMT (len_arg); + if (!is_gimple_assign (stmt)) +- return nullptr; ++ return NULL; + + /* Check pattern: (ptr1 - ptr2) / elem_size. */ + tree_code code = gimple_assign_rhs_code (stmt); + if (code != TRUNC_DIV_EXPR && code != RSHIFT_EXPR) +- return nullptr; ++ return NULL; + + tree rhs1 = gimple_assign_rhs1 (stmt); + if (TREE_CODE (rhs1) != SSA_NAME) +- return nullptr; ++ return NULL; + + gimple *def = SSA_NAME_DEF_STMT (strip_ssa_copy (rhs1)); + if (!is_gimple_assign (def) + || gimple_assign_rhs_code (def) != POINTER_DIFF_EXPR) +- return nullptr; ++ return NULL; + + /* Check ptr1 and ptr2. */ +- tree len = nullptr; ++ tree len = NULL; + unsigned size = 0; + if (!check_pointer (gimple_assign_rhs1 (def), len, size) + || !check_pointer (gimple_assign_rhs2 (def), len, size) + || len != len_main_var || size != elem_size_cst) +- return nullptr; ++ return NULL; + + tree rhs2 = gimple_assign_rhs2 (stmt); + if (!integer_cst_p (rhs2)) +- return nullptr; ++ return NULL; + + HOST_WIDE_INT value = TREE_INT_CST_LOW (rhs2); + if (code == RSHIFT_EXPR) + value = 1 << value; + + if (value != elem_size_cst) +- return nullptr; ++ return NULL; + + return rhs1; + } +@@ -1719,9 +1712,9 @@ array_dse_callee::build_recursive_ptr_range_max (basic_block bb, + tree offset) + { + if (TREE_CODE (array_arg) != SSA_NAME) +- return nullptr; ++ return NULL; + +- tree recursive_ptr_max = nullptr; ++ tree recursive_ptr_max = NULL; + gimple *stmt = SSA_NAME_DEF_STMT (array_arg); + + /* If ARRAY_ARG = rhs1 - offset, return rhs1's range max directly. */ +@@ -1847,7 +1840,7 @@ array_dse_callee::check_loop_exits (loop_p loop) + if (!lhs_cand_p && !rhs_cand_p) + continue; + +- tree step = nullptr; ++ tree step = NULL; + if (POINTER_TYPE_P (TREE_TYPE (lhs)) + && POINTER_TYPE_P (TREE_TYPE (rhs))) + { +@@ -1965,15 +1958,15 @@ array_dse_callee::fill_loop_ptr_range (loop_p loop, basic_block bb, + int_range &range = var_range[ptr][bb]; + tree min = range.min (); + tree max = range.max (); +- if (infinite_p (min) != infinite_kind::NON_INF) ++ if (infinite_p (min) != IK_NON_INF) + { +- if (infinite_p (max) != infinite_kind::NON_INF) ++ if (infinite_p (max) != IK_NON_INF) + return false; + min = minus_tree (max, length); + } +- else if (infinite_p (max) != infinite_kind::NON_INF) ++ else if (infinite_p (max) != IK_NON_INF) + { +- if (infinite_p (min) != infinite_kind::NON_INF) ++ if (infinite_p (min) != IK_NON_INF) + return false; + max = plus_tree (min, length); + } +@@ -2009,9 +2002,9 @@ tree + array_dse_callee::get_loop_var (loop_p loop, tree var) + { + if (TREE_CODE (var) != SSA_NAME || !SSA_NAME_VAR (var)) +- return nullptr; ++ return NULL; + +- tree result = nullptr; ++ tree result = NULL; + + auto_bitmap visited; + auto_vec worklist; +@@ -2021,7 +2014,7 @@ array_dse_callee::get_loop_var (loop_p loop, tree var) + { + tree t = worklist.pop (); + if (TREE_CODE (var) != SSA_NAME) +- return nullptr; ++ return NULL; + + if (!bitmap_set_bit (visited, SSA_NAME_VERSION (t))) + continue; +@@ -2029,7 +2022,7 @@ array_dse_callee::get_loop_var (loop_p loop, tree var) + if (loop_var_p (loop, t) && SSA_NAME_VAR (t) == SSA_NAME_VAR (var)) + { + if (result && result != t) +- return nullptr; ++ return NULL; + result = t; + continue; + } +@@ -2037,7 +2030,7 @@ array_dse_callee::get_loop_var (loop_p loop, tree var) + gimple *stmt = SSA_NAME_DEF_STMT (t); + basic_block bb = gimple_bb (stmt); + if (!bb || !flow_bb_inside_loop_p (loop, gimple_bb (stmt))) +- return nullptr; ++ return NULL; + + if (gimple_code (stmt) == GIMPLE_PHI) + { +@@ -2049,7 +2042,7 @@ array_dse_callee::get_loop_var (loop_p loop, tree var) + if (!is_gimple_assign (stmt) + || (gimple_assign_rhs_code (stmt) != POINTER_PLUS_EXPR + && gimple_assign_rhs_code (stmt) != PLUS_EXPR)) +- return nullptr; ++ return NULL; + + worklist.safe_push (gimple_assign_rhs1 (stmt)); + } +@@ -2060,7 +2053,7 @@ array_dse_callee::get_loop_var (loop_p loop, tree var) + bool + array_dse_callee::find_var_range (tree var, basic_block bb) + { +- std::map>::iterator iter1 = var_range.find (var); ++ std::map >::iterator iter1 = var_range.find (var); + if (iter1 == var_range.end ()) + return false; + +@@ -2134,7 +2127,7 @@ array_dse_edge::check_array_usage () + if (!find_inner_array ()) + return false; + +- for (auto p : array_accesses) ++ for (std::pair p : array_accesses) + if (!check_access_kind (p.second, p.first)) + return false; + +@@ -2162,14 +2155,14 @@ array_dse_edge::collect_array_accesses () + { + gphi *phi = as_a (gsi_stmt (gsi)); + tree result = gimple_phi_result (phi); +- if (walk_tree (&result, sub_expr_p, array, nullptr)) ++ if (walk_tree (&result, sub_expr_p, array, NULL)) + if (!check_array_access (phi, result)) + return false; + + for (unsigned i = 0; i < gimple_phi_num_args (phi); i++) + { + tree arg = gimple_phi_arg_def (phi, i); +- if (!walk_tree (&arg, sub_expr_p, array, nullptr)) ++ if (!walk_tree (&arg, sub_expr_p, array, NULL)) + continue; + + if (!check_array_access (phi, arg)) +@@ -2189,7 +2182,7 @@ array_dse_edge::collect_array_accesses () + if (!var) + continue; + +- if (!walk_tree (&var, sub_expr_p, array, nullptr)) ++ if (!walk_tree (&var, sub_expr_p, array, NULL)) + continue; + + if (!is_gimple_assign (stmt)) +@@ -2291,7 +2284,7 @@ array_dse_edge::check_access_from_address (tree addr) + for (unsigned i = 0; i < gimple_num_ops (stmt); i++) + { + tree op = gimple_op (stmt, i); +- if (walk_tree (&op, sub_expr_p, addr, nullptr) ++ if (walk_tree (&op, sub_expr_p, addr, NULL) + && !check_array_access (stmt, op)) + return false; + } +@@ -2339,19 +2332,19 @@ array_dse_edge::check_access_kind_iterate (tree var, auto_bitmap &visited) + int kind = NONE; + + imm_use_iterator iter; +- gimple *stmt = nullptr; ++ gimple *stmt = NULL; + FOR_EACH_IMM_USE_STMT (stmt, iter, var) + { +- if (walk_stmt_load_store_ops (stmt, var, find_base, nullptr)) ++ if (walk_stmt_load_store_ops (stmt, var, find_base, NULL)) + kind |= READ; + +- if (walk_stmt_load_store_ops (stmt, var, nullptr, find_base)) ++ if (walk_stmt_load_store_ops (stmt, var, NULL, find_base)) + kind |= WRITE; + + if (kind) + continue; + +- tree next_var = nullptr; ++ tree next_var = NULL; + if (is_gimple_assign (stmt)) + { + if ((!gimple_assign_single_p (stmt) && !gimple_assign_cast_p (stmt)) +@@ -2384,7 +2377,7 @@ array_dse_edge::check_access_kind_iterate (tree var, auto_bitmap &visited) + access_kind next_kind = check_access_kind_iterate (next_var, visited); + if (next_kind == ACCESS_ERROR) + return ACCESS_ERROR; +- ++ + kind |= next_kind; + } + +@@ -2412,7 +2405,7 @@ array_dse_edge::find_inner_array () + + inner_elem_type = TREE_TYPE (TREE_TYPE (type)); + +- for (auto p : array_accesses) ++ for (std::pair p : array_accesses) + { + tree var = p.first; + gimple *stmt = p.second; +@@ -2479,7 +2472,7 @@ array_dse_edge::unique_use_p (tree var, gimple *unique_assign) const + continue; + + imm_use_iterator iter; +- gimple *stmt = nullptr; ++ gimple *stmt = NULL; + FOR_EACH_IMM_USE_STMT (stmt, iter, t) + { + if (gimple_call_builtin_p (stmt, BUILT_IN_FREE)) +@@ -2520,7 +2513,7 @@ array_dse_edge::initialize_assign_p (gimple *stmt) const + worklist.safe_push (e->src); + } + +- for (auto p : array_accesses) ++ for (std::pair p : array_accesses) + { + gimple *access_stmt = p.second; + if (access_stmt == stmt) +@@ -2536,7 +2529,7 @@ array_dse_edge::initialize_assign_p (gimple *stmt) const + bool + array_dse_edge::calc_read_bound () + { +- for (auto p : array_accesses) ++ for (std::pair p : array_accesses) + { + tree var = p.first; + gimple *stmt = p.second; +@@ -2764,7 +2757,7 @@ array_dse_edge::check_full_write_elem (basic_block bb, tree index) + { + hash_set visited_fields; + +- for (auto p : array_accesses) ++ for (std::pair p : array_accesses) + { + tree var = p.first; + gimple *stmt = p.second; +@@ -2788,7 +2781,7 @@ array_dse_edge::check_full_write_elem (basic_block bb, tree index) + continue; + + imm_use_iterator iter; +- gimple *use_stmt = nullptr; ++ gimple *use_stmt = NULL; + FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs) + { + tree ref = gimple_get_lhs_or_phi_result (use_stmt); +@@ -2920,7 +2913,6 @@ array_dse_edge::check_len_arg_lower_bound () + len_arg_min = std::max (len_arg_min, rvalue + 1); + break; + case GE_EXPR: +- [[fallthrough]]; + case EQ_EXPR: + len_arg_min = std::max (len_arg_min, rvalue); + break; +@@ -3142,7 +3134,7 @@ ipa_array_dse::apply_array_dse (array_dse_edge *ad_edge) + unlink_stmt_vdef (call_stmt); + if (gsi_remove (&gsi, true)) + gimple_purge_dead_eh_edges (call_bb); +- cgraph_update_edges_for_call_stmt (call_stmt, fndecl, nullptr); ++ cgraph_update_edges_for_call_stmt (call_stmt, fndecl, NULL); + + return true; + } +@@ -3225,12 +3217,12 @@ ipa_array_dse::find_array_main_var (array_dse_callee *callee) + gimple *stmt; + if (!single_imm_use (name, &use_p, &stmt) + || gimple_code (stmt) != GIMPLE_PHI) +- return nullptr; ++ return NULL; + + return gimple_phi_result (stmt); + } + +- return nullptr; ++ return NULL; + } + + bool +@@ -3261,14 +3253,14 @@ ipa_array_dse::transform_new_callee (array_dse_callee *callee, + } + + gimple_stmt_iterator gsi = gsi_last_bb (e->src); +- gimple *cond = gimple_build_cond (GE_EXPR, array, bound_ssa, nullptr, +- nullptr); ++ gimple *cond = gimple_build_cond (GE_EXPR, array, bound_ssa, NULL, ++ NULL); + gsi_insert_after (&gsi, cond, GSI_NEW_STMT); + + edge return_edge = make_edge (e->src, EXIT_BLOCK_PTR_FOR_FN (cfun), 0); + basic_block return_bb = split_edge (return_edge); + gimple_stmt_iterator return_gsi = gsi_last_bb (return_bb); +- gsi_insert_after (&return_gsi, gimple_build_return (nullptr), GSI_NEW_STMT); ++ gsi_insert_after (&return_gsi, gimple_build_return (NULL), GSI_NEW_STMT); + + e->flags &= ~EDGE_FALLTHRU; + e->flags |= EDGE_FALSE_VALUE; +diff --git a/gcc/ipa-array-dse.h b/gcc/ipa-array-dse.h +index 5b56cd456..5d037303a 100644 +--- a/gcc/ipa-array-dse.h ++++ b/gcc/ipa-array-dse.h +@@ -56,11 +56,11 @@ enum access_kind + ACCESS_ERROR = 4 + }; + +-enum class infinite_kind ++enum infinite_kind + { +- NON_INF, +- INF, +- NINF ++ IK_NON_INF, ++ IK_INF, ++ IK_NINF + }; + + /* Address analyzer. */ +@@ -144,20 +144,20 @@ private: + bool find_var_range (tree var, basic_block bb); + + public: +- cgraph_node *node = nullptr; +- tree array_param = nullptr; +- tree len_param = nullptr; ++ cgraph_node *node = NULL; ++ tree array_param = NULL; ++ tree len_param = NULL; + int array_param_index = -1; + int len_param_index = -1; +- tree array_main_var = nullptr; +- tree len_main_var = nullptr; +- tree signed_len_var = nullptr; +- tree elem_size = nullptr; ++ tree array_main_var = NULL; ++ tree len_main_var = NULL; ++ tree signed_len_var = NULL; ++ tree elem_size = NULL; + unsigned elem_size_cst = 0; + +- loop_p main_loop = nullptr; ++ loop_p main_loop = NULL; + +- static constexpr unsigned PARAM_NUM = 2; ++ static const unsigned PARAM_NUM = 2; + + private: + addr_analyzer analyzer; +@@ -166,11 +166,11 @@ private: + hash_set visited_offset; + hash_map branch_start_map; + hash_map len_range_map; +- std::map> var_range; +- std::map> loop_ptrs; ++ std::map > var_range; ++ std::map > loop_ptrs; + hash_set unreachable_blocks; + +- static constexpr unsigned HOST_WIDE_INT len_param_min = 1; ++ static const unsigned HOST_WIDE_INT len_param_min = 1; + unsigned HOST_WIDE_INT len_param_max = 0; + }; + +@@ -219,16 +219,16 @@ private: + bool array_addr_p (tree var); + + public: +- cgraph_edge *call_edge = nullptr; +- array_dse_callee *callee = nullptr; ++ cgraph_edge *call_edge = NULL; ++ array_dse_callee *callee = NULL; + +- tree array = nullptr; ++ tree array = NULL; + + private: + unsigned array_size = 0; + unsigned elem_size = 0; +- tree inner_array = nullptr; +- tree inner_elem_type = nullptr; ++ tree inner_array = NULL; ++ tree inner_elem_type = NULL; + + hash_map array_accesses; + hash_map access_kinds; +diff --git a/gcc/ipa-localize-array.c b/gcc/ipa-localize-array.c +index 8b92f936b..481144fb0 100644 +--- a/gcc/ipa-localize-array.c ++++ b/gcc/ipa-localize-array.c +@@ -63,16 +63,16 @@ private: + void remove_orig_alloc_free (); + + private: +- varpool_node *var = nullptr; +- tree var_type = nullptr; +- ipa_ref *alloc_ref = nullptr; +- ipa_ref *free_ref = nullptr; +- gimple *alloc_stmt = nullptr; +- gimple *free_stmt = nullptr; +- cgraph_node *caller = nullptr; +- cgraph_node *callee = nullptr; +- cgraph_edge *call_edge = nullptr; +- gimple *call_stmt = nullptr; ++ varpool_node *var = NULL; ++ tree var_type = NULL; ++ ipa_ref *alloc_ref = NULL; ++ ipa_ref *free_ref = NULL; ++ gimple *alloc_stmt = NULL; ++ gimple *free_stmt = NULL; ++ cgraph_node *caller = NULL; ++ cgraph_node *callee = NULL; ++ cgraph_edge *call_edge = NULL; ++ gimple *call_stmt = NULL; + + bool scalar_alloc_p = false; + +@@ -142,7 +142,7 @@ array_localizer::scalar_memop_p (tree ref_val, gimple *use_stmt) + tree lhs = gimple_assign_lhs (use_stmt); + if (TREE_CODE (lhs) == SSA_NAME) + { +- gimple *stmt = nullptr; ++ gimple *stmt = NULL; + imm_use_iterator iter; + FOR_EACH_IMM_USE_STMT (stmt, iter, lhs) + if ((!gimple_assign_load_p (stmt) && !gimple_store_p (stmt)) || +@@ -175,7 +175,7 @@ array_localizer::scalar_memop_p (tree ref_val, gimple *use_stmt) + + /* Exclude address-escape case like *var = var */ + ssa_op_iter iter; +- tree use = nullptr; ++ tree use = NULL; + int use_count = 0; + FOR_EACH_SSA_TREE_OPERAND (use, use_stmt, iter, SSA_OP_USE) + if (operand_equal_p (use, ref_val) && use_count++) +@@ -208,15 +208,15 @@ gimple * + array_localizer::find_calloc_stmt (gimple *stmt) + { + if (!gimple_assign_single_p (stmt)) +- return nullptr; ++ return NULL; + + tree rhs = gimple_assign_rhs1 (stmt); + if (TREE_CODE (rhs) != SSA_NAME || !has_single_use (rhs)) +- return nullptr; ++ return NULL; + + gimple *def_stmt = SSA_NAME_DEF_STMT (rhs); + if (!gimple_call_builtin_p (def_stmt, BUILT_IN_CALLOC)) +- return nullptr; ++ return NULL; + + return def_stmt; + } +@@ -224,13 +224,13 @@ array_localizer::find_calloc_stmt (gimple *stmt) + gimple * + array_localizer::find_free_stmt (tree var) + { +- use_operand_p use_p = nullptr; +- gimple *use_stmt = nullptr; ++ use_operand_p use_p = NULL; ++ gimple *use_stmt = NULL; + if (TREE_CODE (var) != SSA_NAME || !single_imm_use (var, &use_p, &use_stmt)) +- return nullptr; ++ return NULL; + + if (!gimple_call_builtin_p (use_stmt, BUILT_IN_FREE)) +- return nullptr; ++ return NULL; + + return use_stmt; + } +@@ -238,7 +238,7 @@ array_localizer::find_free_stmt (tree var) + bool + array_localizer::check_var_store () + { +- ipa_ref *ref = nullptr; ++ ipa_ref *ref = NULL; + for (unsigned i = 0; var->iterate_referring (i, ref); i++) + { + cgraph_node *node = dyn_cast (ref->referring); +@@ -280,13 +280,13 @@ array_localizer::check_var_store () + } + } + +- return alloc_ref != nullptr; ++ return alloc_ref != NULL; + } + + bool + array_localizer::check_var_load () + { +- ipa_ref *ref = nullptr; ++ ipa_ref *ref = NULL; + for (unsigned i = 0; var->iterate_referring (i, ref); i++) + { + if (ref->use == IPA_REF_STORE) +@@ -318,7 +318,7 @@ array_localizer::check_var_load () + } + } + +- gimple *use_stmt = nullptr; ++ gimple *use_stmt = NULL; + imm_use_iterator iter; + FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs) + { +@@ -456,7 +456,7 @@ array_localizer::rewrite_array () + rewrite_access_in_callee (var_ssa); + remove_orig_alloc_free (); + +- for (auto stmt : removed_stmts) ++ for (gimple *stmt : removed_stmts) + caller->remove_stmt_references (stmt); + } + +@@ -503,7 +503,7 @@ array_localizer::insert_new_alloc_free (tree var_ssa) + else + free_used = true; + +- auto gsi = gsi_for_stmt (stmt); ++ gimple_stmt_iterator gsi = gsi_for_stmt (stmt); + gimple_call_set_arg (new_free, 0, var_ssa); + gsi_insert_before (&gsi, new_free, GSI_SAME_STMT); + +@@ -519,7 +519,7 @@ array_localizer::insert_new_alloc_free (tree var_ssa) + void + array_localizer::rewrite_access_in_callee (tree var_ssa) + { +- ipa_ref *ref = nullptr; ++ ipa_ref *ref = NULL; + for (unsigned i = 0; var->iterate_referring (i, ref); i++) + { + if (ref == alloc_ref || ref == free_ref) +@@ -530,7 +530,7 @@ array_localizer::rewrite_access_in_callee (tree var_ssa) + if (scalar_alloc_p) + { + tree lhs = gimple_assign_lhs (ref->stmt); +- gimple *use_stmt = nullptr; ++ gimple *use_stmt = NULL; + imm_use_iterator iter; + FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs) + { +@@ -545,7 +545,7 @@ array_localizer::rewrite_access_in_callee (tree var_ssa) + { + tree t = gimple_assign_lhs (use_stmt); + gcc_assert (TREE_CODE (t) == SSA_NAME); +- gimple *stmt = nullptr; ++ gimple *stmt = NULL; + imm_use_iterator it; + FOR_EACH_IMM_USE_STMT (stmt, it, t) + { +@@ -595,7 +595,7 @@ array_localizer::remove_orig_alloc_free () + static unsigned int + ipa_localize_array (void) + { +- cgraph_node *node = nullptr; ++ cgraph_node *node = NULL; + FOR_EACH_FUNCTION (node) + { + if (!node->real_symbol_p () || !node->definition +@@ -604,7 +604,7 @@ ipa_localize_array (void) + node->get_body (); + } + +- varpool_node *var = nullptr; ++ varpool_node *var = NULL; + FOR_EACH_VARIABLE (var) + array_localizer (var).localize (); + +diff --git a/gcc/ipa-struct-reorg/ipa-struct-reorg.c b/gcc/ipa-struct-reorg/ipa-struct-reorg.c +index 802a5af3f..f8af5c1bf 100644 +--- a/gcc/ipa-struct-reorg/ipa-struct-reorg.c ++++ b/gcc/ipa-struct-reorg/ipa-struct-reorg.c +@@ -106,7 +106,6 @@ along with GCC; see the file COPYING3. If not see + #include "gimplify-me.h" + #include "cfgexpand.h" + #include "gimplify.h" +-#include + + #define VOID_POINTER_P(type) (POINTER_TYPE_P (type) && VOID_TYPE_P (TREE_TYPE (type))) + +@@ -558,11 +557,11 @@ enum struct_layout_opt_level + SEMI_RELAYOUT = 1 << 6 + }; + +-enum class fc_level ++enum fc_level + { +- NONE, +- STATIC, +- DYNAMIC ++ FC_LEVEL_NONE, ++ FC_LEVEL_STATIC, ++ FC_LEVEL_DYNAMIC + }; + + fc_level current_fc_level; +@@ -760,7 +759,7 @@ srtype::srtype (tree type) + { + if (TREE_CODE (field) == FIELD_DECL) + { +- if (current_fc_level != fc_level::DYNAMIC ++ if (current_fc_level != FC_LEVEL_DYNAMIC + && DECL_BIT_FIELD (field)) + { + escapes = escape_bitfields; +@@ -1202,7 +1201,7 @@ srfield::create_new_optimized_fields (tree newtype[max_split], + tree newlast[max_split]) + { + /* For dynamic shadow. */ +- if (current_fc_level == fc_level::DYNAMIC && fc_f && fc_f->original) ++ if (current_fc_level == FC_LEVEL_DYNAMIC && fc_f && fc_f->original) + { + newfield[0] = NULL_TREE; + return; +@@ -1416,7 +1415,7 @@ bool + srtype::has_escaped () + { + return escapes != does_not_escape +- && (current_fc_level != fc_level::DYNAMIC ++ && (current_fc_level != FC_LEVEL_DYNAMIC + || !reorg_name_p ()); + } + +@@ -1520,7 +1519,7 @@ srtype::create_new_type (void) + layout_type (newtype[i]); + } + +- if (current_fc_level == fc_level::DYNAMIC) ++ if (current_fc_level == FC_LEVEL_DYNAMIC) + { + gcc_assert (maxclusters == 1); + fc_info->variant->new_type = newtype[0]; +@@ -2127,7 +2126,7 @@ fc_path_info::collect_blocks (gimple *stmt, direction dir) + && loop_outer (start_bb->loop_father) != NULL) + return false; + +- bool prev = dir == direction::PRED; ++ bool prev = dir == DIR_PRED; + basic_block stop_bb = prev ? ENTRY_BLOCK_PTR_FOR_FN (cfun) + : EXIT_BLOCK_PTR_FOR_FN (cfun); + auto_vec *store_list = prev ? &pre_bbs : &reach_bbs; +@@ -3952,7 +3951,7 @@ check_each_call (cgraph_node *node, cgraph_edge *caller) + } + } + +- if (current_fc_level != fc_level::DYNAMIC && !check_node_def (ptr_layers)) ++ if (current_fc_level != FC_LEVEL_DYNAMIC && !check_node_def (ptr_layers)) + { + return false; + } +@@ -5573,7 +5572,7 @@ ipa_struct_reorg::find_function (cgraph_node *node) + return functions[i]; + + srfunction *cloned_func = functions[i]->fc_path.cloned_func; +- if (current_fc_level == fc_level::DYNAMIC ++ if (current_fc_level == FC_LEVEL_DYNAMIC + && cloned_func && cloned_func->node == node) + return cloned_func; + } +@@ -8640,7 +8639,7 @@ ipa_struct_reorg::rewrite_assign (gassign *stmt, gimple_stmt_iterator *gsi) + tree size = TYPE_SIZE_UNIT (struct_type); + tree num = NULL_TREE; + /* Check if rhs2 is a multiplication of the size of the type. */ +- if ((current_fc_level != fc_level::DYNAMIC ++ if ((current_fc_level != FC_LEVEL_DYNAMIC + || !POINTER_TYPE_P (struct_type)) + && !is_result_of_mult (rhs2, &num, size) + && !(current_layout_opt_level & SEMI_RELAYOUT)) +@@ -8801,7 +8800,7 @@ ipa_struct_reorg::rewrite_assign (gassign *stmt, gimple_stmt_iterator *gsi) + if (current_layout_opt_level >= POINTER_COMPRESSION_SAFE) + try_rewrite_with_pointer_compression (stmt, gsi, lhs, rhs, + newlhs[i], newrhs[i]); +- if (current_fc_level == fc_level::DYNAMIC ++ if (current_fc_level == FC_LEVEL_DYNAMIC + && cur_srfd && cur_srfd->dfc_type_change_p ()) + dynamic_fc_rewrite_assign (stmt, rhs, newlhs[i], newrhs[i]); + remove = true; +@@ -9124,7 +9123,7 @@ ipa_struct_reorg::rewrite_call (gcall *stmt, gimple_stmt_iterator *gsi) + + /* Add a safe func mechanism. */ + if (current_layout_opt_level >= STRUCT_REORDER_FIELDS +- && current_fc_level != fc_level::DYNAMIC ++ && current_fc_level != FC_LEVEL_DYNAMIC + && f && f->is_safe_func) + { + tree expr = gimple_call_arg (stmt, 0); +@@ -9148,7 +9147,7 @@ ipa_struct_reorg::rewrite_call (gcall *stmt, gimple_stmt_iterator *gsi) + if (!f) + return false; + +- if (current_fc_level == fc_level::DYNAMIC) ++ if (current_fc_level == FC_LEVEL_DYNAMIC) + { + if (f->partial_clone_p ()) + return false; +@@ -9162,7 +9161,7 @@ ipa_struct_reorg::rewrite_call (gcall *stmt, gimple_stmt_iterator *gsi) + f = f->newf; + } + +- if (current_fc_level == fc_level::DYNAMIC && f->is_safe_func) ++ if (current_fc_level == FC_LEVEL_DYNAMIC && f->is_safe_func) + { + tree expr = gimple_call_arg (stmt, 0); + tree newexpr[max_split] = {NULL_TREE}; +@@ -9972,13 +9971,13 @@ ipa_struct_reorg::find_field_compression_candidate (srtype *type) + /* Classify fields by field type firstly. */ + classify_fields (info); + +- if (current_fc_level == fc_level::STATIC) ++ if (current_fc_level == FC_LEVEL_STATIC) + { + FC_DUMP_MSG ("Looking for static fc fields\n"); + info->static_fc_p = find_static_fc_fields (info); + } + +- if (current_fc_level == fc_level::DYNAMIC) ++ if (current_fc_level == FC_LEVEL_DYNAMIC) + { + FC_DUMP_MSG ("Looking for dynamic fc fields\n"); + info->dynamic_fc_p = find_dynamic_fc_fields (info); +@@ -10155,7 +10154,7 @@ ipa_struct_reorg::find_shadow_fields (fc_type_info *info, + return false; + } + +- if (current_fc_level == fc_level::DYNAMIC) ++ if (current_fc_level == FC_LEVEL_DYNAMIC) + { + if (!shadow_info.unpair_stmt) + return false; +@@ -10179,7 +10178,7 @@ ipa_struct_reorg::find_shadow_fields (fc_type_info *info, + continue; + + fc_field *fc_f = new fc_field (shadow_srf->fielddecl, 1, original_srf); +- auto_vec &fc_fields = current_fc_level == fc_level::STATIC ++ auto_vec &fc_fields = current_fc_level == FC_LEVEL_STATIC + ? info->static_fc_fields + : info->dynamic_shadow_fields; + fc_fields.safe_push (fc_f); +@@ -10991,7 +10990,7 @@ ipa_struct_reorg::modify_shadow_read (gimple *stmt, unsigned idx, + update_stmt (original_stmt); + + tree cond = NULL_TREE; +- if (current_fc_level == fc_level::DYNAMIC) ++ if (current_fc_level == FC_LEVEL_DYNAMIC) + { + field->original->get_closure ()->add_read_change (original_stmt); + /* new_shadow_ssa = (original_ssa != init_const ? original_ssa : 0) */ +@@ -11540,8 +11539,8 @@ ipa_struct_reorg::find_fc_paths (fc_type_info *info) + SET_CFUN (srfn); + + srfn->fc_path.start_stmt = start_stmt; +- if (!srfn->fc_path.collect_blocks (start_stmt, fc_path_info::PRED) +- || !srfn->fc_path.collect_blocks (start_stmt, fc_path_info::SUCC)) ++ if (!srfn->fc_path.collect_blocks (start_stmt, fc_path_info::DIR_PRED) ++ || !srfn->fc_path.collect_blocks (start_stmt, fc_path_info::DIR_SUCC)) + return false; + + /* Start at the entry function. */ +@@ -12211,9 +12210,9 @@ ipa_struct_reorg::add_fc_ref (fc_type_info *info, fc_array *array, tree var, + /* Rule out duplicants. */ + switch (check_duplicative_ref (info, array, var, field, type, size_expr)) + { +- case check_ref_result::NEW: break; +- case check_ref_result::DUPLICATIVE: return true; +- case check_ref_result::ERROR: return false; ++ case CHECK_REF_NEW: break; ++ case CHECK_REF_DUPLICATIVE: return true; ++ case CHECK_REF_ERROR: return false; + } + + if (!type) +@@ -12279,7 +12278,7 @@ ipa_struct_reorg::check_duplicative_ref (fc_type_info *info, fc_array *array, + print_generic_expr (dump_file, array->var); + fprintf (dump_file, "\n"); + } +- return check_ref_result::ERROR; ++ return CHECK_REF_ERROR; + } + + if (ref->field) +@@ -12294,10 +12293,10 @@ ipa_struct_reorg::check_duplicative_ref (fc_type_info *info, fc_array *array, + } + } + +- return check_ref_result::DUPLICATIVE; ++ return CHECK_REF_DUPLICATIVE; + } + +- return check_ref_result::NEW; ++ return CHECK_REF_NEW; + } + + /* Find the single defination stmt before start-point for a var. */ +@@ -12483,22 +12482,27 @@ ipa_struct_reorg::calc_fc_ref_count (fc_type_info *info) + bool + ipa_struct_reorg::compress_fields_dynamic (fc_type_info *info) + { +- const std::map precision_map{ +- {64, 16}, {32, 16}, {16, 8} +- }; +- + for (fc_field *fc_f : info->dynamic_fc_fields) + { + tree old_type = TREE_TYPE (fc_f->field); + bool is_unsigned = TYPE_UNSIGNED (old_type); + gcc_assert (TREE_CODE (old_type) == INTEGER_TYPE); + +- std::map::const_iterator iter +- = precision_map.find (TYPE_PRECISION (old_type)); +- if (iter == precision_map.cend ()) +- return false; ++ unsigned new_size = 0; ++ switch (TYPE_PRECISION (old_type)) ++ { ++ case 64: ++ case 32: ++ new_size = 16; ++ break; ++ case 16: ++ new_size = 8; ++ break; ++ default: ++ return false; ++ } + +- fc_f->new_type = get_integer_type_node (iter->second, is_unsigned); ++ fc_f->new_type = get_integer_type_node (new_size, is_unsigned); + if (dump_file && (dump_flags & TDF_DETAILS)) + { + FC_DUMP_MSG ("Change the type of "); +@@ -12826,7 +12830,7 @@ ipa_struct_reorg::collect_closure_read_change (fc_type_info *info, + unsigned + ipa_struct_reorg::execute_dynamic_field_compression () + { +- if (current_fc_level != fc_level::DYNAMIC) ++ if (current_fc_level != FC_LEVEL_DYNAMIC) + return 0; + + current_layout_opt_level = STRUCT_REORDER_FIELDS; +@@ -14030,7 +14034,7 @@ ipa_struct_reorg::execute (unsigned int opt) + check_and_prune_struct_for_semi_relayout (); + /* Avoid doing static field compression in STRUCT_SPLIT. */ + if (opt >= STRUCT_REORDER_FIELDS +- && current_fc_level == fc_level::STATIC) ++ && current_fc_level == FC_LEVEL_STATIC) + check_and_prune_struct_for_field_compression (); + ret = rewrite_functions (); + } +@@ -14106,9 +14110,9 @@ public: + relayout_part_size = 1 << SEMI_RELAYOUT_LEVEL; + } + +- current_fc_level = fc_level::NONE; ++ current_fc_level = FC_LEVEL_NONE; + if (flag_ipa_struct_sfc) +- current_fc_level = fc_level::STATIC; ++ current_fc_level = FC_LEVEL_STATIC; + + /* Preserved for backward compatibility, reorder fields needs run before + struct split and complete struct relayout. */ +@@ -14119,7 +14123,7 @@ public: + ret = ipa_struct_reorg ().execute (level); + + /* Reset current_fc_level before struct_split and csr. */ +- current_fc_level = fc_level::NONE; ++ current_fc_level = FC_LEVEL_NONE; + + if (ret & TODO_remove_functions) + symtab->remove_unreachable_nodes (dump_file); +@@ -14134,7 +14138,7 @@ public: + + if (ret && flag_ipa_struct_dfc) + { +- current_fc_level = fc_level::DYNAMIC; ++ current_fc_level = FC_LEVEL_DYNAMIC; + ret = ipa_struct_reorg ().execute_dynamic_field_compression (); + } + +diff --git a/gcc/ipa-struct-reorg/ipa-struct-reorg.h b/gcc/ipa-struct-reorg/ipa-struct-reorg.h +index ced623a14..1e29d4ab0 100644 +--- a/gcc/ipa-struct-reorg/ipa-struct-reorg.h ++++ b/gcc/ipa-struct-reorg/ipa-struct-reorg.h +@@ -65,11 +65,11 @@ const char *escape_type_string[escape_max_escape - 1] = + #include "escapes.def" + }; + +-enum class check_ref_result ++enum check_ref_result + { +- NEW, +- DUPLICATIVE, +- ERROR, ++ CHECK_REF_NEW, ++ CHECK_REF_DUPLICATIVE, ++ CHECK_REF_ERROR, + }; + + struct srfield; +@@ -88,8 +88,8 @@ class fc_path_info + public: + enum direction + { +- PRED, +- SUCC ++ DIR_PRED, ++ DIR_SUCC + }; + + public: diff --git a/SPECS/gcc.spec b/SPECS/gcc.spec index a51504d..47562b8 100644 --- a/SPECS/gcc.spec +++ b/SPECS/gcc.spec @@ -332,6 +332,7 @@ Patch5007: gcc8-aarch64-tune-rebuild.patch Patch5008: gcc8-struct-dfc-optimization.patch Patch5009: gcc8-array-dse-optimization.patch Patch5010: gcc8-support-for-hip12.patch +Patch5011: gcc8-fix-build-error.patch # On ARM EABI systems, we do want -gnueabi to be part of the # target triple. @@ -970,6 +971,7 @@ so that there cannot be any synchronization problems. %patch5008 -p1 -b .struct-dfc-optimization~ %patch5009 -p1 -b .array-dse-optimization~ %patch5010 -p1 -b .support-for-hip12~ +%patch5011 -p1 -b .fix-build-error~ cd nvptx-tools-%{nvptx_tools_gitrev} %patch2000 -p1 -b .nvptx-tools-no-ptxas~ -- Gitee