int _dwarf_transform_arange_to_disk(Dwarf_P_Debug dbg, Dwarf_Error * error) { /* Total num of bytes in .debug_aranges section. */ Dwarf_Unsigned arange_num_bytes = 0; /* Adjustment to align the start of the actual address ranges on a boundary aligned with twice the address size. */ Dwarf_Small remainder = 0; /* Total number of bytes excluding the length field. */ Dwarf_Unsigned adjusted_length = 0; /* Points to first byte of .debug_aranges buffer. */ Dwarf_Small *arange = 0; /* Fills in the .debug_aranges buffer. */ Dwarf_Small *arange_ptr = 0; /* Scans the list of address ranges provided by user. */ Dwarf_P_Arange given_arange = 0; /* Used to fill in 0. */ const Dwarf_Signed big_zero = 0; int extension_word_size = dbg->de_64bit_extension ? 4 : 0; int uword_size = dbg->de_offset_size; int upointer_size = dbg->de_pointer_size; int res = 0; /* ***** BEGIN CODE ***** */ /* Size of the .debug_aranges section header. */ arange_num_bytes = extension_word_size + uword_size + /* Size of length field. */ sizeof(Dwarf_Half) + /* Size of version field. */ uword_size + /* Size of .debug_info offset. */ sizeof(Dwarf_Small) + /* Size of address size field. */ sizeof(Dwarf_Small); /* Size of segment size field. */ /* Adjust the size so that the set of aranges begins on a boundary that aligned with twice the address size. This is a Libdwarf requirement. */ remainder = arange_num_bytes % (2 * upointer_size); if (remainder != 0) arange_num_bytes += (2 * upointer_size) - remainder; /* Add the bytes for the actual address ranges. */ arange_num_bytes += upointer_size * 2 * (dbg->de_arange_count + 1); GET_CHUNK(dbg, dbg->de_elf_sects[DEBUG_ARANGES], arange, (unsigned long) arange_num_bytes, error); arange_ptr = arange; if (arange == NULL) { _dwarf_p_error(dbg, error, DW_DLE_ALLOC_FAIL); return (0); } if (extension_word_size) { Dwarf_Word x = DISTINGUISHED_VALUE; WRITE_UNALIGNED(dbg, (void *) arange_ptr, (const void *) &x, sizeof(x), extension_word_size); arange_ptr += extension_word_size; } /* Write the total length of .debug_aranges section. */ adjusted_length = arange_num_bytes - uword_size - extension_word_size; { Dwarf_Unsigned du = adjusted_length; WRITE_UNALIGNED(dbg, (void *) arange_ptr, (const void *) &du, sizeof(du), uword_size); arange_ptr += uword_size; } /* Write the version as 2 bytes. */ { Dwarf_Half verstamp = CURRENT_VERSION_STAMP; WRITE_UNALIGNED(dbg, (void *) arange_ptr, (const void *) &verstamp, sizeof(verstamp), sizeof(Dwarf_Half)); arange_ptr += sizeof(Dwarf_Half); } /* Write the .debug_info offset. This is always 0. */ WRITE_UNALIGNED(dbg, (void *) arange_ptr, (const void *) &big_zero, sizeof(big_zero), uword_size); arange_ptr += uword_size; { unsigned long count = dbg->de_arange_count + 1; int res = 0; if (dbg->de_reloc_pair) { count = (3 * dbg->de_arange_count) + 1; } /* The following is a small optimization: not needed for correctness */ res = _dwarf_pro_pre_alloc_n_reloc_slots(dbg, DEBUG_ARANGES, count); if (res != DW_DLV_OK) { _dwarf_p_error(dbg, error, DW_DLE_ALLOC_FAIL); return (0); } } /* reloc for .debug_info */ res = dbg->de_reloc_name(dbg, DEBUG_ARANGES, extension_word_size + uword_size + sizeof(Dwarf_Half), dbg->de_sect_name_idx[DEBUG_INFO], dwarf_drt_data_reloc, uword_size); /* Write the size of addresses. */ *arange_ptr = dbg->de_pointer_size; arange_ptr++; /* Write the size of segment addresses. This is zero for MIPS architectures. */ *arange_ptr = 0; arange_ptr++; /* Skip over the padding to align the start of the actual address ranges to twice the address size. */ if (remainder != 0) arange_ptr += (2 * upointer_size) - remainder; /* The arange address, length are pointer-size fields of the target machine. */ for (given_arange = dbg->de_arange; given_arange != NULL; given_arange = given_arange->ag_next) { /* Write relocation record for beginning of address range. */ res = dbg->de_reloc_name(dbg, DEBUG_ARANGES, arange_ptr - arange, /* r_offset */ (long) given_arange->ag_symbol_index, dwarf_drt_data_reloc, upointer_size); if (res != DW_DLV_OK) { _dwarf_p_error(dbg, error, DW_DLE_ALLOC_FAIL); return (0); } /* Copy beginning address of range. */ WRITE_UNALIGNED(dbg, (void *) arange_ptr, (const void *) &given_arange->ag_begin_address, sizeof(given_arange->ag_begin_address), upointer_size); arange_ptr += upointer_size; if (dbg->de_reloc_pair && given_arange->ag_end_symbol_index != 0 && given_arange->ag_length == 0) { /* symbolic reloc, need reloc for length What if we really know the length? If so, should use the other part of 'if'. */ Dwarf_Unsigned val; res = dbg->de_reloc_pair(dbg, DEBUG_ARANGES, arange_ptr - arange, /* r_offset */ given_arange->ag_symbol_index, given_arange->ag_end_symbol_index, dwarf_drt_first_of_length_pair, upointer_size); if (res != DW_DLV_OK) { _dwarf_p_error(dbg, error, DW_DLE_ALLOC_FAIL); return (0); } /* arange pre-calc so assem text can do .word end - begin + val (gets val from stream) */ val = given_arange->ag_end_symbol_offset - given_arange->ag_begin_address; WRITE_UNALIGNED(dbg, (void *) arange_ptr, (const void *) &val, sizeof(val), upointer_size); arange_ptr += upointer_size; } else { /* plain old length to copy, no relocation at all */ WRITE_UNALIGNED(dbg, (void *) arange_ptr, (const void *) &given_arange->ag_length, sizeof(given_arange->ag_length), upointer_size); arange_ptr += upointer_size; } } WRITE_UNALIGNED(dbg, (void *) arange_ptr, (const void *) &big_zero, sizeof(big_zero), upointer_size); arange_ptr += upointer_size; WRITE_UNALIGNED(dbg, (void *) arange_ptr, (const void *) &big_zero, sizeof(big_zero), upointer_size); return (int) dbg->de_n_debug_sect; }
/* _dwarf_transform_simplename_to_disk writes ".rel.debug_pubnames", ".rel.debug_funcnames", sgi extension ".rel.debug_typenames", sgi extension ".rel.debug_varnames", sgi extension ".rel.debug_weaknames", sgi extension to disk. section_index indexes one of those sections. entrykind is one of those 'kind's. */ int _dwarf_transform_simplename_to_disk(Dwarf_P_Debug dbg, enum dwarf_sn_kind entrykind, int section_index, /* in de_elf_sects etc */ Dwarf_Error * error) { /* Used to fill in 0. */ const Dwarf_Signed big_zero = 0; /* Used to scan the section data buffers. */ Dwarf_P_Section_Data debug_sect; Dwarf_Signed debug_info_size; Dwarf_P_Simple_nameentry nameentry_original; Dwarf_P_Simple_nameentry nameentry; Dwarf_Small *stream_bytes; Dwarf_Small *cur_stream_bytes_ptr; Dwarf_Unsigned stream_bytes_count; Dwarf_Unsigned adjusted_length; /* count excluding length field */ int uword_size = dbg->de_offset_size; int extension_size = dbg->de_64bit_extension ? 4 : 0; Dwarf_P_Simple_name_header hdr; /* ***** BEGIN CODE ***** */ debug_info_size = 0; for (debug_sect = dbg->de_debug_sects; debug_sect != NULL; debug_sect = debug_sect->ds_next) { /* We want the size of the .debug_info section for this CU because the dwarf spec requires us to output it below so we look for it specifically. */ if (debug_sect->ds_elf_sect_no == dbg->de_elf_sects[DEBUG_INFO]) { debug_info_size += debug_sect->ds_nbytes; } } hdr = &dbg->de_simple_name_headers[entrykind]; /* Size of the .debug_typenames (or similar) section header. */ stream_bytes_count = extension_size + uword_size + /* Size of length field. */ sizeof(Dwarf_Half) + /* Size of version field. */ uword_size + /* Size of .debug_info offset. */ uword_size; /* Size of .debug_names. */ nameentry_original = hdr->sn_head; nameentry = nameentry_original; /* add in the content size */ stream_bytes_count += hdr->sn_net_len; /* Size of the last 0 offset. */ stream_bytes_count += uword_size; /* Now we know how long the entire section is */ GET_CHUNK(dbg, dbg->de_elf_sects[section_index], stream_bytes, (unsigned long) stream_bytes_count, error); if (stream_bytes == NULL) { _dwarf_p_error(dbg, error, DW_DLE_ALLOC_FAIL); return (0); } cur_stream_bytes_ptr = stream_bytes; if (extension_size) { Dwarf_Unsigned x = DISTINGUISHED_VALUE; WRITE_UNALIGNED(dbg, cur_stream_bytes_ptr, (const void *) &x, sizeof(x), extension_size); cur_stream_bytes_ptr += extension_size; } /* Write the adjusted length of .debug_*names section. */ adjusted_length = stream_bytes_count - uword_size - extension_size; WRITE_UNALIGNED(dbg, cur_stream_bytes_ptr, (const void *) &adjusted_length, sizeof(adjusted_length), uword_size); cur_stream_bytes_ptr += uword_size; /* Write the version as 2 bytes. */ { Dwarf_Half verstamp = CURRENT_VERSION_STAMP; WRITE_UNALIGNED(dbg, cur_stream_bytes_ptr, (const void *) &verstamp, sizeof(verstamp), sizeof(Dwarf_Half)); cur_stream_bytes_ptr += sizeof(Dwarf_Half); } /* Write the offset of the compile-unit. */ WRITE_UNALIGNED(dbg, cur_stream_bytes_ptr, (const void *) &big_zero, sizeof(big_zero), uword_size); cur_stream_bytes_ptr += uword_size; /* now create the relocation for the compile_unit offset */ { int res = dbg->de_reloc_name(dbg, section_index, extension_size + uword_size + sizeof(Dwarf_Half) /* r_offset */ , /* debug_info section name symbol */ dbg->de_sect_name_idx[DEBUG_INFO], dwarf_drt_data_reloc, uword_size); if (res != DW_DLV_OK) { { _dwarf_p_error(dbg, error, DW_DLE_ALLOC_FAIL); return (0); } } } /* Write the size of .debug_info section. */ WRITE_UNALIGNED(dbg, cur_stream_bytes_ptr, (const void *) &debug_info_size, sizeof(debug_info_size), uword_size); cur_stream_bytes_ptr += uword_size; for (nameentry = nameentry_original; nameentry != NULL; nameentry = nameentry->sne_next) { /* Copy offset of die from start of compile-unit. */ WRITE_UNALIGNED(dbg, cur_stream_bytes_ptr, (const void *) &nameentry->sne_die->di_offset, sizeof(nameentry->sne_die->di_offset), uword_size); cur_stream_bytes_ptr += uword_size; /* Copy the type name. */ strcpy((char *) cur_stream_bytes_ptr, nameentry->sne_name); cur_stream_bytes_ptr += nameentry->sne_name_len + 1; } WRITE_UNALIGNED(dbg, cur_stream_bytes_ptr, (const void *) &big_zero, sizeof(big_zero), uword_size); return (int) dbg->de_n_debug_sect; }