Lines Matching refs:size_t
71 static size_t ldso_page_size;
88 const size_t *bloomwords = (const void *)(ght + 4); \
89 size_t f = bloomwords[gho & (ght[2] - 1)]; \
142 size_t reserved_size;
150 typedef void (*stage3_func)(size_t *, size_t *, size_t *);
160 static size_t *saved_addends, *apply_addends_to;
178 static size_t tls_cnt, tls_offset, tls_align = MIN_TLS_ALIGN;
179 static size_t static_tls_cnt;
240 int handle_asan_path_open(int fd, const char *name, ns_t *namespace, char *buf, size_t buf_size);
242 static void set_bss_vma_name(char *path_name, void *addr, size_t zeromap_size);
256 static bool get_app_path(char *path, size_t size)
333 for (size_t i = 0; i < inherits->num; i++) {
402 for (size_t i = 0; i < s_ns->num; i++) {
413 for (size_t i = 0; i < nsl->num; i++) {
423 void *laddr(const struct dso *p, size_t v)
425 size_t j=0;
430 static void *laddr_pg(const struct dso *p, size_t v)
432 size_t j=0;
433 size_t pgsz = PAGE_SIZE;
436 size_t a = p->loadmap->segs[j].p_vaddr;
437 size_t b = a + p->loadmap->segs[j].p_memsz;
459 static void decode_vec(size_t *v, size_t *a, size_t cnt)
461 size_t i;
471 static int search_vec(size_t *v, size_t *r, size_t key)
592 size_t i;
618 uint32_t *buckets = hashtab + 4 + hashtab[2]*(sizeof(size_t)/4);
816 uint32_t gho = gh / (8 * sizeof(size_t));
817 size_t ghm = 1ul << gh % (8 * sizeof(size_t));
823 const size_t *bloomwords = (const void *)(ght + 4);
824 size_t f = bloomwords[gho & (ght[2] - 1)];
866 uint32_t gh = s_info_g.sym_h, gho = gh / (8 * sizeof(size_t)), *ght;
867 size_t ghm = 1ul << gh % (8*sizeof(size_t));
905 uint32_t h = 0, gh = s_info_g.sym_h, gho = gh / (8 * sizeof(size_t)), *ght;
906 size_t ghm = 1ul << gh % (8 * sizeof(size_t));
944 uint32_t gh = s_info_g.sym_h, gho = gh / (8 * sizeof(size_t)), *ght;
945 size_t ghm = 1ul << gh % (8 * sizeof(size_t));
1002 for (size_t cnt = 0; cnt < verneed->vn_cnt; cnt++) {
1057 static void do_relocs(struct dso *dso, size_t *rel, size_t rel_size, size_t stride)
1068 size_t *reloc_addr;
1069 size_t sym_val;
1070 size_t tls_val;
1071 size_t addend;
1081 for (; rel_size; rel+=stride, rel_size-=stride*sizeof(size_t)) {
1148 sym_val = def.sym ? (size_t)laddr(def.dso, def.sym->st_value) : 0;
1161 addend -= (size_t)reloc_addr;
1168 memcpy(reloc_addr, &(size_t){sym_val + addend}, sizeof(size_t));
1171 *reloc_addr = (size_t)base + addend;
1175 else *reloc_addr = (size_t)base + addend;
1182 - (size_t)reloc_addr;
1185 *reloc_addr = def.sym ? (size_t)(def.dso->funcdescs
1191 reloc_addr[1] = def.sym ? (size_t)def.dso->got : 0;
1225 reloc_addr[0] = (size_t)__tlsdesc_dynamic;
1226 reloc_addr[1] = (size_t)new;
1228 reloc_addr[0] = (size_t)__tlsdesc_static;
1240 size_t tmp = reloc_addr[0];
1260 size_t size = p->lazy_cnt*3*sizeof(size_t);
1279 static void reclaim(struct dso *dso, size_t start, size_t end)
1291 size_t phcnt = dso->phnum;
1302 static ssize_t read_loop(int fd, void *p, size_t n)
1304 for (size_t i=0; i<n; ) {
1316 UT_STATIC void *mmap_fixed(void *p, size_t n, int prot, int flags, int fd, off_t off)
1348 size_t i;
1370 UT_STATIC bool get_random(void *buf, size_t buflen)
1388 UT_STATIC void fill_random_data(void *buf, size_t buflen)
1432 static size_t phdr_table_get_maxinum_alignment(Phdr *phdr_table, size_t phdr_count)
1435 size_t maxinum_alignment = PAGE_SIZE;
1436 size_t i = 0;
1477 size_t i, len;
1478 size_t shsize;
1559 size_t mapLen = sizeof(Ehdr);
1573 size_t phsize;
1574 size_t addr_min=SIZE_MAX, addr_max=0, map_len;
1575 size_t this_min, this_max;
1576 size_t nsegs = 0;
1582 size_t dyn=0;
1583 size_t tls_image=0;
1584 size_t i;
1586 size_t start_addr;
1587 size_t start_alignment = PAGE_SIZE;
1663 dso->loadmap->segs[i].addr = (size_t)map +
1669 size_t brk = (ph->p_vaddr & PAGE_SIZE-1)
1671 size_t pgbrk = brk + PAGE_SIZE-1 & -PAGE_SIZE;
1672 size_t pgend = brk + ph->p_memsz - ph->p_filesz
1695 size_t maxinum_alignment = phdr_table_get_maxinum_alignment(ph0, eh->e_phnum);
1706 start_addr = ((size_t)reserved_params->start_addr - 1 + PAGE_SIZE) & -PAGE_SIZE;
1714 size_t mapping_align = start_alignment > LIBRARY_ALIGNMENT ? start_alignment : LIBRARY_ALIGNMENT;
1715 size_t tmp_map_len = ALIGN(map_len, mapping_align) + mapping_align - PAGE_SIZE;
1729 reserved_params->reserved_size -= (map_len + (start_addr - (size_t)reserved_params->start_addr));
1758 size_t unused_part_1 = real_map - temp_map;
1759 size_t unused_part_2 = temp_map_end - (real_map + map_len);
1819 size_t brk = (size_t)base+ph->p_vaddr+ph->p_filesz;
1820 size_t pgbrk = brk+PAGE_SIZE-1 & -PAGE_SIZE;
1821 size_t zeromap_size = (size_t)base + this_max - pgbrk;
1823 if (pgbrk - (size_t)base < this_max && mmap_fixed((void *)pgbrk, zeromap_size, prot, MAP_PRIVATE | MAP_FIXED | MAP_ANONYMOUS, -1, 0) == MAP_FAILED)
1828 for (i=0; ((size_t *)(base+dyn))[i]; i+=2)
1829 if (((size_t *)(base+dyn))[i]==DT_TEXTREL) {
1856 static int path_open(const char *name, const char *s, char *buf, size_t buf_size)
1858 size_t l;
1882 UT_STATIC int fixup_rpath(struct dso *p, char *buf, size_t buf_size)
1884 size_t n, l;
1961 size_t dyn[DYN_CNT];
1962 size_t flags1 = 0;
1992 UT_STATIC size_t count_syms(struct dso *p)
1996 size_t nsym, i;
1997 uint32_t *buckets = p->ghashtab + 4 + (p->ghashtab[2]*sizeof(size_t)/4);
2011 static void *dl_mmap(size_t n)
2026 size_t nsym = count_syms(p);
2027 size_t i, size = nsym * sizeof(*p->funcdescs);
2065 size_t newlen = strlen(sys_path) + strlen(sys_path_default) + 2;
2080 for (size_t i = 0; i < ns->ns_dsos->num; i++) {
2092 for (size_t i = 0; i < ns->ns_dsos->num; i++) {
2124 for (size_t i = 0; i < ns->ns_inherits->num; i++) {
2145 for (size_t i = 0; i < ns->ns_inherits->num; i++) {
2165 size_t alloc_size;
2261 for (size_t i = 0; i < namespace->ns_inherits->num; i++) {
2316 size_t per_th = temp_dso.tls.size + temp_dso.tls.align
2349 p->new_dtv = (void *)(-sizeof(size_t) &
2350 (uintptr_t)(p->name+strlen(p->name)+sizeof(size_t)));
2376 size_t i, cnt=0;
2425 size_t i, j, cnt, ndeps_all;
2550 static void do_mips_relocs(struct dso *p, size_t *got)
2552 size_t i, j, rel[2];
2558 while (i--) *got++ += (size_t)base;
2564 for (i-=j; i; i--, sym++, rel[0]+=sizeof(size_t)) {
2570 static uint8_t* sleb128_decoder(uint8_t* current, uint8_t* end, size_t* value)
2572 size_t result = 0;
2573 static const size_t size = CHAR_BIT * sizeof(result);
2575 size_t shift = 0;
2584 result |= ((size_t)(byte & 127) << shift);
2589 result |= -((size_t)(1) << shift);
2597 static void do_android_relocs(struct dso *p, size_t dt_name, size_t dt_size)
2599 size_t android_rel_addr = 0, android_rel_size = 0;
2619 size_t relocs_num;
2620 size_t rel[3] = {0};
2625 for (size_t i = 0; i < relocs_num;) {
2627 size_t group_size, group_flags;
2632 size_t group_r_offset_delta = 0;
2642 const size_t addend_flags = group_flags & (RELOCATION_GROUP_HAS_ADDEND_FLAG | RELOCATION_GROUPED_BY_ADDEND_FLAG);
2646 size_t addend;
2653 for (size_t j = 0; j < group_size; j++) {
2657 size_t offset_detla;
2668 size_t addend;
2674 do_relocs(p, rel, sizeof(size_t) * 2, 2);
2676 do_relocs(p, rel, sizeof(size_t) * 3, 3);
2684 static void do_relr_relocs(struct dso *dso, size_t *relr, size_t relr_size)
2688 size_t *reloc_addr;
2689 for (; relr_size; relr++, relr_size -= sizeof(size_t))
2692 *reloc_addr++ += (size_t)base;
2695 for (size_t bitmap = relr[0]; (bitmap >>= 1); i++)
2697 reloc_addr[i] += (size_t)base;
2698 reloc_addr += 8 * sizeof(size_t) - 1;
2705 size_t dyn[DYN_CNT];
2741 size_t min_addr = -1, max_addr = 0, cnt;
2772 size_t dyn[DYN_CNT];
2788 size_t n = dyn[DT_FINI_ARRAYSZ]/sizeof(size_t);
2789 size_t *fn = (size_t *)laddr(p, dyn[DT_FINI_ARRAY])+n;
2812 size_t cnt, qpos, spos, i;
2875 size_t dyn[DYN_CNT], i;
2899 size_t n = dyn[DT_INIT_ARRAYSZ]/sizeof(size_t);
2900 size_t *fn = laddr(p, dyn[DT_INIT_ARRAY]);
2932 void __init_tls(size_t *auxv)
2955 size_t i, j;
2956 size_t old_cnt = self->dtv[0];
3009 hidden void __dls2(unsigned char *base, size_t *sp)
3011 size_t *auxv;
3018 size_t aux[AUX_CNT];
3029 size_t aux[AUX_CNT];
3048 size_t dyn[DYN_CNT];
3050 size_t *rel = laddr(&ldso, dyn[DT_REL]);
3051 size_t rel_size = dyn[DT_RELSZ];
3052 size_t symbolic_rel_cnt = 0;
3054 for (; rel_size; rel+=2, rel_size-=2*sizeof(size_t))
3057 size_t addends[symbolic_rel_cnt+1];
3079 void __dls2b(size_t *sp, size_t *auxv, size_t *aux)
3102 void __dls3(size_t *sp, size_t *auxv, size_t *aux)
3105 size_t i;
3108 size_t vdso_base;
3143 if (aux[AT_PHDR] != (size_t)ldso.phdr) {
3144 size_t interp_off = 0;
3145 size_t tls_image = 0;
3154 interp_off = (size_t)phdr->p_vaddr;
3174 size_t l = strlen(ldname);
3223 aux[AT_ENTRY] = (size_t)laddr(&app, ehdr->e_entry);
3255 app.loadmap->segs[0].addr = (size_t)app.map;
3256 app.loadmap->segs[0].p_vaddr = (size_t)app.map
3257 - (size_t)app.base;
3350 app.dynv[i+1] = (size_t)&debug;
3352 size_t *ptr = (size_t *) app.dynv[i+1];
3353 *ptr = (size_t)&debug;
3356 size_t *ptr = (size_t *)((size_t)&app.dynv[i] + app.dynv[i+1]);
3357 *ptr = (size_t)&debug;
3401 size_t tmp_tls_size = libc.tls_size;
3447 size_t dyn[DYN_CNT], n, flags1=0;
3454 size_t j=0; search_vec(p->dynv, &j, DT_MIPS_GOTSYM);
3455 size_t i=0; search_vec(p->dynv, &i, DT_MIPS_SYMTABNO);
3458 p->lazy = calloc(n, 3*sizeof(size_t));
3532 caller = (struct dso *)addr2dso((size_t)caller_addr);
3557 size_t orig_tls_cnt, orig_tls_offset, orig_tls_align;
3558 size_t i;
3624 caller = (struct dso *)addr2dso((size_t)caller_addr);
3801 for (size_t i = 0; reloc_head_so->deps[i]; i++) {
3932 caller = (struct dso *)addr2dso((size_t)caller_addr);
4026 caller = (struct dso *)addr2dso((size_t)caller_addr);
4080 for (size_t i = 0; i < ns->ns_dsos->num; i++) {
4082 for (size_t j = i + 1; j < ns->ns_dsos->num; j++) {
4099 void *addr2dso(size_t a)
4102 size_t i;
4104 if (a < p->map || a - (size_t)p->map >= p->map_len) continue;
4106 size_t phcnt = p->phnum;
4107 size_t entsz = p->phentsize;
4108 size_t base = (size_t)p->base;
4114 if (a-(size_t)p->map < p->map_len)
4130 p = addr2dso((size_t)ra);
4143 caller = (struct dso *)addr2dso((size_t)ra);
4311 size_t n;
4406 for (size_t deps_num = 0; p->deps[deps_num]; deps_num++) {
4434 size_t dyn[DYN_CNT];
4437 n = dyn[DT_FINI_ARRAYSZ] / sizeof(size_t);
4438 size_t *fn = (size_t *)laddr(ef->dso, dyn[DT_FINI_ARRAY]) + n;
4497 static inline int sym_is_matched(const Sym* sym, size_t addr_offset_so) {
4504 static inline Sym* find_addr_by_elf(size_t addr_offset_so, struct dso *p) {
4516 static inline Sym* find_addr_by_gnu(size_t addr_offset_so, struct dso *p) {
4518 size_t i, nsym, first_hash_sym_index;
4521 uint32_t *buckets = p->ghashtab + 4 + (p->ghashtab[2] * sizeof(size_t) / 4);
4558 size_t addr = (size_t)addr_arg;
4570 size_t addr_offset_so = addr - (size_t)p->base;
4644 size_t l = strnlen(s, sizeof redir);
4663 int dl_iterate_phdr(int(*callback)(struct dl_phdr_info *info, size_t size, void *data), void *data)
4817 int handle_asan_path_open(int fd, const char *name, ns_t *namespace, char *buf, size_t buf_size)
4826 size_t newlen = strlen(namespace->asan_lib_paths) + strlen(namespace->lib_paths) + 2;
4872 size_t buf_size = sizeof task->buf;
4873 size_t l;
4907 size_t newlen = strlen(namespace->asan_lib_paths) + strlen(namespace->lib_paths) + 2;
4979 size_t end_locator_len = sizeof(end_locator);
4980 size_t end_locator_pos = zip_file_len - end_locator_len;
5059 size_t mapLen = sizeof(Ehdr);
5073 size_t i;
5074 size_t str_size;
5148 task->dyn_addr = (size_t *)((unsigned char *)task->dyn_map + (ph->p_offset - off_start));
5149 size_t dyn_tmp;
5214 size_t addr_min = SIZE_MAX, addr_max = 0, map_len;
5215 size_t this_min, this_max;
5216 size_t nsegs = 0;
5221 size_t i;
5223 size_t start_addr;
5224 size_t start_alignment = PAGE_SIZE;
5280 task->p->loadmap->segs[i].addr = (size_t)map +
5286 size_t brk = (ph->p_vaddr & PAGE_SIZE - 1) + ph->p_filesz;
5287 size_t pgbrk = (brk + PAGE_SIZE - 1) & -PAGE_SIZE;
5288 size_t pgend = (brk + ph->p_memsz - ph->p_filesz + PAGE_SIZE - 1) & -PAGE_SIZE;
5311 size_t maxinum_alignment = phdr_table_get_maxinum_alignment(task->ph0, task->eh->e_phnum);
5323 start_addr = ((size_t)reserved_params->start_addr - 1 + PAGE_SIZE) & -PAGE_SIZE;
5331 size_t mapping_align = start_alignment > LIBRARY_ALIGNMENT ? start_alignment : LIBRARY_ALIGNMENT;
5332 size_t tmp_map_len = ALIGN(map_len, mapping_align) + mapping_align - PAGE_SIZE;
5349 reserved_params->reserved_size -= (map_len + (start_addr - (size_t)reserved_params->start_addr));
5383 size_t unused_part_1 = real_map - temp_map;
5384 size_t unused_part_2 = temp_map_end - (real_map + map_len);
5446 size_t brk = (size_t)base + ph->p_vaddr + ph->p_filesz;
5447 size_t pgbrk = brk + PAGE_SIZE - 1 & -PAGE_SIZE;
5448 size_t zeromap_size = (size_t)base + this_max - pgbrk;
5450 if (pgbrk - (size_t)base < this_max && mmap_fixed(
5464 for (i = 0; ((size_t *)(base + task->dyn))[i]; i += NEXT_DYNAMIC_INDEX) {
5465 if (((size_t *)(base + task->dyn))[i] == DT_TEXTREL) {
5529 size_t alloc_size;
5660 for (size_t i = 0; i < namespace->ns_inherits->num; i++) {
5714 size_t per_th = task->tls.size + task->tls.align + sizeof(void *) * (tls_cnt + TLS_CNT_INCREASE);
5738 size_t rpath_offset;
5739 size_t runpath_offset;
5752 task->p->new_dtv = (void *)(-sizeof(size_t) &
5753 (uintptr_t)(task->p->name + strlen(task->p->name) + sizeof(size_t)));
5833 size_t i, cnt = 0;
5913 for (size_t i = 0; i < tasks->length; i++) {
5951 for (size_t i = 0; i < tasks->length; i++) {
6138 static void set_bss_vma_name(char *path_name, void *addr, size_t zeromap_size)
6157 size_t cnt;
6161 size_t seg_start = p->base + ph->p_vaddr;
6162 size_t seg_file_end = seg_start + ph->p_filesz + PAGE_SIZE - 1 & -PAGE_SIZE;
6163 size_t seg_max_addr = seg_start + ph->p_memsz + PAGE_SIZE - 1 & -PAGE_SIZE;
6164 size_t zeromap_size = seg_max_addr - seg_file_end;
6307 for (size_t i = 0; p->deps[i]; i++) {
6315 for (size_t i = 0; p->deps_all[i]; i++) {