Lines Matching refs:src
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
48 * o adding a new type ELF_T_* to usr/src/head/libelf.h
848 xlate(Elf_Data *dst, const Elf_Data *src, unsigned encode, int tof)
857 if (dst == 0 || src == 0)
864 (sver = src->d_version - 1) >= EV_CURRENT) {
868 if ((type = src->d_type) >= ELF_T_NUM) {
882 cnt = src->d_size / ssz;
896 * these segments, allow for the src destination to be 0.
898 if (src->d_buf && src->d_buf != dst->d_buf)
899 (void) memcpy(dst->d_buf, src->d_buf, src->d_size);
900 dst->d_type = src->d_type;
901 dst->d_size = src->d_size;
905 (*f)(dst->d_buf, src->d_buf, cnt);
907 dst->d_type = src->d_type;
913 elf64_xlatetof(Elf_Data *dst, const Elf_Data *src, unsigned encode)
915 return (xlate(dst, src, encode, 1));
920 elf64_xlatetom(Elf_Data *dst, const Elf_Data *src, unsigned encode)
922 return (xlate(dst, src, encode, 0));
938 $1(Byte *dst, Elf64_Addr *src, size_t cnt)
940 Elf64_Addr *end = src + cnt;
943 tofa(dst, *src, A_$2);
945 } while (++src < end);
953 byte_to(Byte *dst, Byte *src, size_t cnt)
955 if (dst != src)
956 (void) memcpy(dst, src, cnt);
962 $1(Byte *dst, Elf64_Dyn *src, size_t cnt)
964 Elf64_Dyn *end = src + cnt;
967 tofx(dst, src->d_tag, D1_tag_$2);
968 tofx(dst, src->d_un.d_val, D1_val_$2);
970 } while (++src < end);
979 $1(Byte *dst, Elf64_Ehdr *src, size_t cnt)
981 Elf64_Ehdr *end = src + cnt;
984 if (&dst[E1_ident] != src->e_ident)
985 (void) memcpy(&dst[E1_ident], src->e_ident, E1_Nident);
986 tofh(dst, src->e_type, E1_type_$2);
987 tofh(dst, src->e_machine, E1_machine_$2);
988 tofw(dst, src->e_version, E1_version_$2);
989 tofa(dst, src->e_entry, E1_entry_$2);
990 tofo(dst, src->e_phoff, E1_phoff_$2);
991 tofo(dst, src->e_shoff, E1_shoff_$2);
992 tofw(dst, src->e_flags, E1_flags_$2);
993 tofh(dst, src->e_ehsize, E1_ehsize_$2);
994 tofh(dst, src->e_phentsize, E1_phentsize_$2);
995 tofh(dst, src->e_phnum, E1_phnum_$2);
996 tofh(dst, src->e_shentsize, E1_shentsize_$2);
997 tofh(dst, src->e_shnum, E1_shnum_$2);
998 tofh(dst, src->e_shstrndx, E1_shstrndx_$2);
1000 } while (++src < end);
1009 $1(Byte *dst, Elf64_Half *src, size_t cnt)
1011 Elf64_Half *end = src + cnt;
1014 tofh(dst, *src, H_$2);
1016 } while (++src < end);
1025 $1(unsigned char *dst, Elf64_Move *src, size_t cnt)
1027 Elf64_Move *end = src + cnt;
1030 tofl(dst, src->m_value, M1_value_$2);
1031 tofw(dst, src->m_info, M1_info_$2);
1032 tofw(dst, src->m_poffset, M1_poffset_$2);
1033 tofh(dst, src->m_repeat, M1_repeat_$2);
1034 tofh(dst, src->m_stride, M1_stride_$2);
1036 } while (++src < end);
1045 $1(unsigned char *dst, Elf64_Move *src, size_t cnt)
1047 Elf64_Move *end = src + cnt;
1050 tofl(dst, src->m_value, MP1_value_$2);
1051 tofw(dst, src->m_info, MP1_info_$2);
1052 tofw(dst, src->m_poffset, MP1_poffset_$2);
1053 tofh(dst, src->m_repeat, MP1_repeat_$2);
1054 tofh(dst, src->m_stride, MP1_stride_$2);
1056 } while (++src < end);
1065 $1(Byte *dst, Elf64_Off *src, size_t cnt)
1067 Elf64_Off *end = src + cnt;
1070 tofo(dst, *src, O_$2);
1072 } while (++src < end);
1081 $1(unsigned char *dst, Elf64_Nhdr *src, size_t cnt)
1084 Elf64_Nhdr *end = (Elf64_Nhdr *)((char *)src + cnt);
1098 namesz = S_ROUND(src->n_namesz, sizeof (Elf64_Word));
1099 descsz = src->n_descsz;
1105 (char *) src) >= (char *) end)
1107 tofw(dst, src->n_namesz, N1_namesz_$2);
1110 (char *) src) >= (char *) end)
1112 tofw(dst, src->n_descsz, N1_descsz_$2);
1115 (char *) src) >= (char *) end)
1117 tofw(dst, src->n_type, N1_type_$2);
1123 src++;
1124 if ((namesz + (char *) src) > (char *) end) {
1125 namesz = (char *) end - (char *) src;
1129 (void)memcpy(dst, src, namesz);
1135 src = (Elf64_Nhdr *)((uintptr_t)src + namesz);
1136 if ((descsz + (char *) src) > (char *) end) {
1137 descsz = (char *) end - (char *) src;
1141 (void)memcpy(dst, src, descsz);
1145 src = (Elf64_Nhdr *)((uintptr_t)src + descsz);
1146 } while (src < end);
1155 $1(Byte *dst, Elf64_Phdr *src, size_t cnt)
1157 Elf64_Phdr *end = src + cnt;
1160 tofw(dst, src->p_type, P1_type_$2);
1161 tofw(dst, src->p_flags, P1_flags_$2);
1162 tofo(dst, src->p_offset, P1_offset_$2);
1163 tofa(dst, src->p_vaddr, P1_vaddr_$2);
1164 tofa(dst, src->p_paddr, P1_paddr_$2);
1165 tofx(dst, src->p_filesz, P1_filesz_$2);
1166 tofx(dst, src->p_memsz, P1_memsz_$2);
1167 tofx(dst, src->p_align, P1_align_$2);
1169 } while (++src < end);
1178 $1(Byte *dst, Elf64_Rel *src, size_t cnt)
1180 Elf64_Rel *end = src + cnt;
1183 tofa(dst, src->r_offset, R1_offset_$2);
1184 tofx(dst, src->r_info, R1_info_$2);
1186 } while (++src < end);
1195 $1(Byte *dst, Elf64_Rela *src, size_t cnt)
1197 Elf64_Rela *end = src + cnt;
1200 tofa(dst, src->r_offset, RA1_offset_$2);
1201 tofx(dst, src->r_info, RA1_info_$2);
1204 tofx(dst, src->r_addend, RA1_addend_$2);
1208 if (src->r_addend < 0) {
1209 w = - src->r_addend;
1212 w = src->r_addend;
1216 } while (++src < end);
1225 $1(Byte *dst, Elf64_Shdr *src, size_t cnt)
1227 Elf64_Shdr *end = src + cnt;
1230 tofw(dst, src->sh_name, SH1_name_$2);
1231 tofw(dst, src->sh_type, SH1_type_$2);
1232 tofx(dst, src->sh_flags, SH1_flags_$2);
1233 tofa(dst, src->sh_addr, SH1_addr_$2);
1234 tofo(dst, src->sh_offset, SH1_offset_$2);
1235 tofx(dst, src->sh_size, SH1_size_$2);
1236 tofw(dst, src->sh_link, SH1_link_$2);
1237 tofw(dst, src->sh_info, SH1_info_$2);
1238 tofx(dst, src->sh_addralign, SH1_addralign_$2);
1239 tofx(dst, src->sh_entsize, SH1_entsize_$2);
1241 } while (++src < end);
1250 $1(Byte *dst, Elf64_Sword *src, size_t cnt)
1252 Elf64_Sword *end = src + cnt;
1257 tofw(dst, *src, W_$2);
1261 if (*src < 0) {
1262 w = - *src;
1265 w = *src;
1269 } while (++src < end);
1278 $1(unsigned char *dst, Elf64_Cap *src, size_t cnt)
1280 Elf64_Cap *end = src + cnt;
1283 tofx(dst, src->c_tag, C1_tag_$2);
1284 tofx(dst, src->c_un.c_val, C1_val_$2);
1286 } while (++src < end);
1295 $1(unsigned char *dst, Elf64_Syminfo *src, size_t cnt)
1297 Elf64_Syminfo *end = src + cnt;
1300 tofh(dst, src->si_boundto, SI1_boundto_$2);
1301 tofh(dst, src->si_flags, SI1_flags_$2);
1303 } while (++src < end);
1312 $1(Byte *dst, Elf64_Sym *src, size_t cnt)
1314 Elf64_Sym *end = src + cnt;
1317 tofw(dst, src->st_name, ST1_name_$2);
1318 tofb(dst, src->st_info, ST1_info_$2);
1319 tofb(dst, src->st_other, ST1_other_$2);
1320 tofh(dst, src->st_shndx, ST1_shndx_$2);
1321 tofa(dst, src->st_value, ST1_value_$2);
1322 tofx(dst, src->st_size, ST1_size_$2);
1324 } while (++src < end);
1333 $1(Byte *dst, Elf64_Word *src, size_t cnt)
1335 Elf64_Word *end = src + cnt;
1338 tofw(dst, *src, W_$2);
1340 } while (++src < end);
1349 $1(Byte *dst, Elf64_Verdef *src, size_t cnt)
1352 Elf64_Verdef *end = (Elf64_Verdef *)((Byte *)src + cnt);
1362 next_verdef = (Elf64_Verdef *)(src->vd_next ?
1363 (Byte *)src + src->vd_next : (Byte *)end);
1364 dst_next = dst + src->vd_next;
1367 vaux = (Elf64_Verdaux *)((Byte *)src + src->vd_aux);
1368 vaux_dst = dst + src->vd_aux;
1373 for (i = 0; i < src->vd_cnt; i++) {
1396 tofh(dst, src->vd_version, VD1_version_$2);
1397 tofh(dst, src->vd_flags, VD1_flags_$2);
1398 tofh(dst, src->vd_ndx, VD1_ndx_$2);
1399 tofh(dst, src->vd_cnt, VD1_cnt_$2);
1400 tofw(dst, src->vd_hash, VD1_hash_$2);
1401 tofw(dst, src->vd_aux, VD1_aux_$2);
1402 tofw(dst, src->vd_next, VD1_next_$2);
1403 src = next_verdef;
1405 } while (src < end);
1413 $1(Byte *dst, Elf64_Verneed *src, size_t cnt)
1416 Elf64_Verneed *end = (Elf64_Verneed *)((char *)src + cnt);
1426 next_verneed = (Elf64_Verneed *)(src->vn_next ?
1427 (Byte *)src + src->vn_next : (Byte *)end);
1428 dst_next = dst + src->vn_next;
1431 vaux = (Elf64_Vernaux *)((Byte *)src + src->vn_aux);
1432 vaux_dst = dst + src->vn_aux;
1437 for (i = 0; i < src->vn_cnt; i++) {
1463 tofh(dst, src->vn_version, VN1_version_$2);
1464 tofh(dst, src->vn_cnt, VN1_cnt_$2);
1465 tofw(dst, src->vn_file, VN1_file_$2);
1466 tofw(dst, src->vn_aux, VN1_aux_$2);
1467 tofw(dst, src->vn_next, VN1_next_$2);
1468 src = next_verneed;
1470 } while (src < end);
1479 $1(Byte *dst, Elf64_Sxword *src, size_t cnt)
1481 Elf64_Sxword *end = src + cnt;
1486 tofx(dst, *src, X_$2);
1491 if (*src < 0) {
1492 w = - *src;
1495 w = *src;
1499 } while (++src < end);
1508 $1(Byte *dst, Elf64_Xword *src, size_t cnt)
1510 Elf64_Xword *end = src + cnt;
1513 tofx(dst, *src, X_$2);
1515 } while (++src < end);
1535 $1(Elf64_Addr *dst, Byte *src, size_t cnt)
1540 src += cnt * A_sizeof;
1542 src -= A_sizeof;
1543 *dst = toma(src, A_$2);
1553 $1(Elf64_Dyn *dst, Byte *src, size_t cnt)
1558 dst->d_tag = tomx(src, D1_tag_$2);
1559 dst->d_un.d_val = tomx(src, D1_val_$2);
1560 src += D1_sizeof;
1570 $1(Elf64_Ehdr *dst, Byte *src, size_t cnt)
1575 src += cnt * E1_sizeof;
1577 src -= E1_sizeof;
1578 dst->e_shstrndx = tomh(src, E1_shstrndx_$2);
1579 dst->e_shnum = tomh(src, E1_shnum_$2);
1580 dst->e_shentsize = tomh(src, E1_shentsize_$2);
1581 dst->e_phnum = tomh(src, E1_phnum_$2);
1582 dst->e_phentsize = tomh(src, E1_phentsize_$2);
1583 dst->e_ehsize = tomh(src, E1_ehsize_$2);
1584 dst->e_flags = tomw(src, E1_flags_$2);
1585 dst->e_shoff = tomo(src, E1_shoff_$2);
1586 dst->e_phoff = tomo(src, E1_phoff_$2);
1587 dst->e_entry = toma(src, E1_entry_$2);
1588 dst->e_version = tomw(src, E1_version_$2);
1589 dst->e_machine = tomh(src, E1_machine_$2);
1590 dst->e_type = tomh(src, E1_type_$2);
1591 if (dst->e_ident != &src[E1_ident])
1592 (void) memcpy(dst->e_ident, &src[E1_ident], E1_Nident);
1602 $1(Elf64_Half *dst, Byte *src, size_t cnt)
1607 src += cnt * H_sizeof;
1609 src -= H_sizeof;
1610 *dst = tomh(src, H_$2);
1620 $1(Elf64_Move *dst, unsigned char *src, size_t cnt)
1625 dst->m_value = toml(src, M1_value_$2);
1626 dst->m_info = tomw(src, M1_info_$2);
1627 dst->m_poffset = tomw(src, M1_poffset_$2);
1628 dst->m_repeat = tomh(src, M1_repeat_$2);
1629 dst->m_stride = tomh(src, M1_stride_$2);
1630 src += M1_sizeof;
1640 $1(Elf64_Move *dst, unsigned char *src, size_t cnt)
1646 dst->m_value = toml(src, MP1_value_$2);
1647 dst->m_info = tomw(src, MP1_info_$2);
1648 dst->m_poffset = tomw(src, MP1_poffset_$2);
1649 dst->m_repeat = tomh(src, MP1_repeat_$2);
1650 dst->m_stride = tomh(src, MP1_stride_$2);
1651 src += MP1_sizeof;
1661 $1(Elf64_Nhdr *dst, unsigned char *src, size_t cnt)
1680 dst->n_namesz = tomw(src, N1_namesz_$2);
1685 dst->n_descsz = tomw(src, N1_descsz_$2);
1690 dst->n_type = tomw(src, N1_type_$2);
1695 namestr = src + N1_sizeof;
1718 src = (unsigned char *)desc + field_sz;
1727 $1(Elf64_Off *dst, Byte *src, size_t cnt)
1732 src += cnt * O_sizeof;
1734 src -= O_sizeof;
1735 *dst = tomo(src, O_$2);
1745 $1(Elf64_Phdr *dst, Byte *src, size_t cnt)
1750 src += cnt * P1_sizeof;
1752 src -= P1_sizeof;
1753 dst->p_align = tomx(src, P1_align_$2);
1754 dst->p_memsz = tomx(src, P1_memsz_$2);
1755 dst->p_filesz = tomx(src, P1_filesz_$2);
1756 dst->p_paddr = toma(src, P1_paddr_$2);
1757 dst->p_vaddr = toma(src, P1_vaddr_$2);
1758 dst->p_offset = tomo(src, P1_offset_$2);
1759 dst->p_flags = tomw(src, P1_flags_$2);
1760 dst->p_type = tomw(src, P1_type_$2);
1770 $1(Elf64_Rel *dst, Byte *src, size_t cnt)
1775 src += cnt * R1_sizeof;
1777 src -= R1_sizeof;
1778 dst->r_info = tomx(src, R1_info_$2);
1779 dst->r_offset = toma(src, R1_offset_$2);
1789 $1(Elf64_Rela *dst, Byte *src, size_t cnt)
1794 src += cnt * RA1_sizeof;
1796 src -= RA1_sizeof;
1800 dst->r_addend = tomx(src, RA1_addend_$2);
1807 if ((u.w = tomx(src, RA1_addend_$2)) & HI64) {
1815 dst->r_info = tomx(src, RA1_info_$2);
1816 dst->r_offset = toma(src, RA1_offset_$2);
1826 $1(Elf64_Shdr *dst, Byte *src, size_t cnt)
1831 src += cnt * SH1_sizeof;
1833 src -= SH1_sizeof;
1834 dst->sh_entsize = tomx(src, SH1_entsize_$2);
1835 dst->sh_addralign = tomx(src, SH1_addralign_$2);
1836 dst->sh_info = tomw(src, SH1_info_$2);
1837 dst->sh_link = tomw(src, SH1_link_$2);
1838 dst->sh_size = tomx(src, SH1_size_$2);
1839 dst->sh_offset = tomo(src, SH1_offset_$2);
1840 dst->sh_addr = toma(src, SH1_addr_$2);
1841 dst->sh_flags = tomx(src, SH1_flags_$2);
1842 dst->sh_type = tomw(src, SH1_type_$2);
1843 dst->sh_name = tomw(src, SH1_name_$2);
1853 $1(Elf64_Sword *dst, Byte *src, size_t cnt)
1858 src += cnt * W_sizeof;
1860 src -= W_sizeof;
1864 *dst = tomw(src, W_$2);
1871 if ((u.w = tomw(src, W_$2)) & HI32) {
1887 $1(Elf64_Cap *dst, unsigned char *src, size_t cnt)
1892 dst->c_tag = tomx(src, C1_tag_$2);
1893 dst->c_un.c_val = tomx(src, C1_val_$2);
1894 src += C1_sizeof;
1904 $1(Elf64_Syminfo *dst, unsigned char *src, size_t cnt)
1909 src += cnt * SI1_sizeof;
1912 src -= SI1_sizeof;
1913 dst->si_boundto = tomh(src, SI1_boundto_$2);
1914 dst->si_flags = tomh(src, SI1_flags_$2);
1924 $1(Elf64_Sym *dst, Byte *src, size_t cnt)
1929 src += cnt * ST1_sizeof;
1931 src -= ST1_sizeof;
1932 dst->st_size = tomx(src, ST1_size_$2);
1933 dst->st_value = toma(src, ST1_value_$2);
1934 dst->st_shndx = tomh(src, ST1_shndx_$2);
1935 dst->st_other = tomb(src, ST1_other_$2);
1936 dst->st_info = tomb(src, ST1_info_$2);
1937 dst->st_name = tomw(src, ST1_name_$2);
1947 $1(Elf64_Word *dst, Byte *src, size_t cnt)
1952 src += cnt * W_sizeof;
1954 src -= W_sizeof;
1955 *dst = tomw(src, W_$2);
1965 $1(Elf64_Verdef *dst, Byte *src, size_t cnt)
1975 dst->vd_version = tomh(src, VD1_version_$2);
1976 dst->vd_flags = tomh(src, VD1_flags_$2);
1977 dst->vd_ndx = tomh(src, VD1_ndx_$2);
1978 dst->vd_cnt = tomh(src, VD1_cnt_$2);
1979 dst->vd_hash = tomw(src, VD1_hash_$2);
1980 dst->vd_aux = tomw(src, VD1_aux_$2);
1981 dst->vd_next = tomw(src, VD1_next_$2);
1983 src_vaux = src + dst->vd_aux;
1994 src += dst->vd_next;
2007 $1(Elf64_Verneed *dst, Byte *src, size_t cnt)
2017 dst->vn_version = tomh(src, VN1_version_$2);
2018 dst->vn_cnt = tomh(src, VN1_cnt_$2);
2019 dst->vn_file = tomw(src, VN1_file_$2);
2020 dst->vn_aux = tomw(src, VN1_aux_$2);
2021 dst->vn_next = tomw(src, VN1_next_$2);
2023 src_vaux = src + dst->vn_aux;
2037 src += dst->vn_next;
2050 $1(Elf64_Sxword *dst, Byte *src, size_t cnt)
2055 src += cnt * X_sizeof;
2057 src -= X_sizeof;
2061 *dst = tomx(src, X_$2);
2068 if ((u.w = tomx(src, X_$2)) & HI64) {
2085 $1(Elf64_Xword *dst, Byte *src, size_t cnt)
2090 src += cnt * X_sizeof;
2092 src -= X_sizeof;
2093 *dst = tomx(src, X_$2);