1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (C) 2017 Josh Poimboeuf <jpoimboe@redhat.com> 4 */ 5 6 #include <stdlib.h> 7 #include <string.h> 8 9 #include <linux/objtool_types.h> 10 #include <asm/orc_types.h> 11 12 #include <objtool/check.h> 13 #include <objtool/warn.h> 14 #include <objtool/endianness.h> 15 16 static int init_orc_entry(struct orc_entry *orc, struct cfi_state *cfi, 17 struct instruction *insn) 18 { 19 struct cfi_reg *bp = &cfi->regs[CFI_BP]; 20 21 memset(orc, 0, sizeof(*orc)); 22 23 if (!cfi) { 24 /* 25 * This is usually either unreachable nops/traps (which don't 26 * trigger unreachable instruction warnings), or 27 * STACK_FRAME_NON_STANDARD functions. 28 */ 29 orc->type = ORC_TYPE_UNDEFINED; 30 return 0; 31 } 32 33 switch (cfi->type) { 34 case UNWIND_HINT_TYPE_UNDEFINED: 35 orc->type = ORC_TYPE_UNDEFINED; 36 return 0; 37 case UNWIND_HINT_TYPE_END_OF_STACK: 38 orc->type = ORC_TYPE_END_OF_STACK; 39 return 0; 40 case UNWIND_HINT_TYPE_CALL: 41 orc->type = ORC_TYPE_CALL; 42 break; 43 case UNWIND_HINT_TYPE_REGS: 44 orc->type = ORC_TYPE_REGS; 45 break; 46 case UNWIND_HINT_TYPE_REGS_PARTIAL: 47 orc->type = ORC_TYPE_REGS_PARTIAL; 48 break; 49 default: 50 WARN_INSN(insn, "unknown unwind hint type %d", cfi->type); 51 return -1; 52 } 53 54 orc->signal = cfi->signal; 55 56 switch (cfi->cfa.base) { 57 case CFI_SP: 58 orc->sp_reg = ORC_REG_SP; 59 break; 60 case CFI_SP_INDIRECT: 61 orc->sp_reg = ORC_REG_SP_INDIRECT; 62 break; 63 case CFI_BP: 64 orc->sp_reg = ORC_REG_BP; 65 break; 66 case CFI_BP_INDIRECT: 67 orc->sp_reg = ORC_REG_BP_INDIRECT; 68 break; 69 case CFI_R10: 70 orc->sp_reg = ORC_REG_R10; 71 break; 72 case CFI_R13: 73 orc->sp_reg = ORC_REG_R13; 74 break; 75 case CFI_DI: 76 orc->sp_reg = ORC_REG_DI; 77 break; 78 case CFI_DX: 79 orc->sp_reg = ORC_REG_DX; 80 break; 81 default: 82 WARN_INSN(insn, "unknown CFA base reg %d", cfi->cfa.base); 83 return -1; 84 } 85 86 switch (bp->base) { 87 case CFI_UNDEFINED: 88 orc->bp_reg = ORC_REG_UNDEFINED; 89 break; 90 case CFI_CFA: 91 orc->bp_reg = ORC_REG_PREV_SP; 92 break; 93 case CFI_BP: 94 orc->bp_reg = ORC_REG_BP; 95 break; 96 default: 97 WARN_INSN(insn, "unknown BP base reg %d", bp->base); 98 return -1; 99 } 100 101 orc->sp_offset = cfi->cfa.offset; 102 orc->bp_offset = bp->offset; 103 104 return 0; 105 } 106 107 static int write_orc_entry(struct elf *elf, struct section *orc_sec, 108 struct section *ip_sec, unsigned int idx, 109 struct section *insn_sec, unsigned long insn_off, 110 struct orc_entry *o) 111 { 112 struct orc_entry *orc; 113 114 /* populate ORC data */ 115 orc = (struct orc_entry *)orc_sec->data->d_buf + idx; 116 memcpy(orc, o, sizeof(*orc)); 117 orc->sp_offset = bswap_if_needed(elf, orc->sp_offset); 118 orc->bp_offset = bswap_if_needed(elf, orc->bp_offset); 119 120 /* populate reloc for ip */ 121 if (!elf_init_reloc_text_sym(elf, ip_sec, idx * sizeof(int), idx, 122 insn_sec, insn_off)) 123 return -1; 124 125 return 0; 126 } 127 128 struct orc_list_entry { 129 struct list_head list; 130 struct orc_entry orc; 131 struct section *insn_sec; 132 unsigned long insn_off; 133 }; 134 135 static int orc_list_add(struct list_head *orc_list, struct orc_entry *orc, 136 struct section *sec, unsigned long offset) 137 { 138 struct orc_list_entry *entry = malloc(sizeof(*entry)); 139 140 if (!entry) { 141 WARN("malloc failed"); 142 return -1; 143 } 144 145 entry->orc = *orc; 146 entry->insn_sec = sec; 147 entry->insn_off = offset; 148 149 list_add_tail(&entry->list, orc_list); 150 return 0; 151 } 152 153 static unsigned long alt_group_len(struct alt_group *alt_group) 154 { 155 return alt_group->last_insn->offset + 156 alt_group->last_insn->len - 157 alt_group->first_insn->offset; 158 } 159 160 int orc_create(struct objtool_file *file) 161 { 162 struct section *sec, *orc_sec; 163 unsigned int nr = 0, idx = 0; 164 struct orc_list_entry *entry; 165 struct list_head orc_list; 166 167 struct orc_entry null = { .type = ORC_TYPE_UNDEFINED }; 168 169 /* Build a deduplicated list of ORC entries: */ 170 INIT_LIST_HEAD(&orc_list); 171 for_each_sec(file, sec) { 172 struct orc_entry orc, prev_orc = {0}; 173 struct instruction *insn; 174 bool empty = true; 175 176 if (!sec->text) 177 continue; 178 179 sec_for_each_insn(file, sec, insn) { 180 struct alt_group *alt_group = insn->alt_group; 181 int i; 182 183 if (!alt_group) { 184 if (init_orc_entry(&orc, insn->cfi, insn)) 185 return -1; 186 if (!memcmp(&prev_orc, &orc, sizeof(orc))) 187 continue; 188 if (orc_list_add(&orc_list, &orc, sec, 189 insn->offset)) 190 return -1; 191 nr++; 192 prev_orc = orc; 193 empty = false; 194 continue; 195 } 196 197 /* 198 * Alternatives can have different stack layout 199 * possibilities (but they shouldn't conflict). 200 * Instead of traversing the instructions, use the 201 * alt_group's flattened byte-offset-addressed CFI 202 * array. 203 */ 204 for (i = 0; i < alt_group_len(alt_group); i++) { 205 struct cfi_state *cfi = alt_group->cfi[i]; 206 if (!cfi) 207 continue; 208 /* errors are reported on the original insn */ 209 if (init_orc_entry(&orc, cfi, insn)) 210 return -1; 211 if (!memcmp(&prev_orc, &orc, sizeof(orc))) 212 continue; 213 if (orc_list_add(&orc_list, &orc, insn->sec, 214 insn->offset + i)) 215 return -1; 216 nr++; 217 prev_orc = orc; 218 empty = false; 219 } 220 221 /* Skip to the end of the alt_group */ 222 insn = alt_group->last_insn; 223 } 224 225 /* Add a section terminator */ 226 if (!empty) { 227 orc_list_add(&orc_list, &null, sec, sec->sh.sh_size); 228 nr++; 229 } 230 } 231 if (!nr) 232 return 0; 233 234 /* Create .orc_unwind, .orc_unwind_ip and .rela.orc_unwind_ip sections: */ 235 sec = find_section_by_name(file->elf, ".orc_unwind"); 236 if (sec) { 237 WARN("file already has .orc_unwind section, skipping"); 238 return -1; 239 } 240 orc_sec = elf_create_section(file->elf, ".orc_unwind", 241 sizeof(struct orc_entry), nr); 242 if (!orc_sec) 243 return -1; 244 245 sec = elf_create_section_pair(file->elf, ".orc_unwind_ip", sizeof(int), nr, nr); 246 if (!sec) 247 return -1; 248 249 /* Write ORC entries to sections: */ 250 list_for_each_entry(entry, &orc_list, list) { 251 if (write_orc_entry(file->elf, orc_sec, sec, idx++, 252 entry->insn_sec, entry->insn_off, 253 &entry->orc)) 254 return -1; 255 } 256 257 return 0; 258 } 259