Subversion Repositories openrisc

/* Read the GIMPLE representation from a file stream.

   Copyright 2009, 2010 Free Software Foundation, Inc.

   Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>

   Re-implemented by Diego Novillo <dnovillo@google.com>

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License as published by the Free

Software Foundation; either version 3, or (at your option) any later

version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with GCC; see the file COPYING3.  If not see

<http://www.gnu.org/licenses/>.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "toplev.h"

#include "tree.h"

#include "expr.h"

#include "flags.h"

#include "params.h"

#include "input.h"

#include "hashtab.h"

#include "basic-block.h"

#include "tree-flow.h"

#include "tree-pass.h"

#include "cgraph.h"

#include "function.h"

#include "ggc.h"

#include "diagnostic.h"

#include "libfuncs.h"

#include "except.h"

#include "debug.h"

#include "vec.h"

#include "timevar.h"

#include "output.h"

#include "ipa-utils.h"

#include "data-streamer.h"

#include "gimple-streamer.h"

#include "lto-streamer.h"

#include "tree-streamer.h"

#include "tree-pass.h"

#include "streamer-hooks.h"

/* The table to hold the file names.  */

static htab_t file_name_hash_table;

/* Check that tag ACTUAL has one of the given values.  NUM_TAGS is the

   number of valid tag values to check.  */

void

lto_tag_check_set (enum LTO_tags actual, int ntags, ...)

{

  va_list ap;

  int i;

  va_start (ap, ntags);

  for (i = 0; i < ntags; i++)

    if ((unsigned) actual == va_arg (ap, unsigned))

      {

        va_end (ap);

        return;

      }

  va_end (ap);

  internal_error ("bytecode stream: unexpected tag %s", lto_tag_name (actual));

}

/* Read LENGTH bytes from STREAM to ADDR.  */

void

lto_input_data_block (struct lto_input_block *ib, void *addr, size_t length)

{

  size_t i;

  unsigned char *const buffer = (unsigned char *const) addr;

  for (i = 0; i < length; i++)

    buffer[i] = streamer_read_uchar (ib);

}

/* Lookup STRING in file_name_hash_table.  If found, return the existing

   string, otherwise insert STRING as the canonical version.  */

static const char *

canon_file_name (const char *string)

{

  void **slot;

  struct string_slot s_slot;

  size_t len = strlen (string);

  s_slot.s = string;

  s_slot.len = len;

  slot = htab_find_slot (file_name_hash_table, &s_slot, INSERT);

  if (*slot == NULL)

    {

      char *saved_string;

      struct string_slot *new_slot;

      saved_string = (char *) xmalloc (len + 1);

      new_slot = XCNEW (struct string_slot);

      memcpy (saved_string, string, len + 1);

      new_slot->s = saved_string;

      new_slot->len = len;

      *slot = new_slot;

      return saved_string;

    }

  else

    {

      struct string_slot *old_slot = (struct string_slot *) *slot;

      return old_slot->s;

    }

}

/* Clear the line info stored in DATA_IN.  */

static void

clear_line_info (struct data_in *data_in)

{

  if (data_in->current_file)

    linemap_add (line_table, LC_LEAVE, false, NULL, 0);

  data_in->current_file = NULL;

  data_in->current_line = 0;

  data_in->current_col = 0;

}

/* Read a location bitpack from input block IB.  */

static location_t

lto_input_location_bitpack (struct data_in *data_in, struct bitpack_d *bp)

{

  bool file_change, line_change, column_change;

  unsigned len;

  bool prev_file = data_in->current_file != NULL;

  if (bp_unpack_value (bp, 1))

    return UNKNOWN_LOCATION;

  file_change = bp_unpack_value (bp, 1);

  if (file_change)

    data_in->current_file = canon_file_name

                              (string_for_index (data_in,

                                                 bp_unpack_var_len_unsigned (bp),

                                                 &len));

  line_change = bp_unpack_value (bp, 1);

  if (line_change)

    data_in->current_line = bp_unpack_var_len_unsigned (bp);

  column_change = bp_unpack_value (bp, 1);

  if (column_change)

    data_in->current_col = bp_unpack_var_len_unsigned (bp);

  if (file_change)

    {

      if (prev_file)

        linemap_add (line_table, LC_LEAVE, false, NULL, 0);

      linemap_add (line_table, LC_ENTER, false, data_in->current_file,

                   data_in->current_line);

    }

  else if (line_change)

    linemap_line_start (line_table, data_in->current_line, data_in->current_col);

  return linemap_position_for_column (line_table, data_in->current_col);

}

/* Read a location from input block IB.

   If the input_location streamer hook exists, call it.

   Otherwise, proceed with reading the location from the

   expanded location bitpack.  */

location_t

lto_input_location (struct lto_input_block *ib, struct data_in *data_in)

{

  if (streamer_hooks.input_location)

    return streamer_hooks.input_location (ib, data_in);

  else

    {

      struct bitpack_d bp;

      bp = streamer_read_bitpack (ib);

      return lto_input_location_bitpack (data_in, &bp);

    }

}

/* Read a reference to a tree node from DATA_IN using input block IB.

   TAG is the expected node that should be found in IB, if TAG belongs

   to one of the indexable trees, expect to read a reference index to

   be looked up in one of the symbol tables, otherwise read the pysical

   representation of the tree using stream_read_tree.  FN is the

   function scope for the read tree.  */

tree

lto_input_tree_ref (struct lto_input_block *ib, struct data_in *data_in,

                    struct function *fn, enum LTO_tags tag)

{

  unsigned HOST_WIDE_INT ix_u;

  tree result = NULL_TREE;

  lto_tag_check_range (tag, LTO_field_decl_ref, LTO_global_decl_ref);

  switch (tag)

    {

    case LTO_type_ref:

      ix_u = streamer_read_uhwi (ib);

      result = lto_file_decl_data_get_type (data_in->file_data, ix_u);

      break;

    case LTO_ssa_name_ref:

      ix_u = streamer_read_uhwi (ib);

      result = VEC_index (tree, SSANAMES (fn), ix_u);

      break;

    case LTO_field_decl_ref:

      ix_u = streamer_read_uhwi (ib);

      result = lto_file_decl_data_get_field_decl (data_in->file_data, ix_u);

      break;

    case LTO_function_decl_ref:

      ix_u = streamer_read_uhwi (ib);

      result = lto_file_decl_data_get_fn_decl (data_in->file_data, ix_u);

      break;

    case LTO_type_decl_ref:

      ix_u = streamer_read_uhwi (ib);

      result = lto_file_decl_data_get_type_decl (data_in->file_data, ix_u);

      break;

    case LTO_namespace_decl_ref:

      ix_u = streamer_read_uhwi (ib);

      result = lto_file_decl_data_get_namespace_decl (data_in->file_data, ix_u);

      break;

    case LTO_global_decl_ref:

    case LTO_result_decl_ref:

    case LTO_const_decl_ref:

    case LTO_imported_decl_ref:

    case LTO_label_decl_ref:

    case LTO_translation_unit_decl_ref:

      ix_u = streamer_read_uhwi (ib);

      result = lto_file_decl_data_get_var_decl (data_in->file_data, ix_u);

      break;

    default:

      gcc_unreachable ();

    }

  gcc_assert (result);

  return result;

}

/* Read and return a double-linked list of catch handlers from input

   block IB, using descriptors in DATA_IN.  */

static struct eh_catch_d *

lto_input_eh_catch_list (struct lto_input_block *ib, struct data_in *data_in,

                         eh_catch *last_p)

{

  eh_catch first;

  enum LTO_tags tag;

  *last_p = first = NULL;

  tag = streamer_read_record_start (ib);

  while (tag)

    {

      tree list;

      eh_catch n;

      lto_tag_check_range (tag, LTO_eh_catch, LTO_eh_catch);

      /* Read the catch node.  */

      n = ggc_alloc_cleared_eh_catch_d ();

      n->type_list = stream_read_tree (ib, data_in);

      n->filter_list = stream_read_tree (ib, data_in);

      n->label = stream_read_tree (ib, data_in);

      /* Register all the types in N->FILTER_LIST.  */

      for (list = n->filter_list; list; list = TREE_CHAIN (list))

        add_type_for_runtime (TREE_VALUE (list));

      /* Chain N to the end of the list.  */

      if (*last_p)

        (*last_p)->next_catch = n;

      n->prev_catch = *last_p;

      *last_p = n;

      /* Set the head of the list the first time through the loop.  */

      if (first == NULL)

        first = n;

      tag = streamer_read_record_start (ib);

    }

  return first;

}

/* Read and return EH region IX from input block IB, using descriptors

   in DATA_IN.  */

static eh_region

input_eh_region (struct lto_input_block *ib, struct data_in *data_in, int ix)

{

  enum LTO_tags tag;

  eh_region r;

  /* Read the region header.  */

  tag = streamer_read_record_start (ib);

  if (tag == LTO_null)

    return NULL;

  r = ggc_alloc_cleared_eh_region_d ();

  r->index = streamer_read_hwi (ib);

  gcc_assert (r->index == ix);

  /* Read all the region pointers as region numbers.  We'll fix up

     the pointers once the whole array has been read.  */

  r->outer = (eh_region) (intptr_t) streamer_read_hwi (ib);

  r->inner = (eh_region) (intptr_t) streamer_read_hwi (ib);

  r->next_peer = (eh_region) (intptr_t) streamer_read_hwi (ib);

  switch (tag)

    {

      case LTO_ert_cleanup:

        r->type = ERT_CLEANUP;

        break;

      case LTO_ert_try:

        {

          struct eh_catch_d *last_catch;

          r->type = ERT_TRY;

          r->u.eh_try.first_catch = lto_input_eh_catch_list (ib, data_in,

                                                             &last_catch);

          r->u.eh_try.last_catch = last_catch;

          break;

        }

      case LTO_ert_allowed_exceptions:

        {

          tree l;

          r->type = ERT_ALLOWED_EXCEPTIONS;

          r->u.allowed.type_list = stream_read_tree (ib, data_in);

          r->u.allowed.label = stream_read_tree (ib, data_in);

          r->u.allowed.filter = streamer_read_uhwi (ib);

          for (l = r->u.allowed.type_list; l ; l = TREE_CHAIN (l))

            add_type_for_runtime (TREE_VALUE (l));

        }

        break;

      case LTO_ert_must_not_throw:

        r->type = ERT_MUST_NOT_THROW;

        r->u.must_not_throw.failure_decl = stream_read_tree (ib, data_in);

        r->u.must_not_throw.failure_loc = lto_input_location (ib, data_in);

        break;

      default:

        gcc_unreachable ();

    }

  r->landing_pads = (eh_landing_pad) (intptr_t) streamer_read_hwi (ib);

  return r;

}

/* Read and return EH landing pad IX from input block IB, using descriptors

   in DATA_IN.  */

static eh_landing_pad

input_eh_lp (struct lto_input_block *ib, struct data_in *data_in, int ix)

{

  enum LTO_tags tag;

  eh_landing_pad lp;

  /* Read the landing pad header.  */

  tag = streamer_read_record_start (ib);

  if (tag == LTO_null)

    return NULL;

  lto_tag_check_range (tag, LTO_eh_landing_pad, LTO_eh_landing_pad);

  lp = ggc_alloc_cleared_eh_landing_pad_d ();

  lp->index = streamer_read_hwi (ib);

  gcc_assert (lp->index == ix);

  lp->next_lp = (eh_landing_pad) (intptr_t) streamer_read_hwi (ib);

  lp->region = (eh_region) (intptr_t) streamer_read_hwi (ib);

  lp->post_landing_pad = stream_read_tree (ib, data_in);

  return lp;

}

/* After reading the EH regions, pointers to peer and children regions

   are region numbers.  This converts all these region numbers into

   real pointers into the rematerialized regions for FN.  ROOT_REGION

   is the region number for the root EH region in FN.  */

static void

fixup_eh_region_pointers (struct function *fn, HOST_WIDE_INT root_region)

{

  unsigned i;

  VEC(eh_region,gc) *eh_array = fn->eh->region_array;

  VEC(eh_landing_pad,gc) *lp_array = fn->eh->lp_array;

  eh_region r;

  eh_landing_pad lp;

  gcc_assert (eh_array && lp_array);

  gcc_assert (root_region >= 0);

  fn->eh->region_tree = VEC_index (eh_region, eh_array, root_region);

#define FIXUP_EH_REGION(r) (r) = VEC_index (eh_region, eh_array, \

                                            (HOST_WIDE_INT) (intptr_t) (r))

#define FIXUP_EH_LP(p) (p) = VEC_index (eh_landing_pad, lp_array, \

                                        (HOST_WIDE_INT) (intptr_t) (p))

  /* Convert all the index numbers stored in pointer fields into

     pointers to the corresponding slots in the EH region array.  */

  FOR_EACH_VEC_ELT (eh_region, eh_array, i, r)

    {

      /* The array may contain NULL regions.  */

      if (r == NULL)

        continue;

      gcc_assert (i == (unsigned) r->index);

      FIXUP_EH_REGION (r->outer);

      FIXUP_EH_REGION (r->inner);

      FIXUP_EH_REGION (r->next_peer);

      FIXUP_EH_LP (r->landing_pads);

    }

  /* Convert all the index numbers stored in pointer fields into

     pointers to the corresponding slots in the EH landing pad array.  */

  FOR_EACH_VEC_ELT (eh_landing_pad, lp_array, i, lp)

    {

      /* The array may contain NULL landing pads.  */

      if (lp == NULL)

        continue;

      gcc_assert (i == (unsigned) lp->index);

      FIXUP_EH_LP (lp->next_lp);

      FIXUP_EH_REGION (lp->region);

    }

#undef FIXUP_EH_REGION

#undef FIXUP_EH_LP

}

/* Initialize EH support.  */

void

lto_init_eh (void)

{

  static bool eh_initialized_p = false;

  if (eh_initialized_p)

    return;

  /* Contrary to most other FEs, we only initialize EH support when at

     least one of the files in the set contains exception regions in

     it.  Since this happens much later than the call to init_eh in

     lang_dependent_init, we have to set flag_exceptions and call

     init_eh again to initialize the EH tables.  */

  flag_exceptions = 1;

  init_eh ();

  eh_initialized_p = true;

}

/* Read the exception table for FN from IB using the data descriptors

   in DATA_IN.  */

static void

input_eh_regions (struct lto_input_block *ib, struct data_in *data_in,

                  struct function *fn)

{

  HOST_WIDE_INT i, root_region, len;

  enum LTO_tags tag;

  tag = streamer_read_record_start (ib);

  if (tag == LTO_null)

    return;

  lto_tag_check_range (tag, LTO_eh_table, LTO_eh_table);

  /* If the file contains EH regions, then it was compiled with

     -fexceptions.  In that case, initialize the backend EH

     machinery.  */

  lto_init_eh ();

  gcc_assert (fn->eh);

  root_region = streamer_read_hwi (ib);

  gcc_assert (root_region == (int) root_region);

  /* Read the EH region array.  */

  len = streamer_read_hwi (ib);

  gcc_assert (len == (int) len);

  if (len > 0)

    {

      VEC_safe_grow (eh_region, gc, fn->eh->region_array, len);

      for (i = 0; i < len; i++)

        {

          eh_region r = input_eh_region (ib, data_in, i);

          VEC_replace (eh_region, fn->eh->region_array, i, r);

        }

    }

  /* Read the landing pads.  */

  len = streamer_read_hwi (ib);

  gcc_assert (len == (int) len);

  if (len > 0)

    {

      VEC_safe_grow (eh_landing_pad, gc, fn->eh->lp_array, len);

      for (i = 0; i < len; i++)

        {

          eh_landing_pad lp = input_eh_lp (ib, data_in, i);

          VEC_replace (eh_landing_pad, fn->eh->lp_array, i, lp);

        }

    }

  /* Read the runtime type data.  */

  len = streamer_read_hwi (ib);

  gcc_assert (len == (int) len);

  if (len > 0)

    {

      VEC_safe_grow (tree, gc, fn->eh->ttype_data, len);

      for (i = 0; i < len; i++)

        {

          tree ttype = stream_read_tree (ib, data_in);

          VEC_replace (tree, fn->eh->ttype_data, i, ttype);

        }

    }

  /* Read the table of action chains.  */

  len = streamer_read_hwi (ib);

  gcc_assert (len == (int) len);

  if (len > 0)

    {

      if (targetm.arm_eabi_unwinder)

        {

          VEC_safe_grow (tree, gc, fn->eh->ehspec_data.arm_eabi, len);

          for (i = 0; i < len; i++)

            {

              tree t = stream_read_tree (ib, data_in);

              VEC_replace (tree, fn->eh->ehspec_data.arm_eabi, i, t);

            }

        }

      else

        {

          VEC_safe_grow (uchar, gc, fn->eh->ehspec_data.other, len);

          for (i = 0; i < len; i++)

            {

              uchar c = streamer_read_uchar (ib);

              VEC_replace (uchar, fn->eh->ehspec_data.other, i, c);

            }

        }

    }

  /* Reconstruct the EH region tree by fixing up the peer/children

     pointers.  */

  fixup_eh_region_pointers (fn, root_region);

  tag = streamer_read_record_start (ib);

  lto_tag_check_range (tag, LTO_null, LTO_null);

}

/* Make a new basic block with index INDEX in function FN.  */

static basic_block

make_new_block (struct function *fn, unsigned int index)

{

  basic_block bb = alloc_block ();

  bb->index = index;

  SET_BASIC_BLOCK_FOR_FUNCTION (fn, index, bb);

  bb->il.gimple = ggc_alloc_cleared_gimple_bb_info ();

  n_basic_blocks_for_function (fn)++;

  bb->flags = 0;

  set_bb_seq (bb, gimple_seq_alloc ());

  return bb;

}

/* Read the CFG for function FN from input block IB.  */

static void

input_cfg (struct lto_input_block *ib, struct function *fn,

           int count_materialization_scale)

{

  unsigned int bb_count;

  basic_block p_bb;

  unsigned int i;

  int index;

  init_empty_tree_cfg_for_function (fn);

  init_ssa_operands ();

  profile_status_for_function (fn) = streamer_read_enum (ib, profile_status_d,

                                                         PROFILE_LAST);

  bb_count = streamer_read_uhwi (ib);

  last_basic_block_for_function (fn) = bb_count;

  if (bb_count > VEC_length (basic_block, basic_block_info_for_function (fn)))

    VEC_safe_grow_cleared (basic_block, gc,

                           basic_block_info_for_function (fn), bb_count);

  if (bb_count > VEC_length (basic_block, label_to_block_map_for_function (fn)))

    VEC_safe_grow_cleared (basic_block, gc,

                           label_to_block_map_for_function (fn), bb_count);

  index = streamer_read_hwi (ib);

  while (index != -1)

    {

      basic_block bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);

      unsigned int edge_count;

      if (bb == NULL)

        bb = make_new_block (fn, index);

      edge_count = streamer_read_uhwi (ib);

      /* Connect up the CFG.  */

      for (i = 0; i < edge_count; i++)

        {

          unsigned int dest_index;

          unsigned int edge_flags;

          basic_block dest;

          int probability;

          gcov_type count;

          edge e;

          dest_index = streamer_read_uhwi (ib);

          probability = (int) streamer_read_hwi (ib);

          count = ((gcov_type) streamer_read_hwi (ib) * count_materialization_scale

                   + REG_BR_PROB_BASE / 2) / REG_BR_PROB_BASE;

          edge_flags = streamer_read_uhwi (ib);

          dest = BASIC_BLOCK_FOR_FUNCTION (fn, dest_index);

          if (dest == NULL)

            dest = make_new_block (fn, dest_index);

          e = make_edge (bb, dest, edge_flags);

          e->probability = probability;

          e->count = count;

        }

      index = streamer_read_hwi (ib);

    }

  p_bb = ENTRY_BLOCK_PTR_FOR_FUNCTION(fn);

  index = streamer_read_hwi (ib);

  while (index != -1)

    {

      basic_block bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);

      bb->prev_bb = p_bb;

      p_bb->next_bb = bb;

      p_bb = bb;

      index = streamer_read_hwi (ib);

    }

}

/* Read the SSA names array for function FN from DATA_IN using input

   block IB.  */