X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Flto-streamer.c;h=dba9d2d5dd7cbd3cc9789d157c1a36f403f738c2;hb=e71ec76db59f8a20d013503e7192680f92872796;hp=a086d9180041b87d02c7ef2f71506043bb0e3acd;hpb=2cc621c5e912c53a678925c5ed6abfe4218bf95f;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/lto-streamer.c b/gcc/lto-streamer.c index a086d918004..dba9d2d5dd7 100644 --- a/gcc/lto-streamer.c +++ b/gcc/lto-streamer.c @@ -133,57 +133,45 @@ lto_bitmap_free (bitmap b) /* Get a section name for a particular type or name. The NAME field - is only used if SECTION_TYPE is LTO_section_function_body or - LTO_static_initializer. For all others it is ignored. The callee - of this function is responcible to free the returned name. */ + is only used if SECTION_TYPE is LTO_section_function_body. For all + others it is ignored. The callee of this function is responsible + to free the returned name. */ char * -lto_get_section_name (int section_type, const char *name) +lto_get_section_name (int section_type, const char *name, struct lto_file_decl_data *f) { - switch (section_type) + const char *add; + char post[32]; + const char *sep; + + if (section_type == LTO_section_function_body) { - case LTO_section_function_body: gcc_assert (name != NULL); if (name[0] == '*') name++; - return concat (LTO_SECTION_NAME_PREFIX, name, NULL); - - case LTO_section_static_initializer: - return concat (LTO_SECTION_NAME_PREFIX, ".statics", NULL); - - case LTO_section_symtab: - return concat (LTO_SECTION_NAME_PREFIX, ".symtab", NULL); - - case LTO_section_decls: - return concat (LTO_SECTION_NAME_PREFIX, ".decls", NULL); - - case LTO_section_cgraph: - return concat (LTO_SECTION_NAME_PREFIX, ".cgraph", NULL); - - case LTO_section_varpool: - return concat (LTO_SECTION_NAME_PREFIX, ".vars", NULL); - - case LTO_section_refs: - return concat (LTO_SECTION_NAME_PREFIX, ".refs", NULL); - - case LTO_section_jump_functions: - return concat (LTO_SECTION_NAME_PREFIX, ".jmpfuncs", NULL); - - case LTO_section_ipa_pure_const: - return concat (LTO_SECTION_NAME_PREFIX, ".pureconst", NULL); - - case LTO_section_ipa_reference: - return concat (LTO_SECTION_NAME_PREFIX, ".reference", NULL); + add = name; + sep = ""; + } + else if (section_type < LTO_N_SECTION_TYPES) + { + add = lto_section_name[section_type]; + sep = "."; + } + else + internal_error ("bytecode stream: unexpected LTO section %s", name); - case LTO_section_opts: - return concat (LTO_SECTION_NAME_PREFIX, ".opts", NULL); + /* Make the section name unique so that ld -r combining sections + doesn't confuse the reader with merged sections. - case LTO_section_cgraph_opt_sum: - return concat (LTO_SECTION_NAME_PREFIX, ".cgraphopt", NULL); + For options don't add a ID, the option reader cannot deal with them + and merging should be ok here. - default: - internal_error ("bytecode stream: unexpected LTO section %s", name); - } + XXX: use crc64 to minimize collisions? */ + if (section_type == LTO_section_opts) + strcpy (post, ""); + else + sprintf (post, ".%x", f ? f->id : crc32_string(0, get_random_seed (false))); + return concat (LTO_SECTION_NAME_PREFIX, sep, add, post, NULL); } @@ -266,147 +254,6 @@ print_lto_report (void) lto_section_name[i], lto_stats.section_size[i]); } -/* We cache a single bitpack assuming that usually at most one is - life. This saves repeated re-allocations. */ -static struct bitpack_d *cached_bp; - -/* Create a new bitpack. */ - -struct bitpack_d * -bitpack_create (void) -{ - if (cached_bp) - { - struct bitpack_d *bp = cached_bp; - cached_bp = NULL; - return bp; - } - return XCNEW (struct bitpack_d); -} - - -/* Free the memory used by bitpack BP. */ - -void -bitpack_delete (struct bitpack_d *bp) -{ - if (!cached_bp) - { - bp->num_bits = 0; - bp->first_unused_bit = 0; - VEC_truncate (bitpack_word_t, bp->values, 0); - cached_bp = bp; - return; - } - VEC_free (bitpack_word_t, heap, bp->values); - free (bp); -} - - -/* Return an index to the word in bitpack BP that contains the - next NBITS. */ - -static inline unsigned -bp_get_next_word (struct bitpack_d *bp, unsigned nbits) -{ - unsigned last, ix; - - /* In principle, the next word to use is determined by the - number of bits already processed in BP. */ - ix = bp->num_bits / BITS_PER_BITPACK_WORD; - - /* All the encoded bit patterns in BP are contiguous, therefore if - the next NBITS would straddle over two different words, move the - index to the next word and update the number of encoded bits - by adding up the hole of unused bits created by this move. */ - bp->first_unused_bit %= BITS_PER_BITPACK_WORD; - last = bp->first_unused_bit + nbits - 1; - if (last >= BITS_PER_BITPACK_WORD) - { - ix++; - bp->num_bits += (BITS_PER_BITPACK_WORD - bp->first_unused_bit); - bp->first_unused_bit = 0; - } - - return ix; -} - - -/* Pack NBITS of value VAL into bitpack BP. */ - -void -bp_pack_value (struct bitpack_d *bp, bitpack_word_t val, unsigned nbits) -{ - unsigned ix; - bitpack_word_t word; - - /* We cannot encode more bits than BITS_PER_BITPACK_WORD. */ -#ifdef ENABLE_CHECKING - gcc_assert (nbits > 0 && nbits <= BITS_PER_BITPACK_WORD); -#endif - - /* Compute which word will contain the next NBITS. */ - ix = bp_get_next_word (bp, nbits); - if (ix >= VEC_length (bitpack_word_t, bp->values)) - { - /* If there is no room left in the last word of the values - array, add a new word. Additionally, we should only - need to add a single word, since every pack operation cannot - use more bits than fit in a single word. */ - VEC_safe_push (bitpack_word_t, heap, bp->values, 0); - } - - /* Grab the last word to pack VAL into. */ - word = VEC_index (bitpack_word_t, bp->values, ix); - - /* To fit VAL in WORD, we need to shift VAL to the left to - skip the bottom BP->FIRST_UNUSED_BIT bits. */ - val <<= bp->first_unused_bit; - - /* Update WORD with VAL. */ - word |= val; - - /* Update BP. */ - VEC_replace (bitpack_word_t, bp->values, ix, word); - bp->num_bits += nbits; - bp->first_unused_bit += nbits; -} - - -/* Unpack the next NBITS from bitpack BP. */ - -bitpack_word_t -bp_unpack_value (struct bitpack_d *bp, unsigned nbits) -{ - bitpack_word_t val, word, mask; - unsigned ix; - - /* We cannot decode more bits than BITS_PER_BITPACK_WORD. */ - gcc_assert (nbits > 0 && nbits <= BITS_PER_BITPACK_WORD); - - /* Compute which word contains the next NBITS. */ - ix = bp_get_next_word (bp, nbits); - word = VEC_index (bitpack_word_t, bp->values, ix); - - /* Compute the mask to get NBITS from WORD. */ - mask = (nbits == BITS_PER_BITPACK_WORD) - ? (bitpack_word_t) -1 - : ((bitpack_word_t) 1 << nbits) - 1; - - /* Shift WORD to the right to skip over the bits already decoded - in word. */ - word >>= bp->first_unused_bit; - - /* Apply the mask to obtain the requested value. */ - val = word & mask; - - /* Update BP->NUM_BITS for the next unpack operation. */ - bp->num_bits += nbits; - bp->first_unused_bit += nbits; - - return val; -} - /* Check that all the TS_* structures handled by the lto_output_* and lto_input_* routines are exactly ALL the structures defined in @@ -456,6 +303,7 @@ check_handled_ts_structures (void) handled_p[TS_OMP_CLAUSE] = true; handled_p[TS_OPTIMIZATION] = true; handled_p[TS_TARGET_OPTION] = true; + handled_p[TS_TRANSLATION_UNIT_DECL] = true; /* Anything not marked above will trigger the following assertion. If this assertion triggers, it means that there is a new TS_* @@ -674,7 +522,13 @@ lto_record_common_node (tree *nodep, VEC(tree, heap) **common_nodes, return; if (TYPE_P (node)) - *nodep = node = gimple_register_type (node); + { + /* Type merging will get confused by the canonical types as they + are set by the middle-end. */ + if (in_lto_p) + TYPE_CANONICAL (node) = NULL_TREE; + *nodep = node = gimple_register_type (node); + } /* Return if node is already seen. */ if (pointer_set_insert (seen_nodes, node)) @@ -791,7 +645,7 @@ lto_streamer_cache_create (void) unnecessarily. */ common_nodes = lto_get_common_nodes (); - for (i = 0; VEC_iterate (tree, common_nodes, i, node); i++) + FOR_EACH_VEC_ELT (tree, common_nodes, i, node) preload_common_node (cache, node); VEC_free(tree, heap, common_nodes);