Lines Matching refs:insn
26 struct instruction *insn;
39 struct instruction *insn;
41 hash_for_each_possible(file->insn_hash, insn, hash, sec_offset_hash(sec, offset)) {
42 if (insn->sec == sec && insn->offset == offset)
43 return insn;
50 struct instruction *insn)
52 struct instruction *next = list_next_entry(insn, list);
54 if (!next || &next->list == &file->insn_list || next->sec != insn->sec)
61 struct instruction *insn)
63 struct instruction *next = list_next_entry(insn, list);
64 struct symbol *func = insn->func;
81 struct instruction *insn)
83 struct instruction *prev = list_prev_entry(insn, list);
85 if (&prev->list != &file->insn_list && prev->func == insn->func)
91 #define func_for_each_insn(file, func, insn) \
92 for (insn = find_insn(file, func->sec, func->offset); \
93 insn; \
94 insn = next_insn_same_func(file, insn))
96 #define sym_for_each_insn(file, sym, insn) \
97 for (insn = find_insn(file, sym->sec, sym->offset); \
98 insn && &insn->list != &file->insn_list && \
99 insn->sec == sym->sec && \
100 insn->offset < sym->offset + sym->len; \
101 insn = list_next_entry(insn, list))
103 #define sym_for_each_insn_continue_reverse(file, sym, insn) \
104 for (insn = list_prev_entry(insn, list); \
105 &insn->list != &file->insn_list && \
106 insn->sec == sym->sec && insn->offset >= sym->offset; \
107 insn = list_prev_entry(insn, list))
109 #define sec_for_each_insn_from(file, insn) \
110 for (; insn; insn = next_insn_same_sec(file, insn))
112 #define sec_for_each_insn_continue(file, insn) \
113 for (insn = next_insn_same_sec(file, insn); insn; \
114 insn = next_insn_same_sec(file, insn))
116 static bool is_jump_table_jump(struct instruction *insn)
118 struct alt_group *alt_group = insn->alt_group;
120 if (insn->jump_table)
128 static bool is_sibling_call(struct instruction *insn)
135 if (!insn->func)
139 if (insn->type == INSN_JUMP_DYNAMIC)
140 return !is_jump_table_jump(insn);
142 /* add_jump_destinations() sets insn->call_dest for sibling calls. */
143 return (is_static_jump(insn) && insn->call_dest);
159 struct instruction *insn;
200 insn = find_insn(file, func->sec, func->offset);
201 if (!insn || !insn->func)
204 func_for_each_insn(file, func, insn) {
207 if (insn->type == INSN_RETURN)
219 func_for_each_insn(file, func, insn) {
220 if (is_sibling_call(insn)) {
221 struct instruction *dest = insn->jump_dest;
269 * not correctly determine insn->call_dest->sec (external symbols do
357 struct instruction *insn;
375 for (offset = 0; offset < sec->len; offset += insn->len) {
376 insn = malloc(sizeof(*insn));
377 if (!insn) {
381 memset(insn, 0, sizeof(*insn));
382 INIT_LIST_HEAD(&insn->alts);
383 INIT_LIST_HEAD(&insn->stack_ops);
385 insn->sec = sec;
386 insn->offset = offset;
390 &insn->len, &insn->type,
391 &insn->immediate,
392 &insn->stack_ops);
396 hash_add(file->insn_hash, &insn->hash, sec_offset_hash(sec, insn->offset));
397 list_add_tail(&insn->list, &file->insn_list);
411 sym_for_each_insn(file, func, insn)
412 insn->func = func;
422 free(insn);
429 struct instruction *insn = NULL;
433 for (offset = sec->len - 1; offset >= end && !insn; offset--)
434 insn = find_insn(file, sec, offset);
436 return insn;
446 struct instruction *insn;
452 for_each_insn(file, insn)
453 if (insn->type == INSN_BUG)
454 insn->dead_end = true;
468 insn = find_insn(file, reloc->sym->sec, reloc->addend);
469 if (insn)
470 insn = list_prev_entry(insn, list);
472 insn = find_last_insn(file, reloc->sym->sec);
473 if (!insn) {
474 WARN("can't find unreachable insn at %s+0x%" PRIx64,
479 WARN("can't find unreachable insn at %s+0x%" PRIx64,
484 insn->dead_end = true;
503 insn = find_insn(file, reloc->sym->sec, reloc->addend);
504 if (insn)
505 insn = list_prev_entry(insn, list);
507 insn = find_last_insn(file, reloc->sym->sec);
508 if (!insn) {
509 WARN("can't find reachable insn at %s+0x%" PRIx64,
514 WARN("can't find reachable insn at %s+0x%" PRIx64,
519 insn->dead_end = false;
529 struct instruction *insn;
545 list_for_each_entry(insn, &file->static_call_list, call_node)
554 list_for_each_entry(insn, &file->static_call_list, call_node) {
563 insn->sec, insn->offset))
567 key_name = strdup(insn->call_dest->name);
598 key_sym = insn->call_dest;
606 is_sibling_call(insn) * STATIC_CALL_SITE_TAIL))
617 struct instruction *insn;
628 list_for_each_entry(insn, &file->retpoline_call_list, call_node)
642 list_for_each_entry(insn, &file->retpoline_call_list, call_node) {
650 insn->sec, insn->offset)) {
663 struct instruction *insn;
674 list_for_each_entry(insn, &file->return_thunk_list, call_node)
688 list_for_each_entry(insn, &file->return_thunk_list, call_node) {
696 insn->sec, insn->offset)) {
712 struct instruction *insn;
738 func_for_each_insn(file, func, insn)
739 insn->ignore = true;
925 struct instruction *insn;
937 insn = find_insn(file, reloc->sym->sec, reloc->addend);
938 if (!insn) {
943 insn->ignore_alts = true;
978 static struct reloc *insn_reloc(struct objtool_file *file, struct instruction *insn)
980 if (insn->reloc == NEGATIVE_RELOC)
983 if (!insn->reloc) {
984 insn->reloc = find_reloc_by_dest_range(file->elf, insn->sec,
985 insn->offset, insn->len);
986 if (!insn->reloc) {
987 insn->reloc = NEGATIVE_RELOC;
992 return insn->reloc;
995 static void remove_insn_ops(struct instruction *insn)
999 list_for_each_entry_safe(op, tmp, &insn->stack_ops, list) {
1006 struct instruction *insn, bool sibling)
1008 struct reloc *reloc = insn_reloc(file, insn);
1009 struct symbol *sym = insn->call_dest;
1020 if (!strcmp(insn->sec->name, ".altinstr_replacement"))
1024 list_add_tail(&insn->call_node, &file->static_call_list);
1029 list_add_tail(&insn->call_node, &file->retpoline_call_list);
1038 if (insn->sec->noinstr && sym->kcov) {
1044 elf_write_insn(file->elf, insn->sec,
1045 insn->offset, insn->len,
1046 sibling ? arch_ret_insn(insn->len)
1047 : arch_nop_insn(insn->len));
1049 insn->type = sibling ? INSN_RETURN : INSN_NOP;
1053 * We've replaced the tail-call JMP insn by two new
1054 * insn: RET; INT3, except we only have a single struct
1055 * insn here. Mark it retpoline_safe to avoid the SLS
1056 * warning, instead of adding another insn.
1058 insn->retpoline_safe = true;
1065 static void add_call_dest(struct objtool_file *file, struct instruction *insn,
1068 insn->call_dest = dest;
1079 remove_insn_ops(insn);
1081 annotate_call_site(file, insn, sibling);
1084 static void add_retpoline_call(struct objtool_file *file, struct instruction *insn)
1090 switch (insn->type) {
1092 insn->type = INSN_CALL_DYNAMIC;
1095 insn->type = INSN_JUMP_DYNAMIC;
1098 insn->type = INSN_JUMP_DYNAMIC_CONDITIONAL;
1104 insn->retpoline_safe = true;
1113 remove_insn_ops(insn);
1115 annotate_call_site(file, insn, false);
1118 static void add_return_call(struct objtool_file *file, struct instruction *insn, bool add)
1124 insn->type = INSN_RETURN;
1125 insn->retpoline_safe = true;
1128 if (add && insn->sec->text)
1129 list_add_tail(&insn->call_node, &file->return_thunk_list);
1137 struct instruction *insn;
1142 for_each_insn(file, insn) {
1143 if (!is_static_jump(insn))
1146 reloc = insn_reloc(file, insn);
1148 dest_sec = insn->sec;
1149 dest_off = arch_jump_destination(insn);
1154 add_retpoline_call(file, insn);
1157 add_return_call(file, insn, true);
1159 } else if (insn->func) {
1161 add_call_dest(file, insn, reloc->sym, true);
1172 insn->jump_dest = find_insn(file, dest_sec, dest_off);
1173 if (!insn->jump_dest) {
1181 if (!strcmp(insn->sec->name, ".altinstr_replacement"))
1193 add_return_call(file, insn, false);
1198 insn->sec, insn->offset, dest_sec->name,
1206 if (insn->func && insn->jump_dest->func &&
1207 insn->func != insn->jump_dest->func) {
1224 if (!strstr(insn->func->name, ".cold") &&
1225 strstr(insn->jump_dest->func->name, ".cold")) {
1226 insn->func->cfunc = insn->jump_dest->func;
1227 insn->jump_dest->func->pfunc = insn->func;
1229 } else if (insn->jump_dest->func->pfunc != insn->func->pfunc &&
1230 insn->jump_dest->offset == insn->jump_dest->func->offset) {
1232 add_call_dest(file, insn, insn->jump_dest->func, true);
1256 struct instruction *insn;
1261 for_each_insn(file, insn) {
1262 if (insn->type != INSN_CALL)
1265 reloc = insn_reloc(file, insn);
1267 dest_off = arch_jump_destination(insn);
1268 dest = find_call_destination(insn->sec, dest_off);
1270 add_call_dest(file, insn, dest, false);
1272 if (insn->ignore)
1275 if (!insn->call_dest) {
1276 WARN_FUNC("unannotated intra-function call", insn->sec, insn->offset);
1280 if (insn->func && insn->call_dest->type != STT_FUNC) {
1282 insn->sec, insn->offset);
1291 insn->sec, insn->offset,
1297 add_call_dest(file, insn, dest, false);
1300 add_retpoline_call(file, insn);
1303 add_call_dest(file, insn, reloc->sym, false);
1318 struct instruction *last_orig_insn, *last_new_insn = NULL, *insn, *nop = NULL;
1336 insn = orig_insn;
1337 sec_for_each_insn_from(file, insn) {
1338 if (insn->offset >= special_alt->orig_off + special_alt->orig_len)
1341 insn->alt_group = orig_alt_group;
1342 last_orig_insn = insn;
1386 insn = *new_insn;
1387 sec_for_each_insn_from(file, insn) {
1390 if (insn->offset >= special_alt->new_off + special_alt->new_len)
1393 last_new_insn = insn;
1395 insn->ignore = orig_insn->ignore_alts;
1396 insn->func = orig_insn->func;
1397 insn->alt_group = new_alt_group;
1407 alt_reloc = insn_reloc(file, insn);
1409 !arch_support_alt_relocation(special_alt, insn, alt_reloc)) {
1412 insn->sec, insn->offset);
1416 if (!is_static_jump(insn))
1419 if (!insn->immediate)
1422 dest_off = arch_jump_destination(insn);
1424 insn->jump_dest = next_insn_same_sec(file, last_orig_insn);
1426 if (!insn->jump_dest) {
1428 insn->sec, insn->offset);
1475 * instruction(s) has them added to its insn->alts list, which will be
1539 alt->insn = new_insn;
1552 static int add_jump_table(struct objtool_file *file, struct instruction *insn,
1558 struct symbol *pfunc = insn->func->pfunc;
1594 alt->insn = dest_insn;
1595 list_add_tail(&alt->list, &insn->alts);
1601 insn->sec, insn->offset);
1614 struct instruction *insn)
1617 struct instruction *dest_insn, *orig_insn = insn;
1625 insn && insn->func && insn->func->pfunc == func;
1626 insn = insn->first_jump_src ?: prev_insn_same_sym(file, insn)) {
1628 if (insn != orig_insn && insn->type == INSN_JUMP_DYNAMIC)
1632 if (insn->type == INSN_JUMP_UNCONDITIONAL &&
1633 insn->jump_dest &&
1634 (insn->jump_dest->offset <= insn->offset ||
1635 insn->jump_dest->offset > orig_insn->offset))
1638 table_reloc = arch_find_switch_table(file, insn);
1658 struct instruction *insn, *last = NULL;
1661 func_for_each_insn(file, func, insn) {
1663 last = insn;
1670 if (insn->type == INSN_JUMP_UNCONDITIONAL && insn->jump_dest &&
1671 insn->offset > last->offset &&
1672 insn->jump_dest->offset > insn->offset &&
1673 !insn->jump_dest->first_jump_src) {
1675 insn->jump_dest->first_jump_src = insn;
1676 last = insn->jump_dest;
1679 if (insn->type != INSN_JUMP_DYNAMIC)
1682 reloc = find_jump_table(file, func, insn);
1685 insn->jump_table = reloc;
1693 struct instruction *insn;
1696 func_for_each_insn(file, func, insn) {
1697 if (!insn->jump_table)
1700 ret = add_jump_table(file, insn, insn->jump_table);
1711 * This finds these jump tables and adds them to the insn->alts lists.
1750 struct instruction *insn;
1780 insn = find_insn(file, reloc->sym->sec, reloc->addend);
1781 if (!insn) {
1782 WARN("can't find insn for unwind_hints[%d]", i);
1786 insn->hint = true;
1789 insn->hint = false;
1790 insn->save = true;
1795 insn->restore = true;
1800 struct symbol *sym = find_symbol_by_offset(insn->sec, insn->offset);
1803 insn->entry = 1;
1809 insn->entry = 1;
1813 insn->cfi = &func_cfi;
1817 if (insn->cfi)
1818 cfi = *(insn->cfi);
1822 insn->sec, insn->offset, hint->sp_reg);
1830 insn->cfi = cfi_hash_find_or_add(&cfi);
1839 struct instruction *insn;
1852 insn = find_insn(file, reloc->sym->sec, reloc->addend);
1853 if (!insn) {
1858 if (insn->type != INSN_JUMP_DYNAMIC &&
1859 insn->type != INSN_CALL_DYNAMIC &&
1860 insn->type != INSN_RETURN &&
1861 insn->type != INSN_NOP) {
1863 insn->sec, insn->offset);
1867 insn->retpoline_safe = true;
1876 struct instruction *insn;
1889 insn = find_insn(file, reloc->sym->sec, reloc->addend);
1890 if (!insn) {
1895 insn->instr--;
1908 insn = find_insn(file, reloc->sym->sec, reloc->addend);
1909 if (!insn) {
1914 insn->instr++;
1922 struct instruction *insn;
1939 insn = find_insn(file, reloc->sym->sec, reloc->addend);
1940 if (!insn) {
1945 if (insn->type != INSN_CALL) {
1947 insn->sec, insn->offset);
1956 insn->type = INSN_JUMP_UNCONDITIONAL;
1958 dest_off = insn->offset + insn->len + insn->immediate;
1959 insn->jump_dest = find_insn(file, insn->sec, dest_off);
1960 if (!insn->jump_dest) {
1962 insn->sec, insn->offset,
1963 insn->sec->name, dest_off);
2102 static bool is_special_call(struct instruction *insn)
2104 if (insn->type == INSN_CALL) {
2105 struct symbol *dest = insn->call_dest;
2117 static bool has_modified_stack_frame(struct instruction *insn, struct insn_state *state)
2154 static int update_cfi_state_regs(struct instruction *insn,
2247 static int update_cfi_state(struct instruction *insn, struct cfi_state *cfi,
2255 if (insn->func) {
2256 WARN_FUNC("undefined stack state", insn->sec, insn->offset);
2264 return update_cfi_state_regs(insn, cfi, op);
2395 insn->sec, insn->offset);
2406 insn->sec, insn->offset);
2481 insn->sec, insn->offset);
2524 if (!no_fp && insn->func && op->src.reg == CFI_BP &&
2560 insn->sec, insn->offset);
2579 insn->sec, insn->offset);
2592 insn->sec, insn->offset);
2608 static int propagate_alt_cfi(struct objtool_file *file, struct instruction *insn)
2613 if (!insn->alt_group)
2616 if (!insn->cfi) {
2621 alt_cfi = insn->alt_group->cfi;
2622 group_off = insn->offset - insn->alt_group->first_insn->offset;
2625 alt_cfi[group_off] = insn->cfi;
2627 if (cficmp(alt_cfi[group_off], insn->cfi)) {
2629 insn->sec, insn->offset);
2637 static int handle_insn_ops(struct instruction *insn, struct insn_state *state)
2641 list_for_each_entry(op, &insn->stack_ops, list) {
2643 if (update_cfi_state(insn, &state->cfi, op))
2651 insn->sec, insn->offset);
2671 static bool insn_cfi_match(struct instruction *insn, struct cfi_state *cfi2)
2673 struct cfi_state *cfi1 = insn->cfi;
2684 insn->sec, insn->offset,
2695 insn->sec, insn->offset,
2704 insn->sec, insn->offset, cfi1->type, cfi2->type);
2711 insn->sec, insn->offset,
2729 static inline const char *call_dest_name(struct instruction *insn)
2731 if (insn->call_dest)
2732 return insn->call_dest->name;
2763 static int validate_call(struct instruction *insn, struct insn_state *state)
2766 !noinstr_call_dest(insn->call_dest)) {
2768 insn->sec, insn->offset, call_dest_name(insn));
2772 if (state->uaccess && !func_uaccess_safe(insn->call_dest)) {
2774 insn->sec, insn->offset, call_dest_name(insn));
2780 insn->sec, insn->offset, call_dest_name(insn));
2787 static int validate_sibling_call(struct instruction *insn, struct insn_state *state)
2789 if (has_modified_stack_frame(insn, state)) {
2791 insn->sec, insn->offset);
2795 return validate_call(insn, state);
2798 static int validate_return(struct symbol *func, struct instruction *insn, struct insn_state *state)
2802 insn->sec, insn->offset);
2808 insn->sec, insn->offset);
2814 insn->sec, insn->offset);
2820 insn->sec, insn->offset);
2824 if (func && has_modified_stack_frame(insn, state)) {
2826 insn->sec, insn->offset);
2832 insn->sec, insn->offset);
2840 struct instruction *insn)
2842 struct alt_group *alt_group = insn->alt_group;
2849 if (alt_group && insn == alt_group->last_insn && alt_group->orig_group)
2852 return next_insn_same_sec(file, insn);
2862 struct instruction *insn, struct insn_state state)
2870 sec = insn->sec;
2873 next_insn = next_insn_to_validate(file, insn);
2875 if (file->c_file && func && insn->func && func != insn->func->pfunc) {
2877 func->name, insn->func->name);
2881 if (func && insn->ignore) {
2883 sec, insn->offset);
2888 if (insn->visited & VISITED_BRANCH_MASK) {
2889 if (!insn->hint && !insn_cfi_match(insn, &state.cfi))
2892 if (insn->visited & visited)
2899 state.instr += insn->instr;
2901 if (insn->hint) {
2902 if (insn->restore) {
2905 i = insn;
2917 sec, insn->offset);
2923 sec, insn->offset);
2927 insn->cfi = save_insn->cfi;
2931 state.cfi = *insn->cfi;
2936 insn->cfi = prev_insn->cfi;
2939 insn->cfi = cfi_hash_find_or_add(&state.cfi);
2943 insn->visited |= visited;
2945 if (propagate_alt_cfi(file, insn))
2948 if (!insn->ignore_alts && !list_empty(&insn->alts)) {
2951 list_for_each_entry(alt, &insn->alts, list) {
2955 ret = validate_branch(file, func, alt->insn, state);
2958 BT_FUNC("(alt)", insn);
2967 if (handle_insn_ops(insn, &state))
2970 switch (insn->type) {
2973 if (sls && !insn->retpoline_safe &&
2976 insn->sec, insn->offset);
2978 return validate_return(func, insn, &state);
2982 ret = validate_call(insn, &state);
2986 if (!no_fp && func && !is_special_call(insn) &&
2989 sec, insn->offset);
2993 if (dead_end_function(file, insn->call_dest))
3000 if (is_sibling_call(insn)) {
3001 ret = validate_sibling_call(insn, &state);
3005 } else if (insn->jump_dest) {
3007 insn->jump_dest, state);
3010 BT_FUNC("(branch)", insn);
3015 if (insn->type == INSN_JUMP_UNCONDITIONAL)
3021 if (sls && !insn->retpoline_safe &&
3024 insn->sec, insn->offset);
3029 if (is_sibling_call(insn)) {
3030 ret = validate_sibling_call(insn, &state);
3035 if (insn->type == INSN_JUMP_DYNAMIC)
3043 sec, insn->offset);
3050 WARN_FUNC("recursive UACCESS enable", sec, insn->offset);
3059 WARN_FUNC("redundant UACCESS disable", sec, insn->offset);
3064 WARN_FUNC("UACCESS-safe disables UACCESS", sec, insn->offset);
3073 WARN_FUNC("recursive STD", sec, insn->offset);
3082 WARN_FUNC("redundant CLD", sec, insn->offset);
3093 if (insn->dead_end)
3103 prev_insn = insn;
3104 insn = next_insn;
3112 struct instruction *insn;
3122 insn = find_insn(file, sec, 0);
3123 if (!insn)
3126 insn = list_first_entry(&file->insn_list, typeof(*insn), list);
3129 while (&insn->list != &file->insn_list && (!sec || insn->sec == sec)) {
3130 if (insn->hint && !insn->visited) {
3131 ret = validate_branch(file, insn->func, insn, state);
3133 BT_FUNC("<=== (hint)", insn);
3137 insn = list_next_entry(insn, list);
3149 static int validate_entry(struct objtool_file *file, struct instruction *insn)
3155 next = next_insn_to_validate(file, insn);
3157 if (insn->visited & VISITED_ENTRY)
3160 insn->visited |= VISITED_ENTRY;
3162 if (!insn->ignore_alts && !list_empty(&insn->alts)) {
3166 list_for_each_entry(alt, &insn->alts, list) {
3170 ret = validate_entry(file, alt->insn);
3173 BT_FUNC("(alt)", insn);
3182 switch (insn->type) {
3187 WARN_FUNC("early indirect call", insn->sec, insn->offset);
3192 if (!is_sibling_call(insn)) {
3193 if (!insn->jump_dest) {
3195 insn->sec, insn->offset);
3198 ret = validate_entry(file, insn->jump_dest);
3201 BT_FUNC("(branch%s)", insn,
3202 insn->type == INSN_JUMP_CONDITIONAL ? "-cond" : "");
3207 if (insn->type == INSN_JUMP_UNCONDITIONAL)
3215 dest = find_insn(file, insn->call_dest->sec,
3216 insn->call_dest->offset);
3219 insn->call_dest->name);
3226 BT_FUNC("(call)", insn);
3236 WARN_FUNC("RET before UNTRAIN", insn->sec, insn->offset);
3240 if (insn->retpoline_safe)
3249 WARN_FUNC("teh end!", insn->sec, insn->offset);
3252 insn = next;
3259 * Validate that all branches starting at 'insn->entry' encounter UNRET_END
3264 struct instruction *insn;
3267 for_each_insn(file, insn) {
3268 if (!insn->entry)
3271 ret = validate_entry(file, insn);
3273 WARN_FUNC("Failed UNRET validation", insn->sec, insn->offset);
3284 struct instruction *insn;
3287 for_each_insn(file, insn) {
3288 if (insn->type != INSN_JUMP_DYNAMIC &&
3289 insn->type != INSN_CALL_DYNAMIC &&
3290 insn->type != INSN_RETURN)
3293 if (insn->retpoline_safe)
3302 if (!strcmp(insn->sec->name, ".init.text") && !module)
3305 if (insn->type == INSN_RETURN) {
3308 insn->sec, insn->offset);
3313 insn->sec, insn->offset,
3314 insn->type == INSN_JUMP_DYNAMIC ? "jump" : "call");
3323 static bool is_kasan_insn(struct instruction *insn)
3325 return (insn->type == INSN_CALL &&
3326 !strcmp(insn->call_dest->name, "__asan_handle_no_return"));
3329 static bool is_ubsan_insn(struct instruction *insn)
3331 return (insn->type == INSN_CALL &&
3332 !strcmp(insn->call_dest->name,
3336 static bool ignore_unreachable_insn(struct objtool_file *file, struct instruction *insn)
3341 if (insn->ignore || insn->type == INSN_NOP || insn->type == INSN_TRAP)
3351 if (!strcmp(insn->sec->name, ".fixup") ||
3352 !strcmp(insn->sec->name, ".altinstr_replacement") ||
3353 !strcmp(insn->sec->name, ".altinstr_aux"))
3356 if (!insn->func)
3367 prev_insn = list_prev_entry(insn, list);
3369 (insn->type == INSN_BUG ||
3370 (insn->type == INSN_JUMP_UNCONDITIONAL &&
3371 insn->jump_dest && insn->jump_dest->type == INSN_BUG)))
3382 if (is_kasan_insn(insn) || is_ubsan_insn(insn))
3385 if (insn->type == INSN_JUMP_UNCONDITIONAL) {
3386 if (insn->jump_dest &&
3387 insn->jump_dest->func == insn->func) {
3388 insn = insn->jump_dest;
3395 if (insn->offset + insn->len >= insn->func->offset + insn->func->len)
3398 insn = list_next_entry(insn, list);
3407 struct instruction *insn;
3418 insn = find_insn(file, sec, sym->offset);
3419 if (!insn || insn->ignore || insn->visited)
3424 ret = validate_branch(file, insn->func, insn, *state);
3426 BT_FUNC("<=== (sym)", insn);
3486 struct instruction *insn;
3491 for_each_insn(file, insn) {
3492 if (insn->visited || ignore_unreachable_insn(file, insn))
3495 WARN_FUNC("unreachable instruction", insn->sec, insn->offset);
3555 * further games with insn->visited.