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 */
has_multiple_files(struct elf * elf)153 static inline bool has_multiple_files(struct elf *elf)
154 {
155 return elf->num_files > 1;
156 }
157
elf_addr_size(struct elf * elf)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
elf_rela_size(struct elf * elf)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
elf_data_rela_type(struct elf * elf)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
elf_text_rela_type(struct elf * elf)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
is_reloc_sec(struct section * sec)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
sec_changed(struct section * sec)183 static inline bool sec_changed(struct section *sec)
184 {
185 return sec->_changed;
186 }
187
mark_sec_changed(struct elf * elf,struct section * sec,bool changed)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
sec_num_entries(struct section * sec)195 static inline unsigned int sec_num_entries(struct section *sec)
196 {
197 return sec->sh.sh_size / sec->sh.sh_entsize;
198 }
199
reloc_idx(struct reloc * reloc)200 static inline unsigned int reloc_idx(struct reloc *reloc)
201 {
202 return reloc - reloc->sec->relocs;
203 }
204
reloc_rel(struct reloc * reloc)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
is_32bit_reloc(struct reloc * reloc)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
reloc_offset(struct reloc * reloc)238 static inline u64 reloc_offset(struct reloc *reloc)
239 {
240 return __get_reloc_field(reloc, r_offset);
241 }
242
set_reloc_offset(struct elf * elf,struct reloc * reloc,u64 offset)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
reloc_addend(struct reloc * reloc)249 static inline s64 reloc_addend(struct reloc *reloc)
250 {
251 return __get_reloc_field(reloc, r_addend);
252 }
253
set_reloc_addend(struct elf * elf,struct reloc * reloc,s64 addend)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
reloc_sym(struct reloc * reloc)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
reloc_type(struct reloc * reloc)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
set_reloc_sym(struct elf * elf,struct reloc * reloc,unsigned int sym)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 }
set_reloc_type(struct elf * elf,struct reloc * reloc,unsigned int type)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
sec_offset_hash(struct section * sec,unsigned long offset)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
reloc_hash(struct reloc * reloc)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