1 /* SPDX-License-Identifier: GPL-2.0-or-later */ 2 /* 3 * Copyright (C) 2015 Josh Poimboeuf <jpoimboe@redhat.com> 4 */ 5 6 #ifndef _OBJTOOL_ELF_H 7 #define _OBJTOOL_ELF_H 8 9 #include <stdio.h> 10 #include <gelf.h> 11 #include <linux/list.h> 12 #include <linux/hashtable.h> 13 #include <linux/rbtree.h> 14 #include <linux/jhash.h> 15 #include <arch/elf.h> 16 17 #ifdef LIBELF_USE_DEPRECATED 18 # define elf_getshdrnum elf_getshnum 19 # define elf_getshdrstrndx elf_getshstrndx 20 #endif 21 22 /* 23 * Fallback for systems without this "read, mmaping if possible" cmd. 24 */ 25 #ifndef ELF_C_READ_MMAP 26 #define ELF_C_READ_MMAP ELF_C_READ 27 #endif 28 29 struct elf_hash_node { 30 struct elf_hash_node *next; 31 }; 32 33 struct section { 34 struct list_head list; 35 struct elf_hash_node hash; 36 struct elf_hash_node name_hash; 37 GElf_Shdr sh; 38 struct rb_root_cached symbol_tree; 39 struct list_head symbol_list; 40 struct section *base, *rsec; 41 struct symbol *sym; 42 Elf_Data *data; 43 char *name; 44 int idx; 45 bool _changed, text, rodata, noinstr, init, truncate; 46 struct reloc *relocs; 47 }; 48 49 struct symbol { 50 struct list_head list; 51 struct rb_node node; 52 struct elf_hash_node hash; 53 struct elf_hash_node name_hash; 54 GElf_Sym sym; 55 struct section *sec; 56 char *name; 57 unsigned int idx, len; 58 unsigned long offset; 59 unsigned long __subtree_last; 60 struct symbol *pfunc, *cfunc, *alias; 61 unsigned char bind, type; 62 u8 uaccess_safe : 1; 63 u8 static_call_tramp : 1; 64 u8 retpoline_thunk : 1; 65 u8 return_thunk : 1; 66 u8 fentry : 1; 67 u8 profiling_func : 1; 68 u8 warned : 1; 69 u8 embedded_insn : 1; 70 u8 local_label : 1; 71 u8 frame_pointer : 1; 72 struct list_head pv_target; 73 struct reloc *relocs; 74 }; 75 76 struct reloc { 77 struct elf_hash_node hash; 78 struct section *sec; 79 struct symbol *sym; 80 struct reloc *sym_next_reloc; 81 }; 82 83 struct elf { 84 Elf *elf; 85 GElf_Ehdr ehdr; 86 int fd; 87 bool changed; 88 char *name; 89 unsigned int num_files; 90 struct list_head sections; 91 unsigned long num_relocs; 92 93 int symbol_bits; 94 int symbol_name_bits; 95 int section_bits; 96 int section_name_bits; 97 int reloc_bits; 98 99 struct elf_hash_node **symbol_hash; 100 struct elf_hash_node **symbol_name_hash; 101 struct elf_hash_node **section_hash; 102 struct elf_hash_node **section_name_hash; 103 struct elf_hash_node **reloc_hash; 104 105 struct section *section_data; 106 struct symbol *symbol_data; 107 }; 108 109 struct elf *elf_open_read(const char *name, int flags); 110 111 struct section *elf_create_section(struct elf *elf, const char *name, 112 size_t entsize, unsigned int nr); 113 struct section *elf_create_section_pair(struct elf *elf, const char *name, 114 size_t entsize, unsigned int nr, 115 unsigned int reloc_nr); 116 117 struct symbol *elf_create_prefix_symbol(struct elf *elf, struct symbol *orig, long size); 118 119 struct reloc *elf_init_reloc_text_sym(struct elf *elf, struct section *sec, 120 unsigned long offset, 121 unsigned int reloc_idx, 122 struct section *insn_sec, 123 unsigned long insn_off); 124 125 struct reloc *elf_init_reloc_data_sym(struct elf *elf, struct section *sec, 126 unsigned long offset, 127 unsigned int reloc_idx, 128 struct symbol *sym, 129 s64 addend); 130 131 int elf_write_insn(struct elf *elf, struct section *sec, 132 unsigned long offset, unsigned int len, 133 const char *insn); 134 int elf_write(struct elf *elf); 135 void elf_close(struct elf *elf); 136 137 struct section *find_section_by_name(const struct elf *elf, const char *name); 138 struct symbol *find_func_by_offset(struct section *sec, unsigned long offset); 139 struct symbol *find_symbol_by_offset(struct section *sec, unsigned long offset); 140 struct symbol *find_symbol_by_name(const struct elf *elf, const char *name); 141 struct symbol *find_symbol_containing(const struct section *sec, unsigned long offset); 142 int find_symbol_hole_containing(const struct section *sec, unsigned long offset); 143 struct reloc *find_reloc_by_dest(const struct elf *elf, struct section *sec, unsigned long offset); 144 struct reloc *find_reloc_by_dest_range(const struct elf *elf, struct section *sec, 145 unsigned long offset, unsigned int len); 146 struct symbol *find_func_containing(struct section *sec, unsigned long offset); 147 148 /* 149 * Try to see if it's a whole archive (vmlinux.o or module). 150 * 151 * Note this will miss the case where a module only has one source file. 152 */ 153 static inline bool has_multiple_files(struct elf *elf) 154 { 155 return elf->num_files > 1; 156 } 157 158 static inline size_t elf_addr_size(struct elf *elf) 159 { 160 return elf->ehdr.e_ident[EI_CLASS] == ELFCLASS32 ? 4 : 8; 161 } 162 163 static inline size_t elf_rela_size(struct elf *elf) 164 { 165 return elf_addr_size(elf) == 4 ? sizeof(Elf32_Rela) : sizeof(Elf64_Rela); 166 } 167 168 static inline unsigned int elf_data_rela_type(struct elf *elf) 169 { 170 return elf_addr_size(elf) == 4 ? R_DATA32 : R_DATA64; 171 } 172 173 static inline unsigned int elf_text_rela_type(struct elf *elf) 174 { 175 return elf_addr_size(elf) == 4 ? R_TEXT32 : R_TEXT64; 176 } 177 178 static inline bool is_reloc_sec(struct section *sec) 179 { 180 return sec->sh.sh_type == SHT_RELA || sec->sh.sh_type == SHT_REL; 181 } 182 183 static inline bool sec_changed(struct section *sec) 184 { 185 return sec->_changed; 186 } 187 188 static inline void mark_sec_changed(struct elf *elf, struct section *sec, 189 bool changed) 190 { 191 sec->_changed = changed; 192 elf->changed |= changed; 193 } 194 195 static inline unsigned int sec_num_entries(struct section *sec) 196 { 197 return sec->sh.sh_size / sec->sh.sh_entsize; 198 } 199 200 static inline unsigned int reloc_idx(struct reloc *reloc) 201 { 202 return reloc - reloc->sec->relocs; 203 } 204 205 static inline void *reloc_rel(struct reloc *reloc) 206 { 207 struct section *rsec = reloc->sec; 208 209 return rsec->data->d_buf + (reloc_idx(reloc) * rsec->sh.sh_entsize); 210 } 211 212 static inline bool is_32bit_reloc(struct reloc *reloc) 213 { 214 /* 215 * Elf32_Rel: 8 bytes 216 * Elf32_Rela: 12 bytes 217 * Elf64_Rel: 16 bytes 218 * Elf64_Rela: 24 bytes 219 */ 220 return reloc->sec->sh.sh_entsize < 16; 221 } 222 223 #define __get_reloc_field(reloc, field) \ 224 ({ \ 225 is_32bit_reloc(reloc) ? \ 226 ((Elf32_Rela *)reloc_rel(reloc))->field : \ 227 ((Elf64_Rela *)reloc_rel(reloc))->field; \ 228 }) 229 230 #define __set_reloc_field(reloc, field, val) \ 231 ({ \ 232 if (is_32bit_reloc(reloc)) \ 233 ((Elf32_Rela *)reloc_rel(reloc))->field = val; \ 234 else \ 235 ((Elf64_Rela *)reloc_rel(reloc))->field = val; \ 236 }) 237 238 static inline u64 reloc_offset(struct reloc *reloc) 239 { 240 return __get_reloc_field(reloc, r_offset); 241 } 242 243 static inline void set_reloc_offset(struct elf *elf, struct reloc *reloc, u64 offset) 244 { 245 __set_reloc_field(reloc, r_offset, offset); 246 mark_sec_changed(elf, reloc->sec, true); 247 } 248 249 static inline s64 reloc_addend(struct reloc *reloc) 250 { 251 return __get_reloc_field(reloc, r_addend); 252 } 253 254 static inline void set_reloc_addend(struct elf *elf, struct reloc *reloc, s64 addend) 255 { 256 __set_reloc_field(reloc, r_addend, addend); 257 mark_sec_changed(elf, reloc->sec, true); 258 } 259 260 261 static inline unsigned int reloc_sym(struct reloc *reloc) 262 { 263 u64 info = __get_reloc_field(reloc, r_info); 264 265 return is_32bit_reloc(reloc) ? 266 ELF32_R_SYM(info) : 267 ELF64_R_SYM(info); 268 } 269 270 static inline unsigned int reloc_type(struct reloc *reloc) 271 { 272 u64 info = __get_reloc_field(reloc, r_info); 273 274 return is_32bit_reloc(reloc) ? 275 ELF32_R_TYPE(info) : 276 ELF64_R_TYPE(info); 277 } 278 279 static inline void set_reloc_sym(struct elf *elf, struct reloc *reloc, unsigned int sym) 280 { 281 u64 info = is_32bit_reloc(reloc) ? 282 ELF32_R_INFO(sym, reloc_type(reloc)) : 283 ELF64_R_INFO(sym, reloc_type(reloc)); 284 285 __set_reloc_field(reloc, r_info, info); 286 287 mark_sec_changed(elf, reloc->sec, true); 288 } 289 static inline void set_reloc_type(struct elf *elf, struct reloc *reloc, unsigned int type) 290 { 291 u64 info = is_32bit_reloc(reloc) ? 292 ELF32_R_INFO(reloc_sym(reloc), type) : 293 ELF64_R_INFO(reloc_sym(reloc), type); 294 295 __set_reloc_field(reloc, r_info, info); 296 297 mark_sec_changed(elf, reloc->sec, true); 298 } 299 300 #define for_each_sec(file, sec) \ 301 list_for_each_entry(sec, &file->elf->sections, list) 302 303 #define sec_for_each_sym(sec, sym) \ 304 list_for_each_entry(sym, &sec->symbol_list, list) 305 306 #define for_each_sym(file, sym) \ 307 for (struct section *__sec, *__fake = (struct section *)1; \ 308 __fake; __fake = NULL) \ 309 for_each_sec(file, __sec) \ 310 sec_for_each_sym(__sec, sym) 311 312 #define for_each_reloc(rsec, reloc) \ 313 for (int __i = 0, __fake = 1; __fake; __fake = 0) \ 314 for (reloc = rsec->relocs; \ 315 __i < sec_num_entries(rsec); \ 316 __i++, reloc++) 317 318 #define for_each_reloc_from(rsec, reloc) \ 319 for (int __i = reloc_idx(reloc); \ 320 __i < sec_num_entries(rsec); \ 321 __i++, reloc++) 322 323 #define OFFSET_STRIDE_BITS 4 324 #define OFFSET_STRIDE (1UL << OFFSET_STRIDE_BITS) 325 #define OFFSET_STRIDE_MASK (~(OFFSET_STRIDE - 1)) 326 327 #define for_offset_range(_offset, _start, _end) \ 328 for (_offset = ((_start) & OFFSET_STRIDE_MASK); \ 329 _offset >= ((_start) & OFFSET_STRIDE_MASK) && \ 330 _offset <= ((_end) & OFFSET_STRIDE_MASK); \ 331 _offset += OFFSET_STRIDE) 332 333 static inline u32 sec_offset_hash(struct section *sec, unsigned long offset) 334 { 335 u32 ol, oh, idx = sec->idx; 336 337 offset &= OFFSET_STRIDE_MASK; 338 339 ol = offset; 340 oh = (offset >> 16) >> 16; 341 342 __jhash_mix(ol, oh, idx); 343 344 return ol; 345 } 346 347 static inline u32 reloc_hash(struct reloc *reloc) 348 { 349 return sec_offset_hash(reloc->sec, reloc_offset(reloc)); 350 } 351 352 #endif /* _OBJTOOL_ELF_H */ 353