libkern/kxld/kxld_sect.c

42 static kern_return_t export_macho(const KXLDSect *sect, u_char *buf, u_long offset,
45 static kern_return_t sect_export_macho_header_32(const KXLDSect *sect, u_char *buf,
49 static kern_return_t sect_export_macho_header_64(const KXLDSect *sect, u_char *buf,
57 kxld_sect_init_from_macho_32(KXLDSect *sect, u_char *macho, u_long *sect_offset,
64     check(sect);
68     strlcpy(sect->segname, src->segname, sizeof(sect->segname));
69     strlcpy(sect->sectname, src->sectname, sizeof(sect->sectname));
70     sect->base_addr = src->addr;
71     sect->link_addr = src->addr;
72     sect->size = src->size;
73     sect->sectnum = sectnum;
74     sect->flags = src->flags;
75     sect->align = src->align;
76     sect->reserved1 = src->reserved1;
77     sect->reserved2 = src->reserved2;
80         sect->data = macho + src->offset;
82         sect->data = NULL;
87     rval = kxld_reloc_create_macho(&sect->relocs, relocator,
95     if (rval) kxld_sect_deinit(sect);
105 kxld_sect_init_from_macho_64(KXLDSect *sect, u_char *macho, u_long *sect_offset,
112     check(sect);
116     strlcpy(sect->segname, src->segname, sizeof(sect->segname));
117     strlcpy(sect->sectname, src->sectname, sizeof(sect->sectname));
118     sect->base_addr = src->addr;
119     sect->link_addr = src->addr;
120     sect->size = src->size;
121     sect->sectnum = sectnum;
122     sect->flags = src->flags;
123     sect->align = src->align;
124     sect->reserved1 = src->reserved1;
125     sect->reserved2 = src->reserved2;
128         sect->data = macho + src->offset;
130         sect->data = NULL;
135     rval = kxld_reloc_create_macho(&sect->relocs, relocator,
143     if (rval) kxld_sect_deinit(sect);
154 kxld_sect_init_got(KXLDSect *sect, u_int ngots)
158     check(sect);
160     strlcpy(sect->segname, KXLD_SEG_GOT, sizeof(sect->segname));
161     strlcpy(sect->sectname, KXLD_SECT_GOT, sizeof(sect->sectname));
162     sect->base_addr = 0;
163     sect->link_addr = 0;
164     sect->flags = 0;
165     sect->align = 4;
166     sect->reserved1 = 0;
167     sect->reserved2 = 0;
169     sect->size = ngots * sizeof(kxld_addr_t);
170     sect->data = kxld_alloc((u_long) sect->size);
171     require_action(sect->data, finish, rval=KERN_RESOURCE_SHORTAGE);
173     sect->allocated = TRUE;
186 kxld_sect_init_zerofill(KXLDSect *sect, const char *segname,
189     check(sect);
193     strlcpy(sect->segname, segname, sizeof(sect->segname));
194     strlcpy(sect->sectname, sectname, sizeof(sect->sectname));
195     sect->size = size;
196     sect->align = align;
197     sect->base_addr = 0;
198     sect->link_addr = 0;
199     sect->flags = S_ZEROFILL;
206 kxld_sect_clear(KXLDSect *sect)
208     check(sect);
210     if (sect->allocated) {
211         kxld_free(sect->data, (u_long) sect->size);
212         sect->allocated = FALSE;
215     bzero(sect->sectname, sizeof(sect->sectname));
216     bzero(sect->segname, sizeof(sect->segname));
217     sect->data = NULL;
218     sect->base_addr = 0;
219     sect->link_addr = 0;
220     sect->size = 0;
221     sect->flags = 0;
222     sect->align = 0;
223     sect->reserved1 = 0;
224     sect->reserved2 = 0;
225     kxld_array_clear(&sect->relocs);
231 kxld_sect_deinit(KXLDSect *sect)
233     check(sect);
235     if (streq_safe(sect->sectname, KXLD_SECT_GOT, sizeof(KXLD_SECT_GOT))) {
236         kxld_free(sect->data, (u_long) sect->size);
239     kxld_array_deinit(&sect->relocs);
240     bzero(sect, sizeof(*sect));
246 kxld_sect_get_num_relocs(const KXLDSect *sect)
248     check(sect);
250     return sect->relocs.nitems;
268 kxld_sect_get_macho_data_size(const KXLDSect *sect)
272     check(sect);
274     if (sect->data) {
275         size = (u_long) sect->size;
285 kxld_sect_get_ngots(const KXLDSect *sect, const KXLDRelocator *relocator,
293     for (i = 0; i < sect->relocs.nitems; ++i) {
294         reloc = kxld_array_get_item(&sect->relocs, i);
300             sym = kxld_reloc_get_symbol(relocator, reloc, sect->data, symtab);
319 kxld_sect_align_address(const KXLDSect *sect, kxld_addr_t address)
321     return kxld_align_address(address, sect->align);
327 kxld_sect_export_macho_to_file_buffer(const KXLDSect *sect, u_char *buf,
333     check(sect);
341     if (!sect->data) {
344             sect, buf, header_offset, header_size, /* data_offset */ 0);
347         *data_offset = (u_long) kxld_sect_align_address(sect, *data_offset);
351             sect, buf, header_offset, header_size, *data_offset);
354         rval = export_macho(sect, buf, *data_offset, data_size);
357         *data_offset += (u_long) sect->size;
369 kxld_sect_export_macho_to_vm(const KXLDSect *sect, u_char *buf,
375     u_long data_offset = (u_long) (sect->link_addr - link_addr);
377     check(sect);
383         sect, buf, header_offset, header_size, data_offset);
386     rval = export_macho(sect, buf, data_offset, data_size);
398 export_macho(const KXLDSect *sect, u_char *buf, u_long offset, u_long bufsize)
402     check(sect);
405     if (!sect->data) {
412     require_action(kxld_sect_align_address(sect, offset) == offset, finish,
417     require_action(sect->size <= bufsize - offset, finish,
422     switch (sect->flags & SECTION_TYPE) {
434         memcpy(buf + offset, sect->data, (size_t)sect->size);
436     case S_ZEROFILL: /* sect->data should be NULL, so we'll never get here */
444             "Invalid section type: %u.", sect->flags & SECTION_TYPE);
458 sect_export_macho_header_32(const KXLDSect *sect, u_char *buf,
464     check(sect);
475     strlcpy(secthdr->sectname, sect->sectname, sizeof(secthdr->sectname));
476     strlcpy(secthdr->segname, sect->segname, sizeof(secthdr->segname));
477     secthdr->addr = (uint32_t) sect->link_addr;
478     secthdr->size = (uint32_t) sect->size;
479     secthdr->offset = (uint32_t) ((sect->data) ? data_offset : 0);
480     secthdr->align = sect->align;
483     secthdr->flags = sect->flags;
484     secthdr->reserved1 = sect->reserved1;
485     secthdr->reserved2 = sect->reserved2;
498 sect_export_macho_header_64(const KXLDSect *sect, u_char *buf,
504     check(sect);
515     strlcpy(secthdr->sectname, sect->sectname, sizeof(secthdr->sectname));
516     strlcpy(secthdr->segname, sect->segname, sizeof(secthdr->segname));
517     secthdr->addr = (uint64_t) sect->link_addr;
518     secthdr->size = (uint64_t) sect->size;
519     secthdr->offset = (uint32_t) ((sect->data) ? data_offset : 0);
520     secthdr->align = sect->align;
523     secthdr->flags = sect->flags;
524     secthdr->reserved1 = sect->reserved1;
525     secthdr->reserved2 = sect->reserved2;
538 kxld_sect_grow(KXLDSect *sect, kxld_size_t nbytes, u_int align)
540     kxld_size_t size = kxld_align_address(sect->size, align);
542     if (align > sect->align) sect->align = align;
543     sect->size = size + nbytes;
552 kxld_sect_relocate(KXLDSect *sect, kxld_addr_t link_addr)
554     sect->link_addr = kxld_sect_align_address(sect,
555         sect->link_addr + link_addr);
562 kxld_sect_populate_got(KXLDSect *sect, KXLDSymtab *symtab,
571     check(sect);
573     require(streq_safe(sect->segname, KXLD_SEG_GOT, sizeof(KXLD_SEG_GOT)),
575     require(streq_safe(sect->sectname, KXLD_SECT_GOT, sizeof(KXLD_SECT_GOT)),
580     entry = (kxld_addr_t *) sect->data;
581     entry_addr = sect->link_addr;
604 kxld_sect_process_relocs(KXLDSect *sect, KXLDRelocator *relocator)
610     for (i = 0; i < sect->relocs.nitems; ++i) {
611         reloc = kxld_array_get_item(&sect->relocs, i);
612         rval = kxld_relocator_process_sect_reloc(relocator, reloc, sect);