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 u8 ignore : 1;
73 struct list_head pv_target;
74 struct reloc *relocs;
75 };
76
77 struct reloc {
78 struct elf_hash_node hash;
79 struct section *sec;
80 struct symbol *sym;
81 unsigned long _sym_next_reloc;
82 };
83
84 struct elf {
85 Elf *elf;
86 GElf_Ehdr ehdr;
87 int fd;
88 bool changed;
89 char *name;
90 unsigned int num_files;
91 struct list_head sections;
92 unsigned long num_relocs;
93
94 int symbol_bits;
95 int symbol_name_bits;
96 int section_bits;
97 int section_name_bits;
98 int reloc_bits;
99
100 struct elf_hash_node **symbol_hash;
101 struct elf_hash_node **symbol_name_hash;
102 struct elf_hash_node **section_hash;
103 struct elf_hash_node **section_name_hash;
104 struct elf_hash_node **reloc_hash;
105
106 struct section *section_data;
107 struct symbol *symbol_data;
108 };
109
110 struct elf *elf_open_read(const char *name, int flags);
111
112 struct section *elf_create_section(struct elf *elf, const char *name,
113 size_t entsize, unsigned int nr);
114 struct section *elf_create_section_pair(struct elf *elf, const char *name,
115 size_t entsize, unsigned int nr,
116 unsigned int reloc_nr);
117
118 struct symbol *elf_create_prefix_symbol(struct elf *elf, struct symbol *orig, long size);
119
120 struct reloc *elf_init_reloc_text_sym(struct elf *elf, struct section *sec,
121 unsigned long offset,
122 unsigned int reloc_idx,
123 struct section *insn_sec,
124 unsigned long insn_off);
125
126 struct reloc *elf_init_reloc_data_sym(struct elf *elf, struct section *sec,
127 unsigned long offset,
128 unsigned int reloc_idx,
129 struct symbol *sym,
130 s64 addend);
131
132 int elf_write_insn(struct elf *elf, struct section *sec,
133 unsigned long offset, unsigned int len,
134 const char *insn);
135 int elf_write(struct elf *elf);
136 void elf_close(struct elf *elf);
137
138 struct section *find_section_by_name(const struct elf *elf, const char *name);
139 struct symbol *find_func_by_offset(struct section *sec, unsigned long offset);
140 struct symbol *find_symbol_by_offset(struct section *sec, unsigned long offset);
141 struct symbol *find_symbol_by_name(const struct elf *elf, const char *name);
142 struct symbol *find_symbol_containing(const struct section *sec, unsigned long offset);
143 int find_symbol_hole_containing(const struct section *sec, unsigned long offset);
144 struct reloc *find_reloc_by_dest(const struct elf *elf, struct section *sec, unsigned long offset);
145 struct reloc *find_reloc_by_dest_range(const struct elf *elf, struct section *sec,
146 unsigned long offset, unsigned int len);
147 struct symbol *find_func_containing(struct section *sec, unsigned long offset);
148
149 /*
150 * Try to see if it's a whole archive (vmlinux.o or module).
151 *
152 * Note this will miss the case where a module only has one source file.
153 */
has_multiple_files(struct elf * elf)154 static inline bool has_multiple_files(struct elf *elf)
155 {
156 return elf->num_files > 1;
157 }
158
elf_addr_size(struct elf * elf)159 static inline size_t elf_addr_size(struct elf *elf)
160 {
161 return elf->ehdr.e_ident[EI_CLASS] == ELFCLASS32 ? 4 : 8;
162 }
163
elf_rela_size(struct elf * elf)164 static inline size_t elf_rela_size(struct elf *elf)
165 {
166 return elf_addr_size(elf) == 4 ? sizeof(Elf32_Rela) : sizeof(Elf64_Rela);
167 }
168
elf_data_rela_type(struct elf * elf)169 static inline unsigned int elf_data_rela_type(struct elf *elf)
170 {
171 return elf_addr_size(elf) == 4 ? R_DATA32 : R_DATA64;
172 }
173
elf_text_rela_type(struct elf * elf)174 static inline unsigned int elf_text_rela_type(struct elf *elf)
175 {
176 return elf_addr_size(elf) == 4 ? R_TEXT32 : R_TEXT64;
177 }
178
is_reloc_sec(struct section * sec)179 static inline bool is_reloc_sec(struct section *sec)
180 {
181 return sec->sh.sh_type == SHT_RELA || sec->sh.sh_type == SHT_REL;
182 }
183
sec_changed(struct section * sec)184 static inline bool sec_changed(struct section *sec)
185 {
186 return sec->_changed;
187 }
188
mark_sec_changed(struct elf * elf,struct section * sec,bool changed)189 static inline void mark_sec_changed(struct elf *elf, struct section *sec,
190 bool changed)
191 {
192 sec->_changed = changed;
193 elf->changed |= changed;
194 }
195
sec_num_entries(struct section * sec)196 static inline unsigned int sec_num_entries(struct section *sec)
197 {
198 return sec->sh.sh_size / sec->sh.sh_entsize;
199 }
200
reloc_idx(struct reloc * reloc)201 static inline unsigned int reloc_idx(struct reloc *reloc)
202 {
203 return reloc - reloc->sec->relocs;
204 }
205
reloc_rel(struct reloc * reloc)206 static inline void *reloc_rel(struct reloc *reloc)
207 {
208 struct section *rsec = reloc->sec;
209
210 return rsec->data->d_buf + (reloc_idx(reloc) * rsec->sh.sh_entsize);
211 }
212
is_32bit_reloc(struct reloc * reloc)213 static inline bool is_32bit_reloc(struct reloc *reloc)
214 {
215 /*
216 * Elf32_Rel: 8 bytes
217 * Elf32_Rela: 12 bytes
218 * Elf64_Rel: 16 bytes
219 * Elf64_Rela: 24 bytes
220 */
221 return reloc->sec->sh.sh_entsize < 16;
222 }
223
224 #define __get_reloc_field(reloc, field) \
225 ({ \
226 is_32bit_reloc(reloc) ? \
227 ((Elf32_Rela *)reloc_rel(reloc))->field : \
228 ((Elf64_Rela *)reloc_rel(reloc))->field; \
229 })
230
231 #define __set_reloc_field(reloc, field, val) \
232 ({ \
233 if (is_32bit_reloc(reloc)) \
234 ((Elf32_Rela *)reloc_rel(reloc))->field = val; \
235 else \
236 ((Elf64_Rela *)reloc_rel(reloc))->field = val; \
237 })
238
reloc_offset(struct reloc * reloc)239 static inline u64 reloc_offset(struct reloc *reloc)
240 {
241 return __get_reloc_field(reloc, r_offset);
242 }
243
set_reloc_offset(struct elf * elf,struct reloc * reloc,u64 offset)244 static inline void set_reloc_offset(struct elf *elf, struct reloc *reloc, u64 offset)
245 {
246 __set_reloc_field(reloc, r_offset, offset);
247 mark_sec_changed(elf, reloc->sec, true);
248 }
249
reloc_addend(struct reloc * reloc)250 static inline s64 reloc_addend(struct reloc *reloc)
251 {
252 return __get_reloc_field(reloc, r_addend);
253 }
254
set_reloc_addend(struct elf * elf,struct reloc * reloc,s64 addend)255 static inline void set_reloc_addend(struct elf *elf, struct reloc *reloc, s64 addend)
256 {
257 __set_reloc_field(reloc, r_addend, addend);
258 mark_sec_changed(elf, reloc->sec, true);
259 }
260
261
reloc_sym(struct reloc * reloc)262 static inline unsigned int reloc_sym(struct reloc *reloc)
263 {
264 u64 info = __get_reloc_field(reloc, r_info);
265
266 return is_32bit_reloc(reloc) ?
267 ELF32_R_SYM(info) :
268 ELF64_R_SYM(info);
269 }
270
reloc_type(struct reloc * reloc)271 static inline unsigned int reloc_type(struct reloc *reloc)
272 {
273 u64 info = __get_reloc_field(reloc, r_info);
274
275 return is_32bit_reloc(reloc) ?
276 ELF32_R_TYPE(info) :
277 ELF64_R_TYPE(info);
278 }
279
set_reloc_sym(struct elf * elf,struct reloc * reloc,unsigned int sym)280 static inline void set_reloc_sym(struct elf *elf, struct reloc *reloc, unsigned int sym)
281 {
282 u64 info = is_32bit_reloc(reloc) ?
283 ELF32_R_INFO(sym, reloc_type(reloc)) :
284 ELF64_R_INFO(sym, reloc_type(reloc));
285
286 __set_reloc_field(reloc, r_info, info);
287
288 mark_sec_changed(elf, reloc->sec, true);
289 }
set_reloc_type(struct elf * elf,struct reloc * reloc,unsigned int type)290 static inline void set_reloc_type(struct elf *elf, struct reloc *reloc, unsigned int type)
291 {
292 u64 info = is_32bit_reloc(reloc) ?
293 ELF32_R_INFO(reloc_sym(reloc), type) :
294 ELF64_R_INFO(reloc_sym(reloc), type);
295
296 __set_reloc_field(reloc, r_info, info);
297
298 mark_sec_changed(elf, reloc->sec, true);
299 }
300
301 #define RELOC_JUMP_TABLE_BIT 1UL
302
303 /* Does reloc mark the beginning of a jump table? */
is_jump_table(struct reloc * reloc)304 static inline bool is_jump_table(struct reloc *reloc)
305 {
306 return reloc->_sym_next_reloc & RELOC_JUMP_TABLE_BIT;
307 }
308
set_jump_table(struct reloc * reloc)309 static inline void set_jump_table(struct reloc *reloc)
310 {
311 reloc->_sym_next_reloc |= RELOC_JUMP_TABLE_BIT;
312 }
313
sym_next_reloc(struct reloc * reloc)314 static inline struct reloc *sym_next_reloc(struct reloc *reloc)
315 {
316 return (struct reloc *)(reloc->_sym_next_reloc & ~RELOC_JUMP_TABLE_BIT);
317 }
318
set_sym_next_reloc(struct reloc * reloc,struct reloc * next)319 static inline void set_sym_next_reloc(struct reloc *reloc, struct reloc *next)
320 {
321 unsigned long bit = reloc->_sym_next_reloc & RELOC_JUMP_TABLE_BIT;
322
323 reloc->_sym_next_reloc = (unsigned long)next | bit;
324 }
325
326 #define for_each_sec(file, sec) \
327 list_for_each_entry(sec, &file->elf->sections, list)
328
329 #define sec_for_each_sym(sec, sym) \
330 list_for_each_entry(sym, &sec->symbol_list, list)
331
332 #define for_each_sym(file, sym) \
333 for (struct section *__sec, *__fake = (struct section *)1; \
334 __fake; __fake = NULL) \
335 for_each_sec(file, __sec) \
336 sec_for_each_sym(__sec, sym)
337
338 #define for_each_reloc(rsec, reloc) \
339 for (int __i = 0, __fake = 1; __fake; __fake = 0) \
340 for (reloc = rsec->relocs; \
341 __i < sec_num_entries(rsec); \
342 __i++, reloc++)
343
344 #define for_each_reloc_from(rsec, reloc) \
345 for (int __i = reloc_idx(reloc); \
346 __i < sec_num_entries(rsec); \
347 __i++, reloc++)
348
349 #define OFFSET_STRIDE_BITS 4
350 #define OFFSET_STRIDE (1UL << OFFSET_STRIDE_BITS)
351 #define OFFSET_STRIDE_MASK (~(OFFSET_STRIDE - 1))
352
353 #define for_offset_range(_offset, _start, _end) \
354 for (_offset = ((_start) & OFFSET_STRIDE_MASK); \
355 _offset >= ((_start) & OFFSET_STRIDE_MASK) && \
356 _offset <= ((_end) & OFFSET_STRIDE_MASK); \
357 _offset += OFFSET_STRIDE)
358
sec_offset_hash(struct section * sec,unsigned long offset)359 static inline u32 sec_offset_hash(struct section *sec, unsigned long offset)
360 {
361 u32 ol, oh, idx = sec->idx;
362
363 offset &= OFFSET_STRIDE_MASK;
364
365 ol = offset;
366 oh = (offset >> 16) >> 16;
367
368 __jhash_mix(ol, oh, idx);
369
370 return ol;
371 }
372
reloc_hash(struct reloc * reloc)373 static inline u32 reloc_hash(struct reloc *reloc)
374 {
375 return sec_offset_hash(reloc->sec, reloc_offset(reloc));
376 }
377
378 #endif /* _OBJTOOL_ELF_H */
379