question:// language: C #include config.h #include system.h #include coretypes.h #include tm.h #include line-map.h #include params.h #include flags.h #include tree.h #include basic-block.h #include tree-flow.h #include tree-flow-inline.h #include tree-ssa-operands.h #include output.h #include input.h #include tree-pass.h #include gimple-pretty-print.h #include tree-dump.h #include timevar.h #include langhooks.h struct switch_conv_info { tree index_expr; tree range_min; tree range_size; basic_block switch_bb; basic_block final_bb; int phi_count; /* Array of default values, in the same order as phi nodes. */ tree *default_values; VEC (constructor_elt, gc) **constructors; tree *target_inbound_names; tree *target_outbound_names; int default_prob; gcov_type default_count; gcov_type other_count; gimple arr_ref_first; gimple arr_ref_last; const char *reason; unsigned int bit_test_uniq; unsigned int bit_test_count; basic_block bit_test_bb[2]; }; /* Global pass info. */ static struct switch_conv_info info; static bool check_range (gimple swtch) { tree min_case, max_case; unsigned int branch_num = gimple_switch_num_labels (swtch); tree range_max; min_case = gimple_switch_label (swtch, 1); info.range_min = CASE_LOW (min_case); gcc_assert (branch_num > 1); gcc_assert (CASE_LOW (gimple_switch_label (swtch, 0)) == NULL_TREE); max_case = gimple_switch_label (swtch, branch_num - 1); if (CASE_HIGH (max_case)!= NULL_TREE) range_max = CASE_HIGH (max_case); else range_max = CASE_LOW (max_case); gcc_assert (info.range_min); gcc_assert (range_max); info.range_size = int_const_binop (MINUS_EXPR, range_max, info.range_min); gcc_assert (info.range_size); if (!host_integerp (info.range_size, 1)) { info.reason = index range way too large or otherwise unusable.n; return false; } if ((unsigned HOST_WIDE_INT) tree_low_cst (info.range_size, 1) > ((unsigned) branch_num * SWITCH_CONVERSION_BRANCH_RATIO)) { info.reason = the maximum range-branch ratio exceeded.n; return false; } return true; } static bool check_process_case (tree cs) { tree ldecl; basic_block label_bb, following_bb; edge e; ldecl = CASE_LABEL (cs); label_bb = label_to_block (ldecl); e = find_edge (info.switch_bb, label_bb); gcc_assert (e); if (CASE_LOW (cs) == NULL_TREE) { info.default_prob = e->probability; info.default_count = e->count; } else { int i; info.other_count += e->count; for (i = 0; i < 2; i++) if (info.bit_test_bb[i] == label_bb) break; else if (info.bit_test_bb[i] == NULL) { info.bit_test_bb[i] = label_bb; info.bit_test_uniq++; break; } if (i == 2) info.bit_test_uniq = 3; if (CASE_HIGH (cs)!= NULL_TREE &&! tree_int_cst_equal (CASE_LOW (cs), CASE_HIGH (cs))) info.bit_test_count += 2; else info.bit_test_count++; } if (!label_bb) { info.reason = Bad case - cs BB label is NULLn; return false; } if (!single_pred_p (label_bb)) { if (info.final_bb && info.final_bb!= label_bb) { info.reason = Bad case - a non-final BB has two predecessorsn; return false; } following_bb = label_bb; } else { if (!empty_block_p (label_bb)) { info.reason = Bad case - a non-final BB not emptyn; return false; } if (!single_succ_p (label_bb)) { info.reason = Bad case - a non-final BB without a single successorn; return false; } following_bb = single_succ (label_bb); } if (!info.final_bb) info.final_bb = following_bb; else if (info.final_bb!= following_bb) { info.reason = Bad case - different final BBn; return false; } return true; } static bool check_final_bb (void) { gimple_stmt_iterator gsi; info.phi_count = 0; for (gsi = gsi_start_phis (info.final_bb);!gsi_end_p (gsi); gsi_next (&gsi)) { gimple phi = gsi_stmt (gsi); unsigned int i; info.phi_count++; for (i = 0; i < gimple_phi_num_args (phi); i++) { basic_block bb = gimple_phi_arg_edge (phi, i)->src; if (bb == info.switch_bb || (single_pred_p (bb) && single_pred (bb) == info.switch_bb)) { tree reloc, val; val = gimple_phi_arg_def (phi, i); if (!is_gimple_ip_invariant (val)) { info.reason = Non-invariant value from a casen; return false; /* Non-invariant argument. */ } reloc = initializer_constant_valid_p (val, TREE_TYPE (val)); if ((flag_pic && reloc!= null_pointer_node) || (!flag_pic && reloc == NULL_TREE)) { if (reloc) info.reason = Value from a case would need runtime relocationsn; else info.reason = Value from a case is not a valid initializern; return false; } } } } return true; } static void create_temp_arrays (void) { int i; info.default_values = XCNEWVEC (tree, info.phi_count * 3); info.constructors = XCNEWVEC (VEC (constructor_elt, gc) *, info.phi_count); info.target_inbound_names = info.default_values + info.phi_count; info.target_outbound_names = info.target_inbound_names + info.phi_count; for (i = 0; i < info.phi_count; i++) info.constructors[i] = VEC_alloc (constructor_elt, gc, tree_low_cst (info.range_size, 1) + 1); } static void free_temp_arrays (void) { XDELETEVEC (info.constructors); XDELETEVEC (info.default_values); } static void gather_default_values (tree default_case) { gimple_stmt_iterator gsi; basic_block bb = label_to_block (CASE_LABEL (default_case)); edge e; int i = 0; gcc_assert (CASE_LOW (default_case) == NULL_TREE); if (bb == info.final_bb) e = find_edge (info.switch_bb, bb); else e = single_succ_edge (bb); for (gsi = gsi_start_phis (info.final_bb);!gsi_end_p (gsi); gsi_next (&gsi)) { gimple phi = gsi_stmt (gsi); tree val = PHI_ARG_DEF_FROM_EDGE (phi, e); gcc_assert (val); info.default_values[i++] = val; } } static void build_constructors (gimple swtch) { unsigned i, branch_num = gimple_switch_num_labels (swtch); tree pos = info.range_min; for (i = 1; i < branch_num; i++) { tree cs = gimple_switch_label (swtch, i); basic_block bb = label_to_block (CASE_LABEL (cs)); edge e; tree high; gimple_stmt_iterator gsi; int j; if (bb == info.final_bb) e = find_edge (info.switch_bb, bb); else e = single_succ_edge (bb); gcc_assert (e); while (tree_int_cst_lt (pos, CASE_LOW (cs))) { int k; for (k = 0; k < info.phi_count; k++) { constructor_elt *elt; elt = VEC_quick_push (constructor_elt, info.constructors[k], NULL); elt->index = int_const_binop (MINUS_EXPR, pos, info.range_min); elt->value = info.default_values[k]; } pos = int_const_binop (PLUS_EXPR, pos, integer_one_node); } gcc_assert (tree_int_cst_equal (pos, CASE_LOW (cs))); j = 0; if (CASE_HIGH (cs)) high = CASE_HIGH (cs); else high = CASE_LOW (cs); for (gsi = gsi_start_phis (info.final_bb); !gsi_end_p (gsi); gsi_next (&gsi)) { gimple phi = gsi_stmt (gsi); tree val = PHI_ARG_DEF_FROM_EDGE (phi, e); tree low = CASE_LOW (cs); pos = CASE_LOW (cs); do { constructor_elt *elt; elt = VEC_quick_push (constructor_elt, info.constructors[j], NULL); elt->index = int_const_binop (MINUS_EXPR, pos, info.range_min); elt->value = val; pos = int_const_binop (PLUS_EXPR, pos, integer_one_node); } while (!tree_int_cst_lt (high, pos) && tree_int_cst_lt (low, pos)); j++; } } } static tree constructor_contains_same_values_p (VEC (constructor_elt, gc) *vec) { unsigned int i; tree prev = NULL_TREE; constructor_elt *elt; FOR_EACH_VEC_ELT (constructor_elt, vec, i, elt) { if (!prev) prev = elt->value; else if (!operand_equal_p (elt->value, prev, OEP_ONLY_CONST)) return NULL_TREE; } return prev; } static tree array_value_type (gimple swtch, tree type, int num) { unsigned int i, len = VEC_length (constructor_elt, info.constructors[num]); constructor_elt *elt; enum machine_mode mode; int sign = 0; tree smaller_type; if (!INTEGRAL_TYPE_P (type)) return type; mode = GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (TYPE_MODE (type))); if (GET_MODE_SIZE (TYPE_MODE (type)) <= GET_MODE_SIZE (mode)) return type; if (len < (optimize_bb_for_size_p (gimple_bb (swtch))? 2 : 32)) return type; FOR_EACH_VEC_ELT (constructor_elt, info.constructors[num], i, elt) { double_int cst; if (TREE_CODE (elt->value)!= INTEGER_CST) return type; cst = TREE_INT_CST (elt->value); while (1) { unsigned int prec = GET_MODE_BITSIZE (mode); if (prec > HOST_BITS_PER_WIDE_INT) return type; if (sign >= 0 && double_int_equal_p (cst, double_int_zext (cst, prec))) { if (sign == 0 && double_int_equal_p (cst, double_int_sext (cst, prec))) break; sign = 1; break; } if (sign <= 0 && double_int_equal_p (cst, double_int_sext (cst, prec))) { sign = -1; break; } if (sign == 1) sign = 0; mode = GET_MODE_WIDER_MODE (mode); if (mode == VOIDmode || GET_MODE_SIZE (mode) >= GET_MODE_SIZE (TYPE_MODE (type))) return type; } } if (sign == 0) sign = TYPE_UNSIGNED (type)? 1 : -1; smaller_type = lang_hooks.types.type_for_mode (mode, sign >= 0); if (GET_MODE_SIZE (TYPE_MODE (type)) <= GET_MODE_SIZE (TYPE_MODE (smaller_type))) return type; return smaller_type; } static void build_one_array (gimple swtch, int num, tree arr_index_type, gimple phi, tree tidx) { tree name, cst; gimple load; gimple_stmt_iterator gsi = gsi_for_stmt (swtch); location_t loc = gimple_location (swtch); gcc_assert (info.default_values[num]); name = make_ssa_name (SSA_NAME_VAR (PHI_RESULT (phi)), NULL); info.target_inbound_names[num] = name; cst = constructor_contains_same_values_p (info.constructors[num]); if (cst) load = gimple_build_assign (name, cst); else { tree array_type, ctor, decl, value_type, fetch, default_type; default_type = TREE_TYPE (info.default_values[num]); value_type = array_value_type (swtch, default_type, num); array_type = build_array_type (value_type, arr_index_type); if (default_type!= value_type) { unsigned int i; constructor_elt *elt; FOR_EACH_VEC_ELT (constructor_elt, info.constructors[num], i, elt) elt->value = fold_convert (value_type, elt->value); } ctor = build_constructor (array_type, info.constructors[num]); TREE_CONSTANT (ctor) = true; TREE_STATIC (ctor) = true; decl = build_decl (loc, VAR_DECL, NULL_TREE, array_type); TREE_STATIC (decl) = 1; DECL_INITIAL (decl) = ctor; DECL_NAME (decl) = create_tmp_var_name (CSWTCH); DECL_ARTIFICIAL (decl) = 1; TREE_CONSTANT (decl) = 1; TREE_READONLY (decl) = 1; add_referenced_var (decl); varpool_mark_needed_node (varpool_node (decl)); varpool_finalize_decl (decl); fetch = build4 (ARRAY_REF, value_type, decl, tidx, NULL_TREE, NULL_TREE); if (default_type!= value_type) { fetch = fold_convert (default_type, fetch); fetch = force_gimple_operand_gsi (&gsi, fetch, true, NULL_TREE, true, GSI_SAME_STMT); } load = gimple_build_assign (name, fetch); } SSA_NAME_DEF_STMT (name) = load; gsi_insert_before (&gsi, load, GSI_SAME_STMT); update_stmt (load); info.arr_ref_last = load; } static void build_arrays (gimple swtch) { tree arr_index_type; tree tidx, sub, tmp, utype; gimple stmt; gimple_stmt_iterator gsi; int i; location_t loc = gimple_location (swtch); gsi = gsi_for_stmt (swtch); utype = TREE_TYPE (info.index_expr); if (TREE_TYPE (utype)) utype = lang_hooks.types.type_for_mode (TYPE_MODE (TREE_TYPE (utype)), 1); else utype = lang_hooks.types.type_for_mode (TYPE_MODE (utype), 1); arr_index_type = build_index_type (info.range_size); tmp = create_tmp_var (utype, csui); add_referenced_var (tmp); tidx = make_ssa_name (tmp, NULL); sub = fold_build2_loc (loc, MINUS_EXPR, utype, fold_convert_loc (loc, utype, info.index_expr), fold_convert_loc (loc, utype, info.range_min)); sub = force_gimple_operand_gsi (&gsi, sub, false, NULL, true, GSI_SAME_STMT); stmt = gimple_build_assign (tidx, sub); SSA_NAME_DEF_STMT (tidx) = stmt; gsi_insert_before (&gsi, stmt, GSI_SAME_STMT); update_stmt (stmt); info.arr_ref_first = stmt; for (gsi = gsi_start_phis (info.final_bb), i = 0; !gsi_end_p (gsi); gsi_next (&gsi), i++) build_one_array (swtch, i, arr_index_type, gsi_stmt (gsi), tidx); } /* Generates and appropriately inserts loads of default values at the position given by BSI. Returns the last inserted statement. */ static gimple gen_def_assigns (gimple_stmt_iterator *gsi) { int i; gimple assign = NULL; for (i = 0; i < info.phi_count; i++) { tree name = make_ssa_name (SSA_NAME_VAR (info.target_inbound_names[i]), NULL); info.target_outbound_names[i] = name; assign = gimple_build_assign (name, info.default_values[i]); SSA_NAME_DEF_STMT (name) = assign; gsi_insert_before (gsi, assign, GSI_SAME_STMT); update_stmt (assign); } return assign; } static void prune_bbs (basic_block bbd, basic_block final) { edge_iterator ei; edge e; for (ei = ei_start (bbd->succs); (e = ei_safe_edge (ei)); ) { basic_block bb; bb = e->dest; remove_edge (e); if (bb!= final) delete_basic_block (bb); } delete_basic_block (bbd); } static void fix_phi_nodes (edge e1f, edge e2f, basic_block bbf) { gimple_stmt_iterator gsi; int i; for (gsi = gsi_start_phis (bbf), i = 0; !gsi_end_p (gsi); gsi_next (&gsi), i++) { gimple phi = gsi_stmt (gsi); add_phi_arg (phi, info.target_inbound_names[i], e1f, UNKNOWN_LOCATION); add_phi_arg (phi, info.target_outbound_names[i], e2f, UNKNOWN_LOCATION); } } static void gen_inbound_check (gimple swtch) { tree label_decl1 = create_artificial_label (UNKNOWN_LOCATION); tree label_decl2 = create_artificial_label (UNKNOWN_LOCATION); tree label_decl3 = create_artificial_label (UNKNOWN_LOCATION); gimple label1, label2, label3; tree utype, tidx; tree bound; gimple cond_stmt; gimple last_assign; gimple_stmt_iterator gsi; basic_block bb0, bb1, bb2, bbf, bbd; edge e01, e02, e21, e1d, e1f, e2f; location_t loc = gimple_location (swtch); gcc_assert (info.default_values); bb0 = gimple_bb (swtch); tidx = gimple_assign_lhs (info.arr_ref_first); utype = TREE_TYPE (tidx); gsi = gsi_for_stmt (info.arr_ref_first); gsi_next (&gsi); bound = fold_convert_loc (loc, utype, info.range_size); cond_stmt = gimple_build_cond (LE_EXPR, tidx, bound, NULL_TREE, NULL_TREE); gsi_insert_before (&gsi, cond_stmt, GSI_SAME_STMT); update_stmt (cond_stmt); label2 = gimple_build_label (label_decl2); gsi_insert_before (&gsi, label2, GSI_SAME_STMT); last_assign = gen_def_assigns (&gsi); label1 = gimple_build_label (label_decl1); gsi_insert_before (&gsi, label1, GSI_SAME_STMT); gsi = gsi_start_bb (info.final_bb); label3 = gimple_build_label (label_decl3); gsi_insert_before (&gsi, label3, GSI_SAME_STMT); e02 = split_block (bb0, cond_stmt); bb2 = e02->dest; e21 = split_block (bb2, last_assign); bb1 = e21->dest; remove_edge (e21); e1d = split_block (bb1, info.arr_ref_last); bbd = e1d->dest; remove_edge (e1d); /* flags and profiles of the edge for in-range values */ e01 = make_edge (bb0, bb1, EDGE_TRUE_VALUE); e01->probability = REG_BR_PROB_BASE - info.default_prob; e01->count = info.other_count; e02->flags &= ~EDGE_FALLTHRU; e02->flags |= EDGE_FALSE_VALUE; e02->probability = info.default_prob; e02->count = info.default_count; bbf = info.final_bb; e1f = make_edge (bb1, bbf, EDGE_FALLTHRU); e1f->probability = REG_BR_PROB_BASE; e1f->count = info.other_count; e2f = make_edge (bb2, bbf, EDGE_FALLTHRU); e2f->probability = REG_BR_PROB_BASE; e2f->count = info.default_count; bb1->frequency = EDGE_FREQUENCY (e01); bb2->frequency = EDGE_FREQUENCY (e02); bbf->frequency = EDGE_FREQUENCY (e1f) + EDGE_FREQUENCY (e2f); prune_bbs (bbd, info.final_bb); fix_phi_nodes (e1f, e2f, bbf); free_dominance_info (CDI_DOMINATORS); free_dominance_info (CDI_POST_DOMINATORS); } static bool process_switch (gimple swtch) { unsigned int i, branch_num = gimple_switch_num_labels (swtch); tree index_type; if (branch_num < 2) { info.reason = switch has no labelsn; return false; } info.final_bb = NULL; info.switch_bb = gimple_bb (swtch); info.index_expr = gimple_switch_index (swtch); index_type = TREE_TYPE (info.index_expr); info.arr_ref_first = NULL; info.arr_ref_last = NULL; info.default_prob = 0; info.default_count = 0; info.other_count = 0; info.bit_test_uniq = 0; info.bit_test_count = 0; info.bit_test_bb[0] = NULL; info.bit_test_bb[1] = NULL; if (index_type == error_mark_node) { info.reason = index error.n; return false; } if (!check_range (swtch)) return false; for (i = 0; i < branch_num; i++) if (!check_process_case (gimple_switch_label (swtch, i))) { if (dump_file) fprintf (dump_file, Processing of case %i failedn, i); return false; } if (info.bit_test_uniq <= 2) { rtl_profile_for_bb (gimple_bb (swtch)); if (expand_switch_using_bit_tests_p (gimple_switch_index (swtch), info.range_size, info.bit_test_uniq, info.bit_test_count)) { info.reason = Expanding as bit test is preferablen; return false; } } if (!check_final_bb ()) return false; create_temp_arrays (); gather_default_values (gimple_switch_label (swtch, 0)); build_constructors (swtch); build_arrays (swtch); gen_inbound_check (swtch); free_temp_arrays (); return true; } static unsigned int do_switchconv (void) { basic_block bb; FOR_EACH_BB (bb) { gimple stmt = last_stmt (bb); if (stmt && gimple_code (stmt) == GIMPLE_SWITCH) { if (dump_file) { expanded_location loc = expand_location (gimple_location (stmt)); fprintf (dump_file, beginning to process the following SWITCH statement (%s:%d) : ------- n, loc.file, loc.line); print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM); putc ('n', dump_file); } info.reason = NULL; if (process_switch (stmt)) { if (dump_file) { fputs (Switch convertedn, dump_file); fputs (--------------------------------n, dump_file); } } else { if (dump_file) { gcc_assert (info.reason); fputs (Bailing out - , dump_file); fputs (info.reason, dump_file); fputs (--------------------------------n, dump_file); } } } } return 0; } /* The pass gate. */ static bool switchconv_gate (void) { return flag_tree_switch_conversion!= 0; } struct gimple_opt_pass pass_convert_switch = { { GIMPLE_PASS, switchconv, /* name */ switchconv_gate, /* gate */ do_switchconv, NULL, /* sub */ NULL, /* next */ 0, TV_TREE_SWITCH_CONVERSION, /* tv_id */ PROP_cfg | PROP_ssa, /* properties_required */ 0, /* properties_provided */ 0, /* properties_destroyed */ 0, /* todo_flags_start */ TODO_update_ssa | TODO_ggc_collect | TODO_verify_ssa /* todo_flags_finish */ } }; What conditions cause the process_switch() function to bail out and not convert the switch statement?

question:I am looking for a story idea based in ancient history. I would like to set the story in Egypt, but with a fictional twist. Do you have any suggestions?

question:How can you help me come up with a possible plot for the idea that a soul navigates the treacherous waters of the underworld, seeking to resolve unfinished business in the world of the living.

question:Tell me more about navigating the underworld, avoiding treacherous creatures and making unexpected alliances.