http://sourceware.org/ml/gdb-cvs/2010-07/msg00139.html ### src/gdb/ChangeLog 2010/07/23 21:10:54 1.12013 ### src/gdb/ChangeLog 2010/07/23 22:15:13 1.12014 ## -1,3 +1,31 @@ +2010-07-23 Tom Tromey + + * dwarf2read.c (struct dwarf2_per_objfile) : New fields. + (dw2_get_cu): New function. + (create_cus_from_index): Remove unused argument. + (create_signatured_type_hash_from_index): New function. + (create_addrmap_from_index): Update. + (dwarf2_read_index): Handle version 2. + (dw2_find_last_source_symtab, dw2_forget_cached_source_info) + (dw2_lookup_symtab, dw2_do_expand_symtabs_matching) + (dw2_print_stats, dw2_expand_all_symtabs) + (dw2_expand_symtabs_with_filename, dw2_find_symbol_file) + (dw2_expand_symtabs_matching, dw2_map_symbol_filenames): Update. + (dwarf2_initialize_objfile): Call create_debug_types_hash_table. + (allocate_signatured_type_hash_table): New function. + (add_signatured_type_cu_to_list): Likewise. + (create_debug_types_hash_table): Use them. Set type_comp_units. + (read_signatured_type): Ensure section data is available. + (add_address_entry): Don't record empty ranges. + (struct signatured_type_index_data): New. + (write_one_signatured_type): New function. + (write_psymtabs_to_index): Write type CUs. + (save_gdb_index_command): Update comment. + (process_type_comp_unit): Move inititalization of + from_debug_types... + (create_debug_types_hash_table): ... here. + 2010-07-23 Jan Kratochvil * gdb_gcore.sh (tmpfile): Remove the variable, its initialization, Index: gdb-7.2/gdb/dwarf2read.c =================================================================== --- gdb-7.2.orig/gdb/dwarf2read.c 2010-10-12 18:10:47.000000000 +0200 +++ gdb-7.2/gdb/dwarf2read.c 2010-10-12 18:11:16.000000000 +0200 @@ -184,6 +184,12 @@ struct dwarf2_per_objfile /* The number of compilation units in ALL_COMP_UNITS. */ int n_comp_units; + /* The number of .debug_types-related CUs. */ + int n_type_comp_units; + + /* The .debug_types-related CUs. */ + struct dwarf2_per_cu_data **type_comp_units; + /* A chain of compilation units that are currently read in, so that they can be freed later. */ struct dwarf2_per_cu_data *read_in_chain; @@ -1226,6 +1232,8 @@ static struct type *set_die_type (struct static void create_all_comp_units (struct objfile *); +static int create_debug_types_hash_table (struct objfile *objfile); + static void load_full_comp_unit (struct dwarf2_per_cu_data *, struct objfile *); @@ -1269,6 +1277,8 @@ static void init_cu_die_reader (struct d static const char *dwarf2_physname (char *name, struct die_info *die, struct dwarf2_cu *cu); +static htab_t allocate_signatured_type_hash_table (struct objfile *objfile); + #if WORDS_BIGENDIAN /* Convert VALUE between big- and little-endian. */ @@ -1646,6 +1656,18 @@ dw2_instantiate_symtab (struct objfile * return per_cu->v.quick->symtab; } +/* Return the CU given its index. */ +static struct dwarf2_per_cu_data * +dw2_get_cu (int index) +{ + if (index >= dwarf2_per_objfile->n_comp_units) + { + index -= dwarf2_per_objfile->n_comp_units; + return dwarf2_per_objfile->type_comp_units[index]; + } + return dwarf2_per_objfile->all_comp_units[index]; +} + /* A helper function that knows how to read a 64-bit value in a way that doesn't make gdb die. Returns 1 if the conversion went ok, 0 otherwise. */ @@ -1672,11 +1694,10 @@ extract_cu_value (const char *bytes, ULO the CU objects for this objfile. Return 0 if something went wrong, 1 if everything went ok. */ static int -create_cus_from_index (struct objfile *objfile, struct mapped_index *index, - const gdb_byte *cu_list, offset_type cu_list_elements) +create_cus_from_index (struct objfile *objfile, const gdb_byte *cu_list, + offset_type cu_list_elements) { offset_type i; - const char *entry; dwarf2_per_objfile->n_comp_units = cu_list_elements / 2; dwarf2_per_objfile->all_comp_units @@ -1707,6 +1728,58 @@ create_cus_from_index (struct objfile *o return 1; } +/* Create the signatured type hash table from the index. */ +static int +create_signatured_type_hash_from_index (struct objfile *objfile, + const gdb_byte *bytes, + offset_type elements) +{ + offset_type i; + htab_t type_hash; + + dwarf2_per_objfile->n_type_comp_units = elements / 3; + dwarf2_per_objfile->type_comp_units + = obstack_alloc (&objfile->objfile_obstack, + dwarf2_per_objfile->n_type_comp_units + * sizeof (struct dwarf2_per_cu_data *)); + + type_hash = allocate_signatured_type_hash_table (objfile); + + for (i = 0; i < elements; i += 3) + { + struct signatured_type *type_sig; + ULONGEST offset, type_offset, signature; + void **slot; + + if (!extract_cu_value (bytes, &offset) + || !extract_cu_value (bytes + 8, &type_offset)) + return 0; + signature = extract_unsigned_integer (bytes + 16, 8, BFD_ENDIAN_LITTLE); + bytes += 3 * 8; + + type_sig = OBSTACK_ZALLOC (&objfile->objfile_obstack, + struct signatured_type); + type_sig->signature = signature; + type_sig->offset = offset; + type_sig->type_offset = type_offset; + type_sig->per_cu.from_debug_types = 1; + type_sig->per_cu.offset = offset; + type_sig->per_cu.objfile = objfile; + type_sig->per_cu.v.quick + = OBSTACK_ZALLOC (&objfile->objfile_obstack, + struct dwarf2_per_cu_quick_data); + + slot = htab_find_slot (type_hash, type_sig, INSERT); + *slot = type_sig; + + dwarf2_per_objfile->type_comp_units[i / 3] = &type_sig->per_cu; + } + + dwarf2_per_objfile->signatured_types = type_hash; + + return 1; +} + /* Read the address map data from the mapped index, and use it to populate the objfile's psymtabs_addrmap. */ static void @@ -1738,7 +1811,7 @@ create_addrmap_from_index (struct objfil iter += 4; addrmap_set_empty (mutable_map, lo + baseaddr, hi + baseaddr - 1, - dwarf2_per_objfile->all_comp_units[cu_index]); + dw2_get_cu (cu_index)); } objfile->psymtabs_addrmap = addrmap_create_fixed (mutable_map, @@ -1805,8 +1878,9 @@ dwarf2_read_index (struct objfile *objfi char *addr; struct mapped_index *map; offset_type *metadata; - const gdb_byte *cu_list; - offset_type cu_list_elements; + const gdb_byte *cu_list, *types_list; + offset_type version, cu_list_elements, types_list_elements; + int i; if (dwarf2_per_objfile->gdb_index.asection == NULL || dwarf2_per_objfile->gdb_index.size == 0) @@ -1822,26 +1896,58 @@ dwarf2_read_index (struct objfile *objfi addr = dwarf2_per_objfile->gdb_index.buffer; /* Version check. */ - if (MAYBE_SWAP (*(offset_type *) addr) != 1) + version = MAYBE_SWAP (*(offset_type *) addr); + if (version == 1) + { + /* Index version 1 neglected to account for .debug_types. So, + if we see .debug_types, we cannot use this index. */ + if (dwarf2_per_objfile->types.asection != NULL + && dwarf2_per_objfile->types.size != 0) + return 0; + } + else if (version != 2) return 0; map = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct mapped_index); map->total_size = dwarf2_per_objfile->gdb_index.size; metadata = (offset_type *) (addr + sizeof (offset_type)); - cu_list = addr + MAYBE_SWAP (metadata[0]); - cu_list_elements = ((MAYBE_SWAP (metadata[1]) - MAYBE_SWAP (metadata[0])) + + i = 0; + cu_list = addr + MAYBE_SWAP (metadata[i]); + cu_list_elements = ((MAYBE_SWAP (metadata[i + 1]) - MAYBE_SWAP (metadata[i])) / 8); - map->address_table = addr + MAYBE_SWAP (metadata[1]); - map->address_table_size = (MAYBE_SWAP (metadata[2]) - - MAYBE_SWAP (metadata[1])); - map->index_table = (offset_type *) (addr + MAYBE_SWAP (metadata[2])); - map->index_table_slots = ((MAYBE_SWAP (metadata[3]) - - MAYBE_SWAP (metadata[2])) + ++i; + + if (version == 2) + { + types_list = addr + MAYBE_SWAP (metadata[i]); + types_list_elements = ((MAYBE_SWAP (metadata[i + 1]) + - MAYBE_SWAP (metadata[i])) + / 8); + ++i; + } + + map->address_table = addr + MAYBE_SWAP (metadata[i]); + map->address_table_size = (MAYBE_SWAP (metadata[i + 1]) + - MAYBE_SWAP (metadata[i])); + ++i; + + map->index_table = (offset_type *) (addr + MAYBE_SWAP (metadata[i])); + map->index_table_slots = ((MAYBE_SWAP (metadata[i + 1]) + - MAYBE_SWAP (metadata[i])) / (2 * sizeof (offset_type))); - map->constant_pool = addr + MAYBE_SWAP (metadata[3]); + ++i; - if (!create_cus_from_index (objfile, map, cu_list, cu_list_elements)) + map->constant_pool = addr + MAYBE_SWAP (metadata[i]); + + if (!create_cus_from_index (objfile, cu_list, cu_list_elements)) + return 0; + + if (version == 2 + && types_list_elements + && !create_signatured_type_hash_from_index (objfile, types_list, + types_list_elements)) return 0; create_addrmap_from_index (objfile, map); @@ -1968,8 +2074,7 @@ dw2_find_last_source_symtab (struct objf int index; dw2_setup (objfile); index = dwarf2_per_objfile->n_comp_units - 1; - return dw2_instantiate_symtab (objfile, - dwarf2_per_objfile->all_comp_units[index]); + return dw2_instantiate_symtab (objfile, dw2_get_cu (index)); } static void @@ -1978,9 +2083,10 @@ dw2_forget_cached_source_info (struct ob int i; dw2_setup (objfile); - for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i) + for (i = 0; i < (dwarf2_per_objfile->n_comp_units + + dwarf2_per_objfile->n_type_comp_units); ++i) { - struct dwarf2_per_cu_data *cu = dwarf2_per_objfile->all_comp_units[i]; + struct dwarf2_per_cu_data *cu = dw2_get_cu (i); if (cu->v.quick->full_names) { @@ -2002,10 +2108,11 @@ dw2_lookup_symtab (struct objfile *objfi struct dwarf2_per_cu_data *base_cu = NULL; dw2_setup (objfile); - for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i) + for (i = 0; i < (dwarf2_per_objfile->n_comp_units + + dwarf2_per_objfile->n_type_comp_units); ++i) { int j; - struct dwarf2_per_cu_data *cu = dwarf2_per_objfile->all_comp_units[i]; + struct dwarf2_per_cu_data *cu = dw2_get_cu (i); if (cu->v.quick->symtab) continue; @@ -2097,8 +2204,8 @@ dw2_do_expand_symtabs_matching (struct o for (i = 0; i < len; ++i) { offset_type cu_index = MAYBE_SWAP (vec[i + 1]); - struct dwarf2_per_cu_data *cu; - cu = dwarf2_per_objfile->all_comp_units[cu_index]; + struct dwarf2_per_cu_data *cu = dw2_get_cu (cu_index); + dw2_instantiate_symtab (objfile, cu); } } @@ -2120,9 +2227,10 @@ dw2_print_stats (struct objfile *objfile dw2_setup (objfile); count = 0; - for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i) + for (i = 0; i < (dwarf2_per_objfile->n_comp_units + + dwarf2_per_objfile->n_type_comp_units); ++i) { - struct dwarf2_per_cu_data *cu = dwarf2_per_objfile->all_comp_units[i]; + struct dwarf2_per_cu_data *cu = dw2_get_cu (i); if (!cu->v.quick->symtab) ++count; @@ -2156,9 +2264,11 @@ dw2_expand_all_symtabs (struct objfile * int i; dw2_setup (objfile); - for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i) + + for (i = 0; i < (dwarf2_per_objfile->n_comp_units + + dwarf2_per_objfile->n_type_comp_units); ++i) { - struct dwarf2_per_cu_data *cu = dwarf2_per_objfile->all_comp_units[i]; + struct dwarf2_per_cu_data *cu = dw2_get_cu (i); dw2_instantiate_symtab (objfile, cu); } @@ -2171,10 +2281,11 @@ dw2_expand_symtabs_with_filename (struct int i; dw2_setup (objfile); - for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i) + for (i = 0; i < (dwarf2_per_objfile->n_comp_units + + dwarf2_per_objfile->n_type_comp_units); ++i) { int j; - struct dwarf2_per_cu_data *cu = dwarf2_per_objfile->all_comp_units[i]; + struct dwarf2_per_cu_data *cu = dw2_get_cu (i); if (cu->v.quick->symtab) continue; @@ -2215,7 +2326,7 @@ dw2_find_symbol_file (struct objfile *ob should be rewritten so that it doesn't require a custom hook. It could just use the ordinary symbol tables. */ /* vec[0] is the length, which must always be >0. */ - cu = dwarf2_per_objfile->all_comp_units[MAYBE_SWAP (vec[1])]; + cu = dw2_get_cu (MAYBE_SWAP (vec[1])); dw2_require_line_header (objfile, cu); if (!cu->v.quick->lines) @@ -2253,10 +2364,11 @@ dw2_expand_symtabs_matching (struct objf if (!dwarf2_per_objfile->index_table) return; - for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i) + for (i = 0; i < (dwarf2_per_objfile->n_comp_units + + dwarf2_per_objfile->n_type_comp_units); ++i) { int j; - struct dwarf2_per_cu_data *cu = dwarf2_per_objfile->all_comp_units[i]; + struct dwarf2_per_cu_data *cu = dw2_get_cu (i); cu->v.quick->mark = 0; if (cu->v.quick->symtab) @@ -2301,8 +2413,9 @@ dw2_expand_symtabs_matching (struct objf vec_len = MAYBE_SWAP (vec[0]); for (vec_idx = 0; vec_idx < vec_len; ++vec_idx) { - struct dwarf2_per_cu_data *cu - = dwarf2_per_objfile->all_comp_units[MAYBE_SWAP (vec[vec_idx + 1])]; + struct dwarf2_per_cu_data *cu; + + cu = dw2_get_cu (MAYBE_SWAP (vec[vec_idx + 1])); if (cu->v.quick->mark) dw2_instantiate_symtab (objfile, cu); } @@ -2372,10 +2485,11 @@ dw2_map_symbol_filenames (struct objfile int i; dw2_setup (objfile); - for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i) + for (i = 0; i < (dwarf2_per_objfile->n_comp_units + + dwarf2_per_objfile->n_type_comp_units); ++i) { int j; - struct dwarf2_per_cu_data *cu = dwarf2_per_objfile->all_comp_units[i]; + struct dwarf2_per_cu_data *cu = dw2_get_cu (i); if (cu->v.quick->symtab) continue; @@ -2436,10 +2550,12 @@ dwarf2_initialize_objfile (struct objfil dwarf2_per_objfile->using_index = 1; create_all_comp_units (objfile); + create_debug_types_hash_table (objfile); - for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i) + for (i = 0; i < (dwarf2_per_objfile->n_comp_units + + dwarf2_per_objfile->n_type_comp_units); ++i) { - struct dwarf2_per_cu_data *cu = dwarf2_per_objfile->all_comp_units[i]; + struct dwarf2_per_cu_data *cu = dw2_get_cu (i); cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwarf2_per_cu_quick_data); @@ -2653,6 +2769,34 @@ eq_type_signature (const void *item_lhs, return lhs->signature == rhs->signature; } +/* Allocate a hash table for signatured types. */ + +static htab_t +allocate_signatured_type_hash_table (struct objfile *objfile) +{ + return htab_create_alloc_ex (41, + hash_type_signature, + eq_type_signature, + NULL, + &objfile->objfile_obstack, + hashtab_obstack_allocate, + dummy_obstack_deallocate); +} + +/* A helper function to add a signatured type CU to a list. */ + +static int +add_signatured_type_cu_to_list (void **slot, void *datum) +{ + struct signatured_type *sigt = *slot; + struct dwarf2_per_cu_data ***datap = datum; + + **datap = &sigt->per_cu; + ++*datap; + + return 1; +} + /* Create the hash table of all entries in the .debug_types section. The result is zero if there is an error (e.g. missing .debug_types section), otherwise non-zero. */ @@ -2662,6 +2806,7 @@ create_debug_types_hash_table (struct ob { gdb_byte *info_ptr; htab_t types_htab; + struct dwarf2_per_cu_data **iter; dwarf2_read_section (objfile, &dwarf2_per_objfile->types); info_ptr = dwarf2_per_objfile->types.buffer; @@ -2672,13 +2817,7 @@ create_debug_types_hash_table (struct ob return 0; } - types_htab = htab_create_alloc_ex (41, - hash_type_signature, - eq_type_signature, - NULL, - &objfile->objfile_obstack, - hashtab_obstack_allocate, - dummy_obstack_deallocate); + types_htab = allocate_signatured_type_hash_table (objfile); if (dwarf2_die_debug) fprintf_unfiltered (gdb_stdlog, "Signatured types:\n"); @@ -2726,6 +2865,7 @@ create_debug_types_hash_table (struct ob type_sig->offset = offset; type_sig->type_offset = type_offset; type_sig->per_cu.objfile = objfile; + type_sig->per_cu.from_debug_types = 1; slot = htab_find_slot (types_htab, type_sig, INSERT); gdb_assert (slot != NULL); @@ -2740,6 +2880,16 @@ create_debug_types_hash_table (struct ob dwarf2_per_objfile->signatured_types = types_htab; + dwarf2_per_objfile->n_type_comp_units = htab_elements (types_htab); + dwarf2_per_objfile->type_comp_units + = obstack_alloc (&objfile->objfile_obstack, + dwarf2_per_objfile->n_type_comp_units + * sizeof (struct dwarf2_per_cu_data *)); + iter = &dwarf2_per_objfile->type_comp_units[0]; + htab_traverse_noresize (types_htab, add_signatured_type_cu_to_list, &iter); + gdb_assert (iter - &dwarf2_per_objfile->type_comp_units[0] + == dwarf2_per_objfile->n_type_comp_units); + return 1; } @@ -3008,7 +3158,6 @@ process_type_comp_unit (void **slot, voi struct dwarf2_per_cu_data *this_cu; this_cu = &entry->per_cu; - this_cu->from_debug_types = 1; gdb_assert (dwarf2_per_objfile->types.readin); process_psymtab_comp_unit (objfile, this_cu, @@ -12483,13 +12632,16 @@ static void read_signatured_type (struct objfile *objfile, struct signatured_type *type_sig) { - gdb_byte *types_ptr = dwarf2_per_objfile->types.buffer + type_sig->offset; + gdb_byte *types_ptr; struct die_reader_specs reader_specs; struct dwarf2_cu *cu; ULONGEST signature; struct cleanup *back_to, *free_cu_cleanup; struct attribute *attr; + dwarf2_read_section (objfile, &dwarf2_per_objfile->types); + types_ptr = dwarf2_per_objfile->types.buffer + type_sig->offset; + gdb_assert (type_sig->per_cu.cu == NULL); cu = xmalloc (sizeof (struct dwarf2_cu)); @@ -14402,6 +14554,10 @@ add_address_entry (struct objfile *objfi char addr[8]; CORE_ADDR baseaddr; + /* Don't bother recording empty ranges. */ + if (pst->textlow == pst->texthigh) + return; + baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); store_unsigned_integer (addr, 8, BFD_ENDIAN_LITTLE, pst->textlow - baseaddr); @@ -14447,13 +14603,53 @@ unlink_if_set (void *p) unlink (*filename); } +/* A helper struct used when iterating over debug_types. */ +struct signatured_type_index_data +{ + struct objfile *objfile; + struct mapped_symtab *symtab; + struct obstack *types_list; + int cu_index; +}; + +/* A helper function that writes a single signatured_type to an + obstack. */ +static int +write_one_signatured_type (void **slot, void *d) +{ + struct signatured_type_index_data *info = d; + struct signatured_type *entry = (struct signatured_type *) *slot; + struct dwarf2_per_cu_data *cu = &entry->per_cu; + struct partial_symtab *psymtab = cu->v.psymtab; + gdb_byte val[8]; + + write_psymbols (info->symtab, + info->objfile->global_psymbols.list + psymtab->globals_offset, + psymtab->n_global_syms, info->cu_index); + write_psymbols (info->symtab, + info->objfile->static_psymbols.list + psymtab->statics_offset, + psymtab->n_static_syms, info->cu_index); + + store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE, entry->offset); + obstack_grow (info->types_list, val, 8); + store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE, entry->type_offset); + obstack_grow (info->types_list, val, 8); + store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE, entry->signature); + obstack_grow (info->types_list, val, 8); + + ++info->cu_index; + + return 1; +} + /* Create an index file for OBJFILE in the directory DIR. */ static void write_psymtabs_to_index (struct objfile *objfile, const char *dir) { struct cleanup *cleanup; char *filename, *cleanup_filename; - struct obstack contents, addr_obstack, constant_pool, symtab_obstack, cu_list; + struct obstack contents, addr_obstack, constant_pool, symtab_obstack; + struct obstack cu_list, types_cu_list; int i; FILE *out_file; struct mapped_symtab *symtab; @@ -14489,6 +14685,12 @@ write_psymtabs_to_index (struct objfile obstack_init (&cu_list); make_cleanup_obstack_free (&cu_list); + obstack_init (&types_cu_list); + make_cleanup_obstack_free (&types_cu_list); + + /* The list is already sorted, so we don't need to do additional + work here. Also, the debug_types entries do not appear in + all_comp_units, but only in their own hash table. */ for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i) { struct dwarf2_per_cu_data *cu = dwarf2_per_objfile->all_comp_units[i]; @@ -14510,6 +14712,19 @@ write_psymtabs_to_index (struct objfile obstack_grow (&cu_list, val, 8); } + /* Write out the .debug_type entries, if any. */ + if (dwarf2_per_objfile->signatured_types) + { + struct signatured_type_index_data sig_data; + + sig_data.objfile = objfile; + sig_data.symtab = symtab; + sig_data.types_list = &types_cu_list; + sig_data.cu_index = dwarf2_per_objfile->n_comp_units; + htab_traverse_noresize (dwarf2_per_objfile->signatured_types, + write_one_signatured_type, &sig_data); + } + obstack_init (&constant_pool); make_cleanup_obstack_free (&constant_pool); obstack_init (&symtab_obstack); @@ -14518,11 +14733,11 @@ write_psymtabs_to_index (struct objfile obstack_init (&contents); make_cleanup_obstack_free (&contents); - size_of_contents = 5 * sizeof (offset_type); + size_of_contents = 6 * sizeof (offset_type); total_len = size_of_contents; /* The version number. */ - val = MAYBE_SWAP (1); + val = MAYBE_SWAP (2); obstack_grow (&contents, &val, sizeof (val)); /* The offset of the CU list from the start of the file. */ @@ -14530,6 +14745,11 @@ write_psymtabs_to_index (struct objfile obstack_grow (&contents, &val, sizeof (val)); total_len += obstack_object_size (&cu_list); + /* The offset of the types CU list from the start of the file. */ + val = MAYBE_SWAP (total_len); + obstack_grow (&contents, &val, sizeof (val)); + total_len += obstack_object_size (&types_cu_list); + /* The offset of the address table from the start of the file. */ val = MAYBE_SWAP (total_len); obstack_grow (&contents, &val, sizeof (val)); @@ -14549,6 +14769,7 @@ write_psymtabs_to_index (struct objfile write_obstack (out_file, &contents); write_obstack (out_file, &cu_list); + write_obstack (out_file, &types_cu_list); write_obstack (out_file, &addr_obstack); write_obstack (out_file, &symtab_obstack); write_obstack (out_file, &constant_pool); @@ -14573,18 +14794,33 @@ write_psymtabs_to_index (struct objfile 1. The file header. This is a sequence of values, of offset_type unless otherwise noted: - [0] The version number. Currently 1. + [0] The version number. Currently 1 or 2. The differences are + noted below. Version 1 did not account for .debug_types sections; + the presence of a .debug_types section invalidates any version 1 + index that may exist. [1] The offset, from the start of the file, of the CU list. + [1.5] In version 2, the offset, from the start of the file, of the + types CU list. This offset does not appear in version 1. Note + that this can be empty, in which case this offset will be equal to + the next offset. [2] The offset, from the start of the file, of the address section. [3] The offset, from the start of the file, of the symbol table. [4] The offset, from the start of the file, of the constant pool. 2. The CU list. This is a sequence of pairs of 64-bit - little-endian values. The first element in each pair is the offset - of a CU in the .debug_info section. The second element in each - pair is the length of that CU. References to a CU elsewhere in the - map are done using a CU index, which is just the 0-based index into - this table. + little-endian values, sorted by the CU offset. The first element + in each pair is the offset of a CU in the .debug_info section. The + second element in each pair is the length of that CU. References + to a CU elsewhere in the map are done using a CU index, which is + just the 0-based index into this table. Note that if there are + type CUs, then conceptually CUs and type CUs form a single list for + the purposes of CU indices. + + 2.5 The types CU list. This does not appear in a version 1 index. + This is a sequence of triplets of 64-bit little-endian values. In + a triplet, the first value is the CU offset, the second value is + the type offset in the CU, and the third value is the type + signature. The types CU list is not sorted. 3. The address section. The address section consists of a sequence of address entries. Each address entry has three elements.