?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / cmd / sgs / libelf / common / gelf.c
blob9483826d90b0665ebc2910bed3faa6d3929e775b
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <string.h>
27 #include "_libelf.h"
28 #include "decl.h"
29 #include "msg.h"
30
31
32 /*
33 * Find elf or it's class from a pointer to an Elf_Data struct.
34 * Warning: this Assumes that the Elf_Data is part of a libelf
35 * Dnode structure, which is expected to be true for any Elf_Data
36 * passed into libelf *except* for the xlatetof() and xlatetom() functions.
37 */
38 #define EDATA_CLASS(edata) \
39 (((Dnode *)(edata))->db_scn->s_elf->ed_class)
40
41 #define EDATA_ELF(edata) \
42 (((Dnode *)(edata))->db_scn->s_elf)
43
44 #define EDATA_SCN(edata) \
45 (((Dnode *)(edata))->db_scn)
46
47 #define EDATA_READLOCKS(edata) \
48 READLOCKS(EDATA_ELF((edata)), EDATA_SCN((edata)))
49
50 #define EDATA_READUNLOCKS(edata) \
51 READUNLOCKS(EDATA_ELF((edata)), EDATA_SCN((edata)))
52
53
54 size_t
55 gelf_fsize(Elf * elf, Elf_Type type, size_t count, unsigned ver)
56 {
57 int class;
58
59 if (elf == NULL)
60 return (0);
61
62 class = gelf_getclass(elf);
63 if (class == ELFCLASS32)
64 return (elf32_fsize(type, count, ver));
65 else if (class == ELFCLASS64)
66 return (elf64_fsize(type, count, ver));
67
68 _elf_seterr(EREQ_CLASS, 0);
69 return (0);
70 }
71
72
73 int
74 gelf_getclass(Elf *elf)
75 {
76 if (elf == NULL)
77 return (0);
78
79 /*
80 * Don't rely on the idents, a new ehdr doesn't have it!
81 */
82 return (elf->ed_class);
83 }
84
85
86 GElf_Ehdr *
87 gelf_getehdr(Elf *elf, GElf_Ehdr *dst)
88 {
89 int class;
90
91 if (elf == NULL)
92 return (NULL);
93
94 class = gelf_getclass(elf);
95 if (class == ELFCLASS32) {
96 Elf32_Ehdr * e = elf32_getehdr(elf);
97
98 if (e == NULL)
99 return (NULL);
100
101 ELFRLOCK(elf);
102 (void) memcpy(dst->e_ident, e->e_ident, EI_NIDENT);
103 dst->e_type = e->e_type;
104 dst->e_machine = e->e_machine;
105 dst->e_version = e->e_version;
106 dst->e_entry = (Elf64_Addr)e->e_entry;
107 dst->e_phoff = (Elf64_Off)e->e_phoff;
108 dst->e_shoff = (Elf64_Off)e->e_shoff;
109 dst->e_flags = e->e_flags;
110 dst->e_ehsize = e->e_ehsize;
111 dst->e_phentsize = e->e_phentsize;
112 dst->e_phnum = e->e_phnum;
113 dst->e_shentsize = e->e_shentsize;
114 dst->e_shnum = e->e_shnum;
115 dst->e_shstrndx = e->e_shstrndx;
116 ELFUNLOCK(elf);
117
118 return (dst);
119 } else if (class == ELFCLASS64) {
120 Elf64_Ehdr * e = elf64_getehdr(elf);
121
122 if (e == NULL)
123 return (NULL);
124
125 ELFRLOCK(elf);
126 *dst = *e;
127 ELFUNLOCK(elf);
128
129 return (dst);
130 }
131
132 _elf_seterr(EREQ_CLASS, 0);
133 return (NULL);
134 }
135
136
137 int
138 gelf_update_ehdr(Elf *elf, GElf_Ehdr *src)
139 {
140 int class;
141
142 if (elf == NULL)
143 return (0);
144
145 /*
146 * In case elf isn't cooked.
147 */
148 class = gelf_getclass(elf);
149 if (class == ELFCLASSNONE)
150 class = src->e_ident[EI_CLASS];
151
152
153 if (class == ELFCLASS32) {
154 Elf32_Ehdr * d = elf32_getehdr(elf);
155
156 if (d == NULL)
157 return (0);
158
159 ELFWLOCK(elf);
160 (void) memcpy(d->e_ident, src->e_ident, EI_NIDENT);
161 d->e_type = src->e_type;
162 d->e_machine = src->e_machine;
163 d->e_version = src->e_version;
164 /* LINTED */
165 d->e_entry = (Elf32_Addr)src->e_entry;
166 /* LINTED */
167 d->e_phoff = (Elf32_Off)src->e_phoff;
168 /* LINTED */
169 d->e_shoff = (Elf32_Off)src->e_shoff;
170 /* could memcpy the rest of these... */
171 d->e_flags = src->e_flags;
172 d->e_ehsize = src->e_ehsize;
173 d->e_phentsize = src->e_phentsize;
174 d->e_phnum = src->e_phnum;
175 d->e_shentsize = src->e_shentsize;
176 d->e_shnum = src->e_shnum;
177 d->e_shstrndx = src->e_shstrndx;
178 ELFUNLOCK(elf);
179
180 return (1);
181 } else if (class == ELFCLASS64) {
182 Elf64_Ehdr * d = elf64_getehdr(elf);
183
184 if (d == NULL)
185 return (0);
186
187 ELFWLOCK(elf);
188 *d = *(Elf64_Ehdr *)src;
189 ELFUNLOCK(elf);
190
191 return (1);
192 }
193
194 _elf_seterr(EREQ_CLASS, 0);
195 return (0);
196 }
197
198
199 unsigned long
200 gelf_newehdr(Elf *elf, int class)
201 {
202 if (elf == NULL)
203 return (0);
204
205 if (class == ELFCLASS32)
206 return ((unsigned long)elf32_newehdr(elf));
207 else if (class == ELFCLASS64)
208 return ((unsigned long)elf64_newehdr(elf));
209
210 _elf_seterr(EREQ_CLASS, 0);
211 return (0);
212 }
213
214
215 GElf_Phdr *
216 gelf_getphdr(Elf *elf, int ndx, GElf_Phdr *dst)
217 {
218 int class;
219 size_t phnum;
220
221 if (elf == NULL)
222 return (NULL);
223
224 if (elf_getphdrnum(elf, &phnum) == -1)
225 return (NULL);
226
227 if (phnum <= ndx) {
228 _elf_seterr(EREQ_RAND, 0);
229 return (NULL);
230 }
231
232 class = gelf_getclass(elf);
233 if ((class != ELFCLASS32) && (class != ELFCLASS64)) {
234 _elf_seterr(EREQ_CLASS, 0);
235 return (NULL);
236 }
237
238 if (class == ELFCLASS32) {
239 Elf32_Phdr *p = &((Elf32_Phdr *)elf32_getphdr(elf))[ndx];
240
241 ELFRLOCK(elf);
242 dst->p_type = p->p_type;
243 dst->p_flags = p->p_flags;
244 dst->p_offset = (Elf64_Off)p->p_offset;
245 dst->p_vaddr = (Elf64_Addr)p->p_vaddr;
246 dst->p_paddr = (Elf64_Addr)p->p_paddr;
247 dst->p_filesz = (Elf64_Xword)p->p_filesz;
248 dst->p_memsz = (Elf64_Xword)p->p_memsz;
249 dst->p_align = (Elf64_Xword)p->p_align;
250 ELFUNLOCK(elf);
251 } else if (class == ELFCLASS64) {
252 Elf64_Phdr *phdrs = elf64_getphdr(elf);
253 ELFRLOCK(elf);
254 *dst = ((GElf_Phdr *)phdrs)[ndx];
255 ELFUNLOCK(elf);
256 }
257
258 return (dst);
259 }
260
261
262 int
263 gelf_update_phdr(Elf *elf, int ndx, GElf_Phdr *src)
264 {
265 int class;
266 size_t phnum;
267
268 if (elf == NULL)
269 return (0);
270
271 if (elf_getphdrnum(elf, &phnum) == -1)
272 return (NULL);
273
274 if (phnum < ndx) {
275 _elf_seterr(EREQ_RAND, 0);
276 return (0);
277 }
278
279 class = gelf_getclass(elf);
280 if (class == ELFCLASS32) {
281 Elf32_Phdr *dst = &((Elf32_Phdr *)elf32_getphdr(elf))[ndx];
282 ELFWLOCK(elf);
283 dst->p_type = src->p_type;
284 dst->p_flags = src->p_flags;
285 /* LINTED */
286 dst->p_offset = (Elf32_Off)src->p_offset;
287 /* LINTED */
288 dst->p_vaddr = (Elf32_Addr)src->p_vaddr;
289 /* LINTED */
290 dst->p_paddr = (Elf32_Addr)src->p_paddr;
291 /* LINTED */
292 dst->p_filesz = (Elf32_Word)src->p_filesz;
293 /* LINTED */
294 dst->p_memsz = (Elf32_Word)src->p_memsz;
295 /* LINTED */
296 dst->p_align = (Elf32_Word)src->p_align;
297 ELFUNLOCK(elf);
298 } else if (class == ELFCLASS64) {
299 Elf64_Phdr *dst = elf64_getphdr(elf);
300 ELFWLOCK(elf);
301 dst[ndx] = *(GElf_Phdr *)src;
302 ELFUNLOCK(elf);
303 } else {
304 _elf_seterr(EREQ_CLASS, 0);
305 return (0);
306 }
307 return (1);
308 }
309
310
311 unsigned long
312 gelf_newphdr(Elf *elf, size_t phnum)
313 {
314 int class;
315
316 if (elf == NULL)
317 return (0);
318
319 class = gelf_getclass(elf);
320 if (class == ELFCLASS32)
321 return ((unsigned long)elf32_newphdr(elf, phnum));
322 else if (class == ELFCLASS64)
323 return ((unsigned long)elf64_newphdr(elf, phnum));
324
325 _elf_seterr(EREQ_CLASS, 0);
326 return (0);
327 }
328
329
330 GElf_Shdr *
331 gelf_getshdr(Elf_Scn *scn, GElf_Shdr *dst)
332 {
333 if (scn == NULL)
334 return (NULL);
335
336 if (scn->s_elf->ed_class == ELFCLASS32) {
337 Elf32_Shdr *s = elf32_getshdr(scn);
338
339 if (s == NULL)
340 return (NULL);
341
342 READLOCKS(scn->s_elf, scn);
343 dst->sh_name = s->sh_name;
344 dst->sh_type = s->sh_type;
345 dst->sh_flags = (Elf64_Xword)s->sh_flags;
346 dst->sh_addr = (Elf64_Addr)s->sh_addr;
347 dst->sh_offset = (Elf64_Off)s->sh_offset;
348 dst->sh_size = (Elf64_Xword)s->sh_size;
349 dst->sh_link = s->sh_link;
350 dst->sh_info = s->sh_info;
351 dst->sh_addralign = (Elf64_Xword)s->sh_addralign;
352 dst->sh_entsize = (Elf64_Xword)s->sh_entsize;
353 READUNLOCKS(scn->s_elf, scn);
354
355 return (dst);
356 } else if (scn->s_elf->ed_class == ELFCLASS64) {
357 Elf64_Shdr *s = elf64_getshdr(scn);
358
359 if (s == NULL)
360 return (NULL);
361
362 READLOCKS(scn->s_elf, scn);
363 *dst = *(Elf64_Shdr *)s;
364 READUNLOCKS(scn->s_elf, scn);
365
366 return (dst);
367 }
368
369 _elf_seterr(EREQ_CLASS, 0);
370 return (NULL);
371 }
372
373
374 int
375 gelf_update_shdr(Elf_Scn *scn, GElf_Shdr *src)
376 {
377 if (scn == NULL)
378 return (0);
379
380 if (scn->s_elf->ed_class == ELFCLASS32) {
381 Elf32_Shdr *dst = elf32_getshdr(scn);
382
383 if (dst == NULL)
384 return (0);
385
386 ELFWLOCK(scn->s_elf);
387 dst->sh_name = src->sh_name;
388 dst->sh_type = src->sh_type;
389 /* LINTED */
390 dst->sh_flags = (Elf32_Word)src->sh_flags;
391 /* LINTED */
392 dst->sh_addr = (Elf32_Addr)src->sh_addr;
393 /* LINTED */
394 dst->sh_offset = (Elf32_Off) src->sh_offset;
395 /* LINTED */
396 dst->sh_size = (Elf32_Word)src->sh_size;
397 dst->sh_link = src->sh_link;
398 dst->sh_info = src->sh_info;
399 /* LINTED */
400 dst->sh_addralign = (Elf32_Word)src->sh_addralign;
401 /* LINTED */
402 dst->sh_entsize = (Elf32_Word)src->sh_entsize;
403
404 ELFUNLOCK(scn->s_elf);
405 return (1);
406 } else if (scn->s_elf->ed_class == ELFCLASS64) {
407 Elf64_Shdr * dst = elf64_getshdr(scn);
408
409 if (dst == NULL)
410 return (0);
411
412 ELFWLOCK(scn->s_elf);
413 *dst = *(Elf64_Shdr *)src;
414 ELFUNLOCK(scn->s_elf);
415 return (1);
416 }
417
418 _elf_seterr(EREQ_CLASS, 0);
419 return (0);
420 }
421
422
423 /*
424 * gelf_xlatetof/gelf_xlatetom use 'elf' to find the class
425 * because these are the odd case where the Elf_Data structs
426 * might not have been allocated by libelf (and therefore
427 * don't have Dnode's associated with them).
428 */
429 Elf_Data *
430 gelf_xlatetof(Elf *elf, Elf_Data *dst, const Elf_Data *src, unsigned encode)
431 {
432 int class;
433
434 if ((elf == NULL) || (dst == NULL) || (src == NULL))
435 return (NULL);
436
437 class = gelf_getclass(elf);
438 if (class == ELFCLASS32)
439 return (elf32_xlatetof(dst, src, encode));
440 else if (class == ELFCLASS64)
441 return (elf64_xlatetof(dst, src, encode));
442
443 _elf_seterr(EREQ_CLASS, 0);
444 return (NULL);
445 }
446
447
448 Elf_Data *
449 gelf_xlatetom(Elf *elf, Elf_Data *dst, const Elf_Data *src, unsigned encode)
450 {
451 int class;
452
453 if ((elf == NULL) || (dst == NULL) || (src == NULL))
454 return (NULL);
455
456 class = gelf_getclass(elf);
457 if (class == ELFCLASS32)
458 return (elf32_xlatetom(dst, src, encode));
459 else if (class == ELFCLASS64)
460 return (elf64_xlatetom(dst, src, encode));
461
462 _elf_seterr(EREQ_CLASS, 0);
463 return (NULL);
464 }
465
466
467 GElf_Sym *
468 gelf_getsym(Elf_Data * data, int ndx, GElf_Sym * dst)
469 {
470 int class;
471 size_t entsize;
472
473 if (data == NULL)
474 return (NULL);
475
476 class = EDATA_CLASS(data);
477 if (class == ELFCLASS32)
478 entsize = sizeof (Elf32_Sym);
479 else if (class == ELFCLASS64)
480 entsize = sizeof (GElf_Sym);
481 else {
482 _elf_seterr(EREQ_CLASS, 0);
483 return (NULL);
484 }
485
486 EDATA_READLOCKS(data);
487
488 if ((entsize * ndx) >= data->d_size) {
489 _elf_seterr(EREQ_RAND, 0);
490 dst = NULL;
491 } else if (class == ELFCLASS32) {
492 Elf32_Sym *s;
493 s = &(((Elf32_Sym *)data->d_buf)[ndx]);
494 dst->st_name = s->st_name;
495 dst->st_value = (Elf64_Addr)s->st_value;
496 dst->st_size = (Elf64_Xword)s->st_size;
497 dst->st_info = ELF64_ST_INFO(ELF32_ST_BIND(s->st_info),
498 ELF32_ST_TYPE(s->st_info));
499 dst->st_other = s->st_other;
500 dst->st_shndx = s->st_shndx;
501 } else
502 *dst = ((GElf_Sym *)data->d_buf)[ndx];
503
504 EDATA_READUNLOCKS(data);
505 return (dst);
506 }
507
508
509 int
510 gelf_update_sym(Elf_Data *dst, int ndx, GElf_Sym *src)
511 {
512 int class, rc = 1;
513 size_t entsize;
514
515 if (dst == NULL)
516 return (0);
517
518 class = EDATA_CLASS(dst);
519 if (class == ELFCLASS32)
520 entsize = sizeof (Elf32_Sym);
521 else if (class == ELFCLASS64)
522 entsize = sizeof (GElf_Sym);
523 else {
524 _elf_seterr(EREQ_CLASS, 0);
525 return (0);
526 }
527
528 ELFWLOCK(EDATA_ELF(dst));
529
530 if ((entsize * ndx) >= dst->d_size) {
531 _elf_seterr(EREQ_RAND, 0);
532 rc = 0;
533 } else if (class == ELFCLASS32) {
534 Elf32_Sym * d;
535
536 d = &(((Elf32_Sym *)dst->d_buf)[ndx]);
537 d->st_name = src->st_name;
538 /* LINTED */
539 d->st_value = (Elf32_Addr)src->st_value;
540 /* LINTED */
541 d->st_size = (Elf32_Word)src->st_size;
542 d->st_info = ELF32_ST_INFO(ELF64_ST_BIND(src->st_info),
543 ELF64_ST_TYPE(src->st_info));
544 d->st_other = src->st_other;
545 d->st_shndx = src->st_shndx;
546 } else
547 ((Elf64_Sym *)dst->d_buf)[ndx] = *((Elf64_Sym *)src);
548
549 ELFUNLOCK(EDATA_ELF(dst));
550 return (rc);
551 }
552
553
554 GElf_Syminfo *
555 gelf_getsyminfo(Elf_Data *data, int ndx, GElf_Syminfo *dst)
556 {
557 int class;
558 size_t entsize;
559
560 if (data == NULL)
561 return (NULL);
562
563 class = EDATA_CLASS(data);
564 if (class == ELFCLASS32)
565 entsize = sizeof (Elf32_Syminfo);
566 else if (class == ELFCLASS64)
567 entsize = sizeof (GElf_Syminfo);
568 else {
569 _elf_seterr(EREQ_CLASS, 0);
570 return (NULL);
571 }
572 EDATA_READLOCKS(data);
573
574 if ((entsize * ndx) >= data->d_size) {
575 _elf_seterr(EREQ_RAND, 0);
576 dst = NULL;
577 } else if (class == ELFCLASS32) {
578 Elf32_Syminfo * si;
579
580 si = &(((Elf32_Syminfo *)data->d_buf)[ndx]);
581 dst->si_boundto = si->si_boundto;
582 dst->si_flags = si->si_flags;
583 } else
584 *dst = ((GElf_Syminfo *)data->d_buf)[ndx];
585
586 EDATA_READUNLOCKS(data);
587 return (dst);
588 }
589
590 int
591 gelf_update_syminfo(Elf_Data *dst, int ndx, GElf_Syminfo *src)
592 {
593 int class, rc = 1;
594 size_t entsize;
595
596 if (dst == NULL)
597 return (0);
598
599 class = EDATA_CLASS(dst);
600 if (class == ELFCLASS32)
601 entsize = sizeof (Elf32_Syminfo);
602 else if (class == ELFCLASS64)
603 entsize = sizeof (GElf_Syminfo);
604 else {
605 _elf_seterr(EREQ_CLASS, 0);
606 return (0);
607 }
608 ELFWLOCK(EDATA_ELF(dst));
609
610 if ((entsize * ndx) >= dst->d_size) {
611 _elf_seterr(EREQ_RAND, 0);
612 rc = 0;
613 } else if (class == ELFCLASS32) {
614 Elf32_Syminfo * d = &(((Elf32_Syminfo *)dst->d_buf)[ndx]);
615 d->si_boundto = src->si_boundto;
616 d->si_flags = src->si_flags;
617 } else
618 ((Elf64_Syminfo *)dst->d_buf)[ndx] = *((Elf64_Syminfo *)src);
619
620 ELFUNLOCK(EDATA_ELF(dst));
621 return (rc);
622 }
623
624 GElf_Dyn *
625 gelf_getdyn(Elf_Data *data, int ndx, GElf_Dyn *dst)
626 {
627 int class;
628 size_t entsize;
629
630 if (data == NULL)
631 return (NULL);
632
633 class = EDATA_CLASS(data);
634 if (class == ELFCLASS32)
635 entsize = sizeof (Elf32_Dyn);
636 else if (class == ELFCLASS64)
637 entsize = sizeof (GElf_Dyn);
638 else {
639 _elf_seterr(EREQ_CLASS, 0);
640 return (NULL);
641 }
642 EDATA_READLOCKS(data);
643
644 if ((entsize * ndx) >= data->d_size) {
645 _elf_seterr(EREQ_RAND, 0);
646 dst = NULL;
647 } else if (class == ELFCLASS32) {
648 Elf32_Dyn * d = &((Elf32_Dyn *)data->d_buf)[ndx];
649
650 dst->d_tag = (Elf32_Sword)d->d_tag;
651 dst->d_un.d_val = (Elf32_Word) d->d_un.d_val;
652 } else
653 *dst = ((Elf64_Dyn *)data->d_buf)[ndx];
654
655 EDATA_READUNLOCKS(data);
656 return (dst);
657 }
658
659
660 int
661 gelf_update_dyn(Elf_Data *dst, int ndx, GElf_Dyn *src)
662 {
663 int class, rc = 1;
664 size_t entsize;
665
666 if (dst == NULL)
667 return (0);
668
669 class = EDATA_CLASS(dst);
670 if (class == ELFCLASS32)
671 entsize = sizeof (Elf32_Dyn);
672 else if (class == ELFCLASS64)
673 entsize = sizeof (GElf_Dyn);
674 else {
675 _elf_seterr(EREQ_CLASS, 0);
676 return (0);
677 }
678 ELFWLOCK(EDATA_ELF(dst));
679
680 if ((entsize * ndx) >= dst->d_size) {
681 _elf_seterr(EREQ_RAND, 0);
682 rc = 0;
683 } else if (class == ELFCLASS32) {
684 Elf32_Dyn * d = &((Elf32_Dyn *)dst->d_buf)[ndx];
685
686 /* LINTED */
687 d->d_tag = (Elf32_Word)src->d_tag;
688 /* LINTED */
689 d->d_un.d_val = (Elf32_Word)src->d_un.d_val;
690 } else
691 ((Elf64_Dyn *)dst->d_buf)[ndx] = *(Elf64_Dyn*)src;
692
693 ELFUNLOCK(EDATA_ELF(dst));
694 return (rc);
695 }
696
697
698
699 GElf_Sym *
700 gelf_getsymshndx(Elf_Data *symdata, Elf_Data *shndxdata,
701 int ndx, GElf_Sym *symptr, Elf32_Word *xshndx)
702 {
703 if (gelf_getsym(symdata, ndx, symptr) == 0)
704 return (NULL);
705 if (shndxdata && xshndx) {
706 EDATA_READLOCKS(shndxdata);
707 if ((ndx * sizeof (Elf32_Word)) >= shndxdata->d_size) {
708 _elf_seterr(EREQ_RAND, 0);
709 EDATA_READUNLOCKS(shndxdata);
710 return (NULL);
711 }
712 *xshndx = (((Elf32_Word *)shndxdata->d_buf)[ndx]);
713 EDATA_READUNLOCKS(shndxdata);
714 } else {
715 *xshndx = 0;
716 }
717 return (symptr);
718 }
719
720 int
721 gelf_update_symshndx(Elf_Data *symdata, Elf_Data *shndxdata,
722 int ndx, GElf_Sym *symptr, Elf32_Word xshndx)
723 {
724 if (gelf_update_sym(symdata, ndx, symptr) == 0)
725 return (0);
726 if (shndxdata) {
727 ELFWLOCK(EDATA_ELF(shndxdata));
728 if ((ndx * sizeof (Elf32_Word)) >= shndxdata->d_size) {
729 _elf_seterr(EREQ_RAND, 0);
730 ELFUNLOCK(EDATA_ELF(shndxdata));
731 return (0);
732 }
733 ((Elf32_Word *)shndxdata->d_buf)[ndx] = xshndx;
734 ELFUNLOCK(EDATA_ELF(shndxdata));
735 }
736 return (1);
737 }
738
739
740 GElf_Move *
741 gelf_getmove(Elf_Data *src, int ndx, GElf_Move *dst)
742 {
743 int class;
744 size_t entsize;
745
746 if (src == NULL)
747 return (NULL);
748
749 class = EDATA_CLASS(src);
750 if (class == ELFCLASS32)
751 entsize = sizeof (Elf32_Move);
752 else if (class == ELFCLASS64)
753 entsize = sizeof (GElf_Move);
754 else {
755 _elf_seterr(EREQ_CLASS, 0);
756 return (NULL);
757 }
758 EDATA_READLOCKS(src);
759
760 if ((entsize * ndx) >= src->d_size) {
761 _elf_seterr(EREQ_RAND, 0);
762 dst = NULL;
763 } else if (class == ELFCLASS32) {
764 Elf32_Move * m = &((Elf32_Move *)src->d_buf)[ndx];
765
766 dst->m_poffset = (Elf64_Word)m->m_poffset;
767 dst->m_repeat = (Elf64_Xword)m->m_repeat;
768 dst->m_stride = (Elf64_Half)m->m_stride;
769 dst->m_value = (Elf64_Xword)m->m_value;
770 dst->m_info = ELF64_M_INFO(ELF32_M_SYM(m->m_info),
771 ELF32_M_SIZE(m->m_info));
772 } else {
773 *dst = ((Elf64_Move *)src->d_buf)[ndx];
774 }
775
776 EDATA_READUNLOCKS(src);
777 return (dst);
778 }
779
780 int
781 gelf_update_move(Elf_Data *dest, int ndx, GElf_Move *src)
782 {
783 int class, rc = 1;
784 size_t entsize;
785
786 if (dest == NULL)
787 return (0);
788
789 class = EDATA_CLASS(dest);
790 if (class == ELFCLASS32)
791 entsize = sizeof (Elf32_Move);
792 else if (class == ELFCLASS64)
793 entsize = sizeof (GElf_Move);
794 else {
795 _elf_seterr(EREQ_CLASS, 0);
796 return (0);
797 }
798 ELFWLOCK(EDATA_ELF(dest));
799
800 if ((entsize * ndx) >= dest->d_size) {
801 _elf_seterr(EREQ_RAND, 0);
802 rc = 0;
803 } else if (class == ELFCLASS32) {
804 Elf32_Move * m = &((Elf32_Move *)dest->d_buf)[ndx];
805
806 m->m_poffset = (Elf32_Word)src->m_poffset;
807 m->m_repeat = (Elf32_Half)src->m_repeat;
808 m->m_stride = (Elf32_Half)src->m_stride;
809 m->m_value = (Elf32_Lword)src->m_value;
810 m->m_info = (Elf32_Word)ELF32_M_INFO(ELF64_M_SYM(src->m_info),
811 ELF64_M_SIZE(src->m_info));
812 } else {
813 ((Elf64_Move *)dest->d_buf)[ndx] = *(Elf64_Move *)src;
814 }
815
816 ELFUNLOCK(EDATA_ELF(dest));
817 return (rc);
818 }
819
820
821 GElf_Rela *
822 gelf_getrela(Elf_Data *src, int ndx, GElf_Rela *dst)
823 {
824 int class;
825 size_t entsize;
826
827 if (src == NULL)
828 return (NULL);
829
830 class = EDATA_CLASS(src);
831 if (class == ELFCLASS32)
832 entsize = sizeof (Elf32_Rela);
833 else if (class == ELFCLASS64)
834 entsize = sizeof (GElf_Rela);
835 else {
836 _elf_seterr(EREQ_CLASS, 0);
837 return (NULL);
838 }
839 EDATA_READLOCKS(src);
840
841 if ((entsize * ndx) >= src->d_size) {
842 _elf_seterr(EREQ_RAND, 0);
843 dst = NULL;
844 } else if (class == ELFCLASS32) {
845 Elf32_Rela * r = &((Elf32_Rela *)src->d_buf)[ndx];
846
847 dst->r_offset = (GElf_Addr)r->r_offset;
848 dst->r_addend = (GElf_Addr)r->r_addend;
849
850 /*
851 * Elf32 will never have the extra data field that
852 * Elf64's r_info field can have, so ignore it.
853 */
854 /* LINTED */
855 dst->r_info = ELF64_R_INFO(
856 ELF32_R_SYM(r->r_info),
857 ELF32_R_TYPE(r->r_info));
858 } else
859 *dst = ((Elf64_Rela *)src->d_buf)[ndx];
860
861 EDATA_READUNLOCKS(src);
862 return (dst);
863 }
864
865
866 int
867 gelf_update_rela(Elf_Data *dst, int ndx, GElf_Rela *src)
868 {
869 int class, rc = 1;
870 size_t entsize;
871
872 if (dst == NULL)
873 return (0);
874
875 class = EDATA_CLASS(dst);
876 if (class == ELFCLASS32)
877 entsize = sizeof (Elf32_Rela);
878 else if (class == ELFCLASS64)
879 entsize = sizeof (GElf_Rela);
880 else {
881 _elf_seterr(EREQ_CLASS, 0);
882 return (0);
883 }
884 ELFWLOCK(EDATA_ELF(dst));
885
886 if ((entsize * ndx) >= dst->d_size) {
887 _elf_seterr(EREQ_RAND, 0);
888 rc = 0;
889 } else if (class == ELFCLASS32) {
890 Elf32_Rela * r = &((Elf32_Rela *)dst->d_buf)[ndx];
891
892 /* LINTED */
893 r->r_offset = (Elf32_Addr) src->r_offset;
894 /* LINTED */
895 r->r_addend = (Elf32_Sword)src->r_addend;
896
897 /*
898 * Elf32 will never have the extra data field that
899 * Elf64's r_info field can have, so ignore it.
900 */
901 /* LINTED */
902 r->r_info = ELF32_R_INFO(ELF64_R_SYM(src->r_info),
903 ELF64_R_TYPE(src->r_info));
904 } else {
905 ((Elf64_Rela *)dst->d_buf)[ndx] = *(Elf64_Rela *)src;
906 }
907
908 ELFUNLOCK(EDATA_ELF(dst));
909
910 return (rc);
911 }
912
913
914 GElf_Rel *
915 gelf_getrel(Elf_Data *src, int ndx, GElf_Rel *dst)
916 {
917 int class;
918 size_t entsize;
919
920 if (src == NULL)
921 return (NULL);
922
923 class = EDATA_CLASS(src);
924 if (class == ELFCLASS32)
925 entsize = sizeof (Elf32_Rel);
926 else if (class == ELFCLASS64)
927 entsize = sizeof (GElf_Rel);
928 else {
929 _elf_seterr(EREQ_CLASS, 0);
930 return (NULL);
931 }
932 EDATA_READLOCKS(src);
933
934 if ((entsize * ndx) >= src->d_size) {
935 _elf_seterr(EREQ_RAND, 0);
936 dst = NULL;
937 } else if (class == ELFCLASS32) {
938 Elf32_Rel * r = &((Elf32_Rel *)src->d_buf)[ndx];
939
940 dst->r_offset = (GElf_Addr)r->r_offset;
941
942 /*
943 * Elf32 will never have the extra data field that
944 * Elf64's r_info field can have, so ignore it.
945 */
946 /* LINTED */
947 dst->r_info = ELF64_R_INFO(ELF32_R_SYM(r->r_info),
948 ELF32_R_TYPE(r->r_info));
949 } else
950 *dst = ((Elf64_Rel *)src->d_buf)[ndx];
951
952 EDATA_READUNLOCKS(src);
953 return (dst);
954 }
955
956
957 int
958 gelf_update_rel(Elf_Data *dst, int ndx, GElf_Rel *src)
959 {
960 int class, rc = 1;
961 size_t entsize;
962
963 if (dst == NULL)
964 return (0);
965
966 class = EDATA_CLASS(dst);
967 if (class == ELFCLASS32)
968 entsize = sizeof (Elf32_Rel);
969 else if (class == ELFCLASS64)
970 entsize = sizeof (GElf_Rel);
971 else {
972 _elf_seterr(EREQ_CLASS, 0);
973 return (0);
974 }
975 ELFWLOCK(EDATA_ELF(dst));
976
977 if ((entsize * ndx) >= dst->d_size) {
978 _elf_seterr(EREQ_RAND, 0);
979 rc = 0;
980 } else if (class == ELFCLASS32) {
981 Elf32_Rel * r = &((Elf32_Rel *)dst->d_buf)[ndx];
982
983 /* LINTED */
984 r->r_offset = (Elf32_Addr) src->r_offset;
985
986 /*
987 * Elf32 will never have the extra data field that
988 * Elf64's r_info field can have, so ignore it.
989 */
990 /* LINTED */
991 r->r_info = ELF32_R_INFO(ELF64_R_SYM(src->r_info),
992 ELF64_R_TYPE(src->r_info));
993
994 } else {
995 ((Elf64_Rel *)dst->d_buf)[ndx] = *(Elf64_Rel *)src;
996 }
997
998 ELFUNLOCK(EDATA_ELF(dst));
999 return (rc);
1000 }
1001
1002 long
1003 gelf_checksum(Elf *elf)
1004 {
1005 int class = gelf_getclass(elf);
1006
1007 if (class == ELFCLASS32)
1008 return (elf32_checksum(elf));
1009 else if (class == ELFCLASS64)
1010 return (elf64_checksum(elf));
1011
1012 _elf_seterr(EREQ_CLASS, 0);
1013 return (0);
1014 }
1015
1016 GElf_Cap *
1017 gelf_getcap(Elf_Data *data, int ndx, GElf_Cap *dst)
1018 {
1019 int class;
1020 size_t entsize;
1021
1022 if (data == NULL)
1023 return (NULL);
1024
1025 class = EDATA_CLASS(data);
1026 if (class == ELFCLASS32)
1027 entsize = sizeof (Elf32_Cap);
1028 else if (class == ELFCLASS64)
1029 entsize = sizeof (GElf_Cap);
1030 else {
1031 _elf_seterr(EREQ_CLASS, 0);
1032 return (NULL);
1033 }
1034
1035 EDATA_READLOCKS(data);
1036
1037 if ((entsize * ndx) >= data->d_size) {
1038 _elf_seterr(EREQ_RAND, 0);
1039 dst = NULL;
1040 } else if (class == ELFCLASS32) {
1041 Elf32_Cap *c = &(((Elf32_Cap *)data->d_buf)[ndx]);
1042
1043 dst->c_tag = (Elf64_Xword)c->c_tag;
1044 dst->c_un.c_val = (Elf64_Xword)c->c_un.c_val;
1045 } else
1046 *dst = ((GElf_Cap *)data->d_buf)[ndx];
1047
1048 EDATA_READUNLOCKS(data);
1049 return (dst);
1050 }
1051
1052 int
1053 gelf_update_cap(Elf_Data *dst, int ndx, GElf_Cap *src)
1054 {
1055 int class, rc = 1;
1056 size_t entsize;
1057
1058 if (dst == NULL)
1059 return (0);
1060
1061 class = EDATA_CLASS(dst);
1062 if (class == ELFCLASS32)
1063 entsize = sizeof (Elf32_Cap);
1064 else if (class == ELFCLASS64)
1065 entsize = sizeof (GElf_Cap);
1066 else {
1067 _elf_seterr(EREQ_CLASS, 0);
1068 return (0);
1069 }
1070
1071 ELFWLOCK(EDATA_ELF(dst));
1072
1073 if ((entsize * ndx) >= dst->d_size) {
1074 _elf_seterr(EREQ_RAND, 0);
1075 rc = 0;
1076 } else if (class == ELFCLASS32) {
1077 Elf32_Cap *c = &(((Elf32_Cap *)dst->d_buf)[ndx]);
1078
1079 c->c_tag = (Elf32_Word)src->c_tag;
1080 c->c_un.c_val = (Elf32_Word)src->c_un.c_val;
1081 } else
1082 ((Elf64_Cap *)dst->d_buf)[ndx] = *((Elf64_Cap *)src);
1083
1084 ELFUNLOCK(EDATA_ELF(dst));
1085 return (rc);
1086 }
1087
1088 /*
1089 * If the specified object has a dynamic section, and that section
1090 * contains a DT_FLAGS_1 entry, then return the value of that entry.
1091 * Otherwise, return 0.
1092 */
1093 GElf_Xword
1094 _gelf_getdyndtflags_1(Elf *elf)
1095 {
1096 Elf_Scn *scn = NULL;
1097 Elf_Data *data;
1098 GElf_Shdr shdr;
1099 GElf_Dyn dyn;
1100 int i, n;
1101
1102 while (scn = elf_nextscn(elf, scn)) {
1103 if (gelf_getshdr(scn, &shdr) == NULL)
1104 break;
1105 if (shdr.sh_type != SHT_DYNAMIC)
1106 continue;
1107 if (data = elf_getdata(scn, NULL)) {
1108 n = shdr.sh_size / shdr.sh_entsize;
1109 for (i = 0; i < n; i++) {
1110 (void) gelf_getdyn(data, i, &dyn);
1111 if (dyn.d_tag == DT_FLAGS_1) {
1112 return (dyn.d_un.d_val);
1113 }
1114 }
1115 }
1116 break;
1117 }
1118 return (0);
1119 }
unleashed repo fork