The modules implementation is necessarily sensitive to the internal workings of class line_map, and so it needed changes in order to handle a 64-bit location_t. The changes mostly boil down to supporting that in the debug dumping routines (which is accomplished by using a new custom code %K for that purpose), and supporting that when streaming in and out from the module (which is accomplished by using a new loc() function to go along with existing abstractions like u() or z() for streaming in and out different data types).
gcc/cp/ChangeLog: * module.cc (bytes_out::loc): New function. (bytes_in::loc): New function. (struct span): Change int fields to location_diff_t. (range_t): Change from "unsigned int" to "line_map_uint_t". (struct ord_loc_info): Likewise. (struct macro_loc_info): Likewise. (class module_state): Likewise. (dumper::operator()): Add new code 'K' for dumping a location_t. (loc_spans::init): Use %K instead of %u for location_t dumps. (loc_spans::open): Likewise. (loc_spans::close): Likewise. Adjust bitwise expressions to support 64-bit location_t as well. (struct module_state_config): Change ordinary_locs and macro_locs from "unsigned int" to "line_map_uint_t". Reorder fields to improve packing. Rather than changing the constructor initializer list to match the new order, switch to NSDMI instead. (module_state::note_location): Adjust to support 64-bit location_t. (module_state::write_location): Use %K instead of %u for location_t dumps. Use loc() instead of u() for streaming location_t. (module_state::read_location): Likewise. (module_state::write_ordinary_maps): Likewise. (module_state::write_macro_maps): Likewise. (module_state::write_config): Likewise. (module_state::read_config): Likewise. (module_state::write_prepare_maps): Use %K instead of %u for location_t dumps. Adjust variable types and bitwise expressions to support 64-bit location_t. (module_state::read_ordinary_maps): Likewise. (module_state::read_macro_maps): Likewise. (preprocess_module): Adjust data types to support 64-bit number of line maps. --- gcc/cp/module.cc | 229 +++++++++++++++++++++++++++-------------------- 1 file changed, 130 insertions(+), 99 deletions(-) diff --git a/gcc/cp/module.cc b/gcc/cp/module.cc index dde7e5f6dbf..415bdd41ea3 100644 --- a/gcc/cp/module.cc +++ b/gcc/cp/module.cc @@ -350,6 +350,9 @@ typedef hash_map<void *,signed,ptr_int_traits> ptr_int_hash_map; /* Variable length buffer. */ namespace { + +constexpr line_map_uint_t loc_one = 1; + class data { public: class allocator { @@ -549,6 +552,7 @@ public: int i (); /* Read a signed int. */ unsigned u (); /* Read an unsigned int. */ size_t z (); /* Read a size_t. */ + location_t loc (); /* Read a location_t. */ HOST_WIDE_INT wi (); /* Read a HOST_WIDE_INT. */ unsigned HOST_WIDE_INT wu (); /* Read an unsigned HOST_WIDE_INT. */ const char *str (size_t * = NULL); /* Read a string. */ @@ -633,6 +637,7 @@ public: void i (int); /* Write signed int. */ void u (unsigned); /* Write unsigned int. */ void z (size_t s); /* Write size_t. */ + void loc (location_t); /* Write location_t. */ void wi (HOST_WIDE_INT); /* Write HOST_WIDE_INT. */ void wu (unsigned HOST_WIDE_INT); /* Write unsigned HOST_WIDE_INT. */ void str (const char *ptr) @@ -1057,6 +1062,26 @@ bytes_in::z () return wu (); } +/* location_t written as 32- or 64-bit as needed. */ + +inline void bytes_out::loc (location_t l) +{ +#ifdef ENABLE_LARGE_SOURCE_LOCATIONS + wu (l); +#else + u (l); +#endif +} + +inline location_t bytes_in::loc () +{ +#ifdef ENABLE_LARGE_SOURCE_LOCATIONS + return wu (); +#else + return u (); +#endif +} + /* Buffer simply memcpied. */ void * bytes_out::buf (size_t len) @@ -3210,7 +3235,7 @@ trees_out::~trees_out () /* I use half-open [first,second) ranges. */ -typedef std::pair<unsigned,unsigned> range_t; +typedef std::pair<line_map_uint_t,line_map_uint_t> range_t; /* A range of locations. */ typedef std::pair<location_t,location_t> loc_range_t; @@ -3227,8 +3252,9 @@ public: struct span { loc_range_t ordinary; /* Ordinary map location range. */ loc_range_t macro; /* Macro map location range. */ - int ordinary_delta; /* Add to ordinary loc to get serialized loc. */ - int macro_delta; /* Likewise for macro loc. */ + /* Add to locs to get serialized loc. */ + location_diff_t ordinary_delta; + location_diff_t macro_delta; }; private: @@ -3304,9 +3330,9 @@ static loc_spans spans; struct ord_loc_info { const line_map_ordinary *src; // line map we're based on - unsigned offset; // offset to this line - unsigned span; // number of locs we span - unsigned remap; // serialization + line_map_uint_t offset; // offset to this line + line_map_uint_t span; // number of locs we span + line_map_uint_t remap; // serialization static int compare (const void *a_, const void *b_) { @@ -3364,7 +3390,7 @@ static vec<ord_loc_info> *ord_loc_remap; struct macro_loc_info { const line_map_macro *src; // original expansion - unsigned remap; // serialization + line_map_uint_t remap; // serialization static int compare (const void *a_, const void *b_) { @@ -3785,7 +3811,7 @@ class GTY((chain_next ("%h.parent"), for_user)) module_state { bool, unsigned *crc_ptr); bool read_ordinary_maps (unsigned, unsigned); void write_macro_maps (elf_out *to, range_t &, unsigned *crc_ptr); - bool read_macro_maps (unsigned); + bool read_macro_maps (line_map_uint_t); private: void write_define (bytes_out &, const cpp_macro *); @@ -4420,6 +4446,7 @@ dumper::impl::nested_name (tree t) Escapes: %C - tree_code %I - identifier + %K - location_t or line_map_uint_t %M - module_state %N - name -- DECL_NAME %P - context:name pair @@ -4496,6 +4523,13 @@ dumper::operator () (const char *format, ...) } break; + case 'K': /* location_t, either 32- or 64-bit. */ + { + unsigned long long u = va_arg (args, location_t); + fprintf (dumps->stream, "%llu", u); + } + break; + case 'M': /* Module. */ { const char *str = "(none)"; @@ -4565,7 +4599,7 @@ dumper::operator () (const char *format, ...) } break; - case 'V': /* Verson. */ + case 'V': /* Version. */ { unsigned v = va_arg (args, unsigned); verstr_t string; @@ -14264,7 +14298,7 @@ loc_spans::init (const line_maps *lmaps, const line_map_ordinary *map) = MAP_START_LOCATION (LINEMAPS_ORDINARY_MAP_AT (line_table, 0)); interval.macro.first = interval.macro.second; dump (dumper::LOCATION) - && dump ("Fixed span %u ordinary:[%u,%u) macro:[%u,%u)", spans->length (), + && dump ("Fixed span %u ordinary:[%K,%K) macro:[%K,%K)", spans->length (), interval.ordinary.first, interval.ordinary.second, interval.macro.first, interval.macro.second); spans->quick_push (interval); @@ -14278,7 +14312,7 @@ loc_spans::init (const line_maps *lmaps, const line_map_ordinary *map) interval.macro.first = LINEMAPS_MACRO_LOWEST_LOCATION (lmaps); } dump (dumper::LOCATION) - && dump ("Pre span %u ordinary:[%u,%u) macro:[%u,%u)", spans->length (), + && dump ("Pre span %u ordinary:[%K,%K) macro:[%K,%K)", spans->length (), interval.ordinary.first, interval.ordinary.second, interval.macro.first, interval.macro.second); spans->quick_push (interval); @@ -14287,7 +14321,7 @@ loc_spans::init (const line_maps *lmaps, const line_map_ordinary *map) interval.ordinary.first = interval.ordinary.second; interval.macro.second = interval.macro.first; dump (dumper::LOCATION) - && dump ("Main span %u ordinary:[%u,*) macro:[*,%u)", spans->length (), + && dump ("Main span %u ordinary:[%K,*) macro:[*,%K)", spans->length (), interval.ordinary.first, interval.macro.second); spans->quick_push (interval); } @@ -14318,7 +14352,7 @@ loc_spans::open (location_t hwm) = LINEMAPS_MACRO_LOWEST_LOCATION (line_table); interval.ordinary_delta = interval.macro_delta = 0; dump (dumper::LOCATION) - && dump ("Opening span %u ordinary:[%u,... macro:...,%u)", + && dump ("Opening span %u ordinary:[%K,... macro:...,%K)", spans->length (), interval.ordinary.first, interval.macro.second); if (spans->length ()) @@ -14340,11 +14374,12 @@ loc_spans::close () span &interval = spans->last (); interval.ordinary.second - = ((line_table->highest_location + (1 << line_table->default_range_bits)) - & ~((1u << line_table->default_range_bits) - 1)); + = ((line_table->highest_location + + (loc_one << line_table->default_range_bits)) + & ~((loc_one << line_table->default_range_bits) - 1)); interval.macro.first = LINEMAPS_MACRO_LOWEST_LOCATION (line_table); dump (dumper::LOCATION) - && dump ("Closing span %u ordinary:[%u,%u) macro:[%u,%u)", + && dump ("Closing span %u ordinary:[%K,%K) macro:[%K,%K)", spans->length () - 1, interval.ordinary.first,interval.ordinary.second, interval.macro.first, interval.macro.second); @@ -15054,23 +15089,14 @@ module_state::read_partitions (unsigned count) /* Data for config reading and writing. */ struct module_state_config { - const char *dialect_str; - unsigned num_imports; - unsigned num_partitions; - unsigned num_entities; - unsigned ordinary_locs; - unsigned macro_locs; - unsigned loc_range_bits; - unsigned active_init; - -public: - module_state_config () - :dialect_str (get_dialect ()), - num_imports (0), num_partitions (0), num_entities (0), - ordinary_locs (0), macro_locs (0), loc_range_bits (0), - active_init (0) - { - } + const char *dialect_str = get_dialect (); + line_map_uint_t ordinary_locs = 0; + line_map_uint_t macro_locs = 0; + unsigned num_imports = 0; + unsigned num_partitions = 0; + unsigned num_entities = 0; + unsigned loc_range_bits = 0; + unsigned active_init = 0; static void release () { @@ -16356,7 +16382,7 @@ module_state::note_location (location_t loc) const line_map_ordinary *ord_map = linemap_check_ordinary (map); ord_loc_info lkup; lkup.src = ord_map; - lkup.span = 1 << ord_map->m_column_and_range_bits; + lkup.span = loc_one << ord_map->m_column_and_range_bits; lkup.offset = (loc - MAP_START_LOCATION (ord_map)) & ~(lkup.span - 1); lkup.remap = 0; ord_loc_info *slot = (ord_loc_table->find_slot_with_hash @@ -16387,8 +16413,8 @@ module_state::write_location (bytes_out &sec, location_t loc) if (loc < RESERVED_LOCATION_COUNT) { - dump (dumper::LOCATION) && dump ("Reserved location %u", unsigned (loc)); - sec.u (LK_RESERVED + loc); + dump (dumper::LOCATION) && dump ("Reserved location %K", loc); + sec.loc (LK_RESERVED + loc); } else if (IS_ADHOC_LOC (loc)) { @@ -16408,7 +16434,7 @@ module_state::write_location (bytes_out &sec, location_t loc) else if (loc >= LINEMAPS_MACRO_LOWEST_LOCATION (line_table)) { const macro_loc_info *info = nullptr; - unsigned offset = 0; + line_map_uint_t offset = 0; if (unsigned hwm = macro_loc_remap->length ()) { info = macro_loc_remap->begin (); @@ -16434,18 +16460,18 @@ module_state::write_location (bytes_out &sec, location_t loc) { offset += info->remap; sec.u (LK_MACRO); - sec.u (offset); + sec.loc (offset); dump (dumper::LOCATION) - && dump ("Macro location %u output %u", loc, offset); + && dump ("Macro location %K output %K", loc, offset); } else if (const module_state *import = module_for_macro_loc (loc)) { - unsigned off = loc - import->macro_locs.first; + auto off = loc - import->macro_locs.first; sec.u (LK_IMPORT_MACRO); sec.u (import->remap); - sec.u (off); + sec.loc (off); dump (dumper::LOCATION) - && dump ("Imported macro location %u output %u:%u", + && dump ("Imported macro location %K output %u:%K", loc, import->remap, off); } else @@ -16454,13 +16480,13 @@ module_state::write_location (bytes_out &sec, location_t loc) else if (IS_ORDINARY_LOC (loc)) { const ord_loc_info *info = nullptr; - unsigned offset = 0; - if (unsigned hwm = ord_loc_remap->length ()) + line_map_uint_t offset = 0; + if (line_map_uint_t hwm = ord_loc_remap->length ()) { info = ord_loc_remap->begin (); while (hwm != 1) { - unsigned mid = hwm / 2; + auto mid = hwm / 2; if (MAP_START_LOCATION (info[mid].src) + info[mid].offset <= loc) { info += mid; @@ -16480,20 +16506,20 @@ module_state::write_location (bytes_out &sec, location_t loc) { offset += info->remap; sec.u (LK_ORDINARY); - sec.u (offset); + sec.loc (offset); dump (dumper::LOCATION) - && dump ("Ordinary location %u output %u", loc, offset); + && dump ("Ordinary location %K output %K", loc, offset); } else if (const module_state *import = module_for_ordinary_loc (loc)) { - unsigned off = loc - import->ordinary_locs.first; + auto off = loc - import->ordinary_locs.first; sec.u (LK_IMPORT_ORDINARY); sec.u (import->remap); - sec.u (off); + sec.loc (off); dump (dumper::LOCATION) - && dump ("Imported ordinary location %u output %u:%u", - import->remap, import->remap, off); + && dump ("Imported ordinary location %K output %u:%K", + loc, import->remap, off); } else gcc_unreachable (); @@ -16516,7 +16542,7 @@ module_state::read_location (bytes_in &sec) const else sec.set_overrun (); dump (dumper::LOCATION) - && dump ("Reserved location %u", unsigned (locus)); + && dump ("Reserved location %K", locus); } break; @@ -16538,7 +16564,7 @@ module_state::read_location (bytes_in &sec) const case LK_MACRO: { - unsigned off = sec.u (); + auto off = sec.loc (); if (macro_locs.second) { @@ -16550,13 +16576,13 @@ module_state::read_location (bytes_in &sec) const else locus = loc; dump (dumper::LOCATION) - && dump ("Macro %u becoming %u", off, locus); + && dump ("Macro %K becoming %K", off, locus); } break; case LK_ORDINARY: { - unsigned off = sec.u (); + auto off = sec.loc (); if (ordinary_locs.second) { if (off < ordinary_locs.second) @@ -16568,7 +16594,7 @@ module_state::read_location (bytes_in &sec) const locus = loc; dump (dumper::LOCATION) - && dump ("Ordinary location %u becoming %u", off, locus); + && dump ("Ordinary location %K becoming %K", off, locus); } break; @@ -16576,7 +16602,7 @@ module_state::read_location (bytes_in &sec) const case LK_IMPORT_ORDINARY: { unsigned mod = sec.u (); - unsigned off = sec.u (); + location_t off = sec.loc (); const module_state *import = NULL; if (!mod && !slurp->remap) @@ -16639,7 +16665,7 @@ module_state::write_prepare_maps (module_state_config *cfg, bool has_partitions) dump () && dump ("Preparing locations"); dump.indent (); - dump () && dump ("Reserved locations [%u,%u) macro [%u,%u)", + dump () && dump ("Reserved locations [%K,%K) macro [%K,%K)", spans[loc_spans::SPAN_RESERVED].ordinary.first, spans[loc_spans::SPAN_RESERVED].ordinary.second, spans[loc_spans::SPAN_RESERVED].macro.first, @@ -16695,10 +16721,11 @@ module_state::write_prepare_maps (module_state_config *cfg, bool has_partitions) ord_loc_table = nullptr; // Merge (sufficiently) adjacent spans, and calculate remapping. - constexpr unsigned adjacency = 2; // Allow 2 missing lines. + constexpr line_map_uint_t adjacency = 2; // Allow 2 missing lines. auto begin = ord_loc_remap->begin (), end = ord_loc_remap->end (); auto dst = begin; - unsigned offset = 0, range_bits = 0; + line_map_uint_t offset = 0; + unsigned range_bits = 0; ord_loc_info *base = nullptr; for (auto iter = begin; iter != end; ++iter) { @@ -16720,8 +16747,8 @@ module_state::write_prepare_maps (module_state_config *cfg, bool has_partitions) else if (range_bits < iter->src->m_range_bits) range_bits = iter->src->m_range_bits; - offset += ((1u << iter->src->m_range_bits) - 1); - offset &= ~((1u << iter->src->m_range_bits) - 1); + offset += ((loc_one << iter->src->m_range_bits) - 1); + offset &= ~((loc_one << iter->src->m_range_bits) - 1); iter->remap = offset; offset += iter->span; base = dst; @@ -16732,8 +16759,9 @@ module_state::write_prepare_maps (module_state_config *cfg, bool has_partitions) info.first = ord_loc_remap->length (); cfg->ordinary_locs = offset; cfg->loc_range_bits = range_bits; - dump () && dump ("Ordinary maps:%u locs:%u range_bits:%u", - info.first, cfg->ordinary_locs, + dump () && dump ("Ordinary maps:%K locs:%K range_bits:%u", + info.first, + cfg->ordinary_locs, cfg->loc_range_bits); // Remap the macro locations. @@ -16756,7 +16784,7 @@ module_state::write_prepare_maps (module_state_config *cfg, bool has_partitions) info.second = macro_loc_remap->length (); cfg->macro_locs = offset; - dump () && dump ("Macro maps:%u locs:%u", info.second, cfg->macro_locs); + dump () && dump ("Macro maps:%K locs:%K", info.second, cfg->macro_locs); dump.outdent (); @@ -16853,20 +16881,21 @@ module_state::write_ordinary_maps (elf_out *to, range_t &info, sec.str (fname); } - sec.u (info.first); /* Num maps. */ + sec.loc (info.first); /* Num maps. */ const ord_loc_info *base = nullptr; for (auto iter = ord_loc_remap->begin (), end = ord_loc_remap->end (); iter != end; ++iter) { dump (dumper::LOCATION) - && dump ("Span:%u ordinary [%u+%u,+%u)->[%u,+%u)", - iter - ord_loc_remap->begin (), - MAP_START_LOCATION (iter->src), iter->offset, iter->span, - iter->remap, iter->span); + && dump ("Span:%K ordinary [%K+%K,+%K)->[%K,+%K)", + (location_t) (iter - ord_loc_remap->begin ()), + MAP_START_LOCATION (iter->src), + iter->offset, iter->span, iter->remap, + iter->span); if (!base || iter->src != base->src) base = iter; - sec.u (iter->offset - base->offset); + sec.loc (iter->offset - base->offset); if (base == iter) { sec.u (iter->src->sysp); @@ -16884,7 +16913,7 @@ module_state::write_ordinary_maps (elf_out *to, range_t &info, line += iter->offset >> iter->src->m_column_and_range_bits; sec.u (line); } - sec.u (iter->remap); + sec.loc (iter->remap); if (base == iter) { /* Write the included from location, which means reading it @@ -16920,15 +16949,15 @@ module_state::write_macro_maps (elf_out *to, range_t &info, unsigned *crc_p) bytes_out sec (to); sec.begin (); - dump () && dump ("Macro maps:%u", info.second); - sec.u (info.second); + dump () && dump ("Macro maps:%K", info.second); + sec.loc (info.second); - unsigned macro_num = 0; + line_map_uint_t macro_num = 0; for (auto iter = macro_loc_remap->end (), begin = macro_loc_remap->begin (); iter-- != begin;) { auto mac = iter->src; - sec.u (iter->remap); + sec.loc (iter->remap); sec.u (mac->n_tokens); sec.cpp_node (mac->macro); write_location (sec, mac->m_expansion); @@ -16953,7 +16982,7 @@ module_state::write_macro_maps (elf_out *to, range_t &info, unsigned *crc_p) } sec.u (count); dump (dumper::LOCATION) - && dump ("Macro:%u %I %u/%u*2 locations [%u,%u)->%u", + && dump ("Macro:%K %I %u/%u*2 locations [%K,%K)->%K", macro_num, identifier (mac->macro), runs, mac->n_tokens, MAP_START_LOCATION (mac), @@ -16994,12 +17023,13 @@ module_state::read_ordinary_maps (unsigned num_ord_locs, unsigned range_bits) filenames.quick_push (fname); } - unsigned num_ordinary = sec.u (); - dump () && dump ("Ordinary maps:%u, range_bits:%u", num_ordinary, range_bits); + line_map_uint_t num_ordinary = sec.loc (); + dump () && dump ("Ordinary maps:%K, range_bits:%u", + num_ordinary, range_bits); location_t offset = line_table->highest_location + 1; - offset += ((1u << range_bits) - 1); - offset &= ~((1u << range_bits) - 1); + offset += ((loc_one << range_bits) - 1); + offset &= ~((loc_one << range_bits) - 1); ordinary_locs.first = offset; bool propagated = spans.maybe_propagate (this, offset); @@ -17007,11 +17037,11 @@ module_state::read_ordinary_maps (unsigned num_ord_locs, unsigned range_bits) (line_map_new_raw (line_table, false, num_ordinary)); const line_map_ordinary *base = nullptr; - for (unsigned ix = 0; ix != num_ordinary && !sec.get_overrun (); ix++) + for (line_map_uint_t ix = 0; ix != num_ordinary && !sec.get_overrun (); ix++) { line_map_ordinary *map = &maps[ix]; - unsigned offset = sec.u (); + location_t offset = sec.loc (); if (!offset) { map->reason = LC_RENAME; @@ -17028,7 +17058,7 @@ module_state::read_ordinary_maps (unsigned num_ord_locs, unsigned range_bits) *map = *base; map->to_line += offset >> map->m_column_and_range_bits; } - unsigned remap = sec.u (); + location_t remap = sec.loc (); map->start_location = remap + ordinary_locs.first; if (base == map) { @@ -17048,7 +17078,7 @@ module_state::read_ordinary_maps (unsigned num_ord_locs, unsigned range_bits) /* We shouldn't run out of locations, as we checked before starting. */ sec.set_overrun (); - dump () && dump ("Ordinary location [%u,+%u)", + dump () && dump ("Ordinary location [%K,+%K)", ordinary_locs.first, ordinary_locs.second); if (propagated) @@ -17064,7 +17094,7 @@ module_state::read_ordinary_maps (unsigned num_ord_locs, unsigned range_bits) } bool -module_state::read_macro_maps (unsigned num_macro_locs) +module_state::read_macro_maps (line_map_uint_t num_macro_locs) { bytes_in sec; @@ -17073,8 +17103,9 @@ module_state::read_macro_maps (unsigned num_macro_locs) dump () && dump ("Reading macro location maps"); dump.indent (); - unsigned num_macros = sec.u (); - dump () && dump ("Macro maps:%u locs:%u", num_macros, num_macro_locs); + line_map_uint_t num_macros = sec.loc (); + dump () && dump ("Macro maps:%K locs:%K", + num_macros, num_macro_locs); bool propagated = spans.maybe_propagate (this, line_table->highest_location + 1); @@ -17083,13 +17114,13 @@ module_state::read_macro_maps (unsigned num_macro_locs) macro_locs.second = num_macro_locs; macro_locs.first = offset - num_macro_locs; - dump () && dump ("Macro loc delta %d", offset); - dump () && dump ("Macro locations [%u,%u)", + dump () && dump ("Macro loc delta %K", offset); + dump () && dump ("Macro locations [%K,%K)", macro_locs.first, macro_locs.second); - for (unsigned ix = 0; ix != num_macros && !sec.get_overrun (); ix++) + for (line_map_uint_t ix = 0; ix != num_macros && !sec.get_overrun (); ix++) { - unsigned offset = sec.u (); + location_t offset = sec.loc (); unsigned n_tokens = sec.u (); cpp_hashnode *node = sec.cpp_node (); location_t exp_loc = read_location (sec); @@ -17120,13 +17151,13 @@ module_state::read_macro_maps (unsigned num_macro_locs) if (count) sec.set_overrun (); dump (dumper::LOCATION) - && dump ("Macro:%u %I %u/%u*2 locations [%u,%u)", + && dump ("Macro:%K %I %u/%u*2 locations [%K,%K)", ix, identifier (node), runs, n_tokens, MAP_START_LOCATION (macro), MAP_START_LOCATION (macro) + n_tokens); } - dump () && dump ("Macro location lwm:%u", macro_locs.first); + dump () && dump ("Macro location lwm:%K", macro_locs.first); if (propagated) spans.close (); @@ -18167,8 +18198,8 @@ module_state::write_config (elf_out *to, module_state_config &config, cfg.u (config.num_partitions); cfg.u (config.num_entities); - cfg.u (config.ordinary_locs); - cfg.u (config.macro_locs); + cfg.loc (config.ordinary_locs); + cfg.loc (config.macro_locs); cfg.u (config.loc_range_bits); cfg.u (config.active_init); @@ -18354,8 +18385,8 @@ module_state::read_config (module_state_config &config) config.num_partitions = cfg.u (); config.num_entities = cfg.u (); - config.ordinary_locs = cfg.u (); - config.macro_locs = cfg.u (); + config.ordinary_locs = cfg.loc (); + config.macro_locs = cfg.loc (); config.loc_range_bits = cfg.u (); config.active_init = cfg.u (); @@ -20460,7 +20491,7 @@ preprocess_module (module_state *module, location_t from_loc, name_pending_imports (reader); /* Preserve the state of the line-map. */ - unsigned pre_hwm = LINEMAPS_ORDINARY_USED (line_table); + auto pre_hwm = LINEMAPS_ORDINARY_USED (line_table); /* We only need to close the span, if we're going to emit a CMI. But that's a little tricky -- our token scanner