Subversion Repositories openrisc

/* A pass for lowering trees to RTL.

   Copyright (C) 2004, 2005, 2007 Free Software Foundation, Inc.

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 "tree.h"

#include "rtl.h"

#include "tm_p.h"

#include "basic-block.h"

#include "function.h"

#include "expr.h"

#include "langhooks.h"

#include "tree-flow.h"

#include "timevar.h"

#include "tree-dump.h"

#include "tree-pass.h"

#include "except.h"

#include "flags.h"

#include "diagnostic.h"

#include "toplev.h"

#include "debug.h"

#include "params.h"

/* Verify that there is exactly single jump instruction since last and attach

   REG_BR_PROB note specifying probability.

   ??? We really ought to pass the probability down to RTL expanders and let it

   re-distribute it when the conditional expands into multiple conditionals.

   This is however difficult to do.  */

static void

add_reg_br_prob_note (rtx last, int probability)

{

  if (profile_status == PROFILE_ABSENT)

    return;

  for (last = NEXT_INSN (last); last && NEXT_INSN (last); last = NEXT_INSN (last))

    if (JUMP_P (last))

      {

        /* It is common to emit condjump-around-jump sequence when we don't know

           how to reverse the conditional.  Special case this.  */

        if (!any_condjump_p (last)

            || !JUMP_P (NEXT_INSN (last))

            || !simplejump_p (NEXT_INSN (last))

            || !NEXT_INSN (NEXT_INSN (last))

            || !BARRIER_P (NEXT_INSN (NEXT_INSN (last)))

            || !NEXT_INSN (NEXT_INSN (NEXT_INSN (last)))

            || !LABEL_P (NEXT_INSN (NEXT_INSN (NEXT_INSN (last))))

            || NEXT_INSN (NEXT_INSN (NEXT_INSN (NEXT_INSN (last)))))

          goto failed;

        gcc_assert (!find_reg_note (last, REG_BR_PROB, 0));

        REG_NOTES (last)

          = gen_rtx_EXPR_LIST (REG_BR_PROB,

                               GEN_INT (REG_BR_PROB_BASE - probability),

                               REG_NOTES (last));

        return;

      }

  if (!last || !JUMP_P (last) || !any_condjump_p (last))

    goto failed;

  gcc_assert (!find_reg_note (last, REG_BR_PROB, 0));

  REG_NOTES (last)

    = gen_rtx_EXPR_LIST (REG_BR_PROB,

                         GEN_INT (probability), REG_NOTES (last));

  return;

failed:

  if (dump_file)

    fprintf (dump_file, "Failed to add probability note\n");

}

#ifndef LOCAL_ALIGNMENT

#define LOCAL_ALIGNMENT(TYPE, ALIGNMENT) ALIGNMENT

#endif

#ifndef STACK_ALIGNMENT_NEEDED

#define STACK_ALIGNMENT_NEEDED 1

#endif

/* This structure holds data relevant to one variable that will be

   placed in a stack slot.  */

struct stack_var

{

  /* The Variable.  */

  tree decl;

  /* The offset of the variable.  During partitioning, this is the

     offset relative to the partition.  After partitioning, this

     is relative to the stack frame.  */

  HOST_WIDE_INT offset;

  /* Initially, the size of the variable.  Later, the size of the partition,

     if this variable becomes it's partition's representative.  */

  HOST_WIDE_INT size;

  /* The *byte* alignment required for this variable.  Or as, with the

     size, the alignment for this partition.  */

  unsigned int alignb;

  /* The partition representative.  */

  size_t representative;

  /* The next stack variable in the partition, or EOC.  */

  size_t next;

};

#define EOC  ((size_t)-1)

/* We have an array of such objects while deciding allocation.  */

static struct stack_var *stack_vars;

static size_t stack_vars_alloc;

static size_t stack_vars_num;

/* An array of indicies such that stack_vars[stack_vars_sorted[i]].size

   is non-decreasing.  */

static size_t *stack_vars_sorted;

/* We have an interference graph between such objects.  This graph

   is lower triangular.  */

static bool *stack_vars_conflict;

static size_t stack_vars_conflict_alloc;

/* The phase of the stack frame.  This is the known misalignment of

   virtual_stack_vars_rtx from PREFERRED_STACK_BOUNDARY.  That is,

   (frame_offset+frame_phase) % PREFERRED_STACK_BOUNDARY == 0.  */

static int frame_phase;

/* Used during expand_used_vars to remember if we saw any decls for

   which we'd like to enable stack smashing protection.  */

static bool has_protected_decls;

/* Used during expand_used_vars.  Remember if we say a character buffer

   smaller than our cutoff threshold.  Used for -Wstack-protector.  */

static bool has_short_buffer;

/* Discover the byte alignment to use for DECL.  Ignore alignment

   we can't do with expected alignment of the stack boundary.  */

static unsigned int

get_decl_align_unit (tree decl)

{

  unsigned int align;

  align = DECL_ALIGN (decl);

  align = LOCAL_ALIGNMENT (TREE_TYPE (decl), align);

  if (align > PREFERRED_STACK_BOUNDARY)

    align = PREFERRED_STACK_BOUNDARY;

  if (cfun->stack_alignment_needed < align)

    cfun->stack_alignment_needed = align;

  return align / BITS_PER_UNIT;

}

/* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.

   Return the frame offset.  */

static HOST_WIDE_INT

alloc_stack_frame_space (HOST_WIDE_INT size, HOST_WIDE_INT align)

{

  HOST_WIDE_INT offset, new_frame_offset;

  new_frame_offset = frame_offset;

  if (FRAME_GROWS_DOWNWARD)

    {

      new_frame_offset -= size + frame_phase;

      new_frame_offset &= -align;

      new_frame_offset += frame_phase;

      offset = new_frame_offset;

    }

  else

    {

      new_frame_offset -= frame_phase;

      new_frame_offset += align - 1;

      new_frame_offset &= -align;

      new_frame_offset += frame_phase;

      offset = new_frame_offset;

      new_frame_offset += size;

    }

  frame_offset = new_frame_offset;

  if (frame_offset_overflow (frame_offset, cfun->decl))

    frame_offset = offset = 0;

  return offset;

}

/* Accumulate DECL into STACK_VARS.  */

static void

add_stack_var (tree decl)

{

  if (stack_vars_num >= stack_vars_alloc)

    {

      if (stack_vars_alloc)

        stack_vars_alloc = stack_vars_alloc * 3 / 2;

      else

        stack_vars_alloc = 32;

      stack_vars

        = XRESIZEVEC (struct stack_var, stack_vars, stack_vars_alloc);

    }

  stack_vars[stack_vars_num].decl = decl;

  stack_vars[stack_vars_num].offset = 0;

  stack_vars[stack_vars_num].size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);

  stack_vars[stack_vars_num].alignb = get_decl_align_unit (decl);

  /* All variables are initially in their own partition.  */

  stack_vars[stack_vars_num].representative = stack_vars_num;

  stack_vars[stack_vars_num].next = EOC;

  /* Ensure that this decl doesn't get put onto the list twice.  */

  SET_DECL_RTL (decl, pc_rtx);

  stack_vars_num++;

}

/* Compute the linear index of a lower-triangular coordinate (I, J).  */

static size_t

triangular_index (size_t i, size_t j)

{

  if (i < j)

    {

      size_t t;

      t = i, i = j, j = t;

    }

  return (i * (i + 1)) / 2 + j;

}

/* Ensure that STACK_VARS_CONFLICT is large enough for N objects.  */

static void

resize_stack_vars_conflict (size_t n)

{

  size_t size = triangular_index (n-1, n-1) + 1;

  if (size <= stack_vars_conflict_alloc)

    return;

  stack_vars_conflict = XRESIZEVEC (bool, stack_vars_conflict, size);

  memset (stack_vars_conflict + stack_vars_conflict_alloc, 0,

          (size - stack_vars_conflict_alloc) * sizeof (bool));

  stack_vars_conflict_alloc = size;

}

/* Make the decls associated with luid's X and Y conflict.  */

static void

add_stack_var_conflict (size_t x, size_t y)

{

  size_t index = triangular_index (x, y);

  gcc_assert (index < stack_vars_conflict_alloc);

  stack_vars_conflict[index] = true;

}

/* Check whether the decls associated with luid's X and Y conflict.  */

static bool

stack_var_conflict_p (size_t x, size_t y)

{

  size_t index = triangular_index (x, y);

  gcc_assert (index < stack_vars_conflict_alloc);

  return stack_vars_conflict[index];

}

/* Returns true if TYPE is or contains a union type.  */

static bool

aggregate_contains_union_type (tree type)

{

  tree field;

  if (TREE_CODE (type) == UNION_TYPE

      || TREE_CODE (type) == QUAL_UNION_TYPE)

    return true;

  if (TREE_CODE (type) == ARRAY_TYPE)

    return aggregate_contains_union_type (TREE_TYPE (type));

  if (TREE_CODE (type) != RECORD_TYPE)

    return false;

  for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))

    if (TREE_CODE (field) == FIELD_DECL)

      if (aggregate_contains_union_type (TREE_TYPE (field)))

        return true;

  return false;

}

/* A subroutine of expand_used_vars.  If two variables X and Y have alias

   sets that do not conflict, then do add a conflict for these variables

   in the interference graph.  We also need to make sure to add conflicts

   for union containing structures.  Else RTL alias analysis comes along

   and due to type based aliasing rules decides that for two overlapping

   union temporaries { short s; int i; } accesses to the same mem through

   different types may not alias and happily reorders stores across

   life-time boundaries of the temporaries (See PR25654).

   We also have to mind MEM_IN_STRUCT_P and MEM_SCALAR_P.  */

static void

add_alias_set_conflicts (void)

{

  size_t i, j, n = stack_vars_num;

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

    {

      tree type_i = TREE_TYPE (stack_vars[i].decl);

      bool aggr_i = AGGREGATE_TYPE_P (type_i);

      bool contains_union;

      contains_union = aggregate_contains_union_type (type_i);

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

        {

          tree type_j = TREE_TYPE (stack_vars[j].decl);

          bool aggr_j = AGGREGATE_TYPE_P (type_j);

          if (aggr_i != aggr_j

              /* Either the objects conflict by means of type based

                 aliasing rules, or we need to add a conflict.  */

              || !objects_must_conflict_p (type_i, type_j)

              /* In case the types do not conflict ensure that access

                 to elements will conflict.  In case of unions we have

                 to be careful as type based aliasing rules may say

                 access to the same memory does not conflict.  So play

                 safe and add a conflict in this case.  */

              || contains_union)

            add_stack_var_conflict (i, j);

        }

    }

}

/* A subroutine of partition_stack_vars.  A comparison function for qsort,

   sorting an array of indicies by the size of the object.  */

static int

stack_var_size_cmp (const void *a, const void *b)

{

  HOST_WIDE_INT sa = stack_vars[*(const size_t *)a].size;

  HOST_WIDE_INT sb = stack_vars[*(const size_t *)b].size;

  unsigned int uida = DECL_UID (stack_vars[*(const size_t *)a].decl);

  unsigned int uidb = DECL_UID (stack_vars[*(const size_t *)b].decl);

  if (sa < sb)

    return -1;

  if (sa > sb)

    return 1;

  /* For stack variables of the same size use the uid of the decl

     to make the sort stable.  */

  if (uida < uidb)

    return -1;

  if (uida > uidb)

    return 1;

  return 0;

}

/* A subroutine of partition_stack_vars.  The UNION portion of a UNION/FIND

   partitioning algorithm.  Partitions A and B are known to be non-conflicting.

   Merge them into a single partition A.

   At the same time, add OFFSET to all variables in partition B.  At the end

   of the partitioning process we've have a nice block easy to lay out within

   the stack frame.  */

static void

union_stack_vars (size_t a, size_t b, HOST_WIDE_INT offset)

{

  size_t i, last;

  /* Update each element of partition B with the given offset,

     and merge them into partition A.  */

  for (last = i = b; i != EOC; last = i, i = stack_vars[i].next)

    {

      stack_vars[i].offset += offset;

      stack_vars[i].representative = a;

    }

  stack_vars[last].next = stack_vars[a].next;

  stack_vars[a].next = b;

  /* Update the required alignment of partition A to account for B.  */

  if (stack_vars[a].alignb < stack_vars[b].alignb)

    stack_vars[a].alignb = stack_vars[b].alignb;

  /* Update the interference graph and merge the conflicts.  */

  for (last = stack_vars_num, i = 0; i < last; ++i)

    if (stack_var_conflict_p (b, i))

      add_stack_var_conflict (a, i);

}

/* A subroutine of expand_used_vars.  Binpack the variables into

   partitions constrained by the interference graph.  The overall

   algorithm used is as follows:

        Sort the objects by size.

        For each object A {

          S = size(A)

          O = 0

          loop {

            Look for the largest non-conflicting object B with size <= S.

            UNION (A, B)

            offset(B) = O

            O += size(B)

            S -= size(B)

          }

        }

*/

static void

partition_stack_vars (void)

{

  size_t si, sj, n = stack_vars_num;

  stack_vars_sorted = XNEWVEC (size_t, stack_vars_num);

  for (si = 0; si < n; ++si)

    stack_vars_sorted[si] = si;

  if (n == 1)

    return;

  qsort (stack_vars_sorted, n, sizeof (size_t), stack_var_size_cmp);

  /* Special case: detect when all variables conflict, and thus we can't

     do anything during the partitioning loop.  It isn't uncommon (with

     C code at least) to declare all variables at the top of the function,

     and if we're not inlining, then all variables will be in the same scope.

     Take advantage of very fast libc routines for this scan.  */

  gcc_assert (sizeof(bool) == sizeof(char));

  if (memchr (stack_vars_conflict, false, stack_vars_conflict_alloc) == NULL)

    return;

  for (si = 0; si < n; ++si)

    {

      size_t i = stack_vars_sorted[si];

      HOST_WIDE_INT isize = stack_vars[i].size;

      HOST_WIDE_INT offset = 0;

      for (sj = si; sj-- > 0; )

        {

          size_t j = stack_vars_sorted[sj];

          HOST_WIDE_INT jsize = stack_vars[j].size;

          unsigned int jalign = stack_vars[j].alignb;

          /* Ignore objects that aren't partition representatives.  */

          if (stack_vars[j].representative != j)

            continue;

          /* Ignore objects too large for the remaining space.  */

          if (isize < jsize)

            continue;

          /* Ignore conflicting objects.  */

          if (stack_var_conflict_p (i, j))

            continue;

          /* Refine the remaining space check to include alignment.  */

          if (offset & (jalign - 1))

            {

              HOST_WIDE_INT toff = offset;

              toff += jalign - 1;

              toff &= -(HOST_WIDE_INT)jalign;

              if (isize - (toff - offset) < jsize)

                continue;

              isize -= toff - offset;

              offset = toff;

            }

          /* UNION the objects, placing J at OFFSET.  */

          union_stack_vars (i, j, offset);

          isize -= jsize;

          if (isize == 0)

            break;

        }

    }

}

/* A debugging aid for expand_used_vars.  Dump the generated partitions.  */

static void

dump_stack_var_partition (void)

{

  size_t si, i, j, n = stack_vars_num;

  for (si = 0; si < n; ++si)

    {

      i = stack_vars_sorted[si];

      /* Skip variables that aren't partition representatives, for now.  */

      if (stack_vars[i].representative != i)

        continue;

      fprintf (dump_file, "Partition %lu: size " HOST_WIDE_INT_PRINT_DEC

               " align %u\n", (unsigned long) i, stack_vars[i].size,

               stack_vars[i].alignb);

      for (j = i; j != EOC; j = stack_vars[j].next)

        {

          fputc ('\t', dump_file);

          print_generic_expr (dump_file, stack_vars[j].decl, dump_flags);

          fprintf (dump_file, ", offset " HOST_WIDE_INT_PRINT_DEC "\n",

                   stack_vars[i].offset);

        }

    }

}

/* Assign rtl to DECL at frame offset OFFSET.  */

static void

expand_one_stack_var_at (tree decl, HOST_WIDE_INT offset)

{

  HOST_WIDE_INT align;

  rtx x;

  /* If this fails, we've overflowed the stack frame.  Error nicely?  */

  gcc_assert (offset == trunc_int_for_mode (offset, Pmode));

  x = plus_constant (virtual_stack_vars_rtx, offset);

  x = gen_rtx_MEM (DECL_MODE (decl), x);

  /* Set alignment we actually gave this decl.  */

  offset -= frame_phase;

  align = offset & -offset;

  align *= BITS_PER_UNIT;

  if (align > STACK_BOUNDARY || align == 0)

    align = STACK_BOUNDARY;

  DECL_ALIGN (decl) = align;

  DECL_USER_ALIGN (decl) = 0;

  set_mem_attributes (x, decl, true);

  SET_DECL_RTL (decl, x);

}

/* A subroutine of expand_used_vars.  Give each partition representative

   a unique location within the stack frame.  Update each partition member

   with that location.  */

static void

expand_stack_vars (bool (*pred) (tree))

{

  size_t si, i, j, n = stack_vars_num;

  for (si = 0; si < n; ++si)

    {

      HOST_WIDE_INT offset;

      i = stack_vars_sorted[si];

      /* Skip variables that aren't partition representatives, for now.  */

      if (stack_vars[i].representative != i)

        continue;

      /* Skip variables that have already had rtl assigned.  See also

         add_stack_var where we perpetrate this pc_rtx hack.  */

      if (DECL_RTL (stack_vars[i].decl) != pc_rtx)

        continue;

      /* Check the predicate to see whether this variable should be

         allocated in this pass.  */

      if (pred && !pred (stack_vars[i].decl))

        continue;

      offset = alloc_stack_frame_space (stack_vars[i].size,

                                        stack_vars[i].alignb);

      /* Create rtl for each variable based on their location within the

         partition.  */

      for (j = i; j != EOC; j = stack_vars[j].next)

        expand_one_stack_var_at (stack_vars[j].decl,

                                 stack_vars[j].offset + offset);

    }

}

/* A subroutine of expand_one_var.  Called to immediately assign rtl

   to a variable to be allocated in the stack frame.  */

static void

expand_one_stack_var (tree var)

{

  HOST_WIDE_INT size, offset, align;

  size = tree_low_cst (DECL_SIZE_UNIT (var), 1);

  align = get_decl_align_unit (var);

  offset = alloc_stack_frame_space (size, align);

  expand_one_stack_var_at (var, offset);

}

/* A subroutine of expand_one_var.  Called to assign rtl

   to a TREE_STATIC VAR_DECL.  */

static void

expand_one_static_var (tree var)

{

  /* In unit-at-a-time all the static variables are expanded at the end

     of compilation process.  */

  if (flag_unit_at_a_time)

    return;

  /* If this is an inlined copy of a static local variable,

     look up the original.  */

  var = DECL_ORIGIN (var);

  /* If we've already processed this variable because of that, do nothing.  */

  if (TREE_ASM_WRITTEN (var))

    return;

  /* Give the front end a chance to do whatever.  In practice, this is

     resolving duplicate names for IMA in C.  */

  if (lang_hooks.expand_decl (var))

    return;

  /* Otherwise, just emit the variable.  */

  rest_of_decl_compilation (var, 0, 0);

}

/* A subroutine of expand_one_var.  Called to assign rtl to a VAR_DECL

   that will reside in a hard register.  */

static void

expand_one_hard_reg_var (tree var)

{

  rest_of_decl_compilation (var, 0, 0);

}

/* A subroutine of expand_one_var.  Called to assign rtl to a VAR_DECL

   that will reside in a pseudo register.  */

static void

expand_one_register_var (tree var)

{

  tree type = TREE_TYPE (var);

  int unsignedp = TYPE_UNSIGNED (type);

  enum machine_mode reg_mode

    = promote_mode (type, DECL_MODE (var), &unsignedp, 0);

  rtx x = gen_reg_rtx (reg_mode);

  SET_DECL_RTL (var, x);

  /* Note if the object is a user variable.  */

  if (!DECL_ARTIFICIAL (var))

    {

      mark_user_reg (x);

      /* Trust user variables which have a pointer type to really

         be pointers.  Do not trust compiler generated temporaries

         as our type system is totally busted as it relates to

         pointer arithmetic which translates into lots of compiler

         generated objects with pointer types, but which are not really

         pointers.  */

      if (POINTER_TYPE_P (type))

        mark_reg_pointer (x, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (var))));

    }

}

/* A subroutine of expand_one_var.  Called to assign rtl to a VAR_DECL that

   has some associated error, e.g. its type is error-mark.  We just need

   to pick something that won't crash the rest of the compiler.  */

static void

expand_one_error_var (tree var)

{

  enum machine_mode mode = DECL_MODE (var);

  rtx x;

  if (mode == BLKmode)

    x = gen_rtx_MEM (BLKmode, const0_rtx);

  else if (mode == VOIDmode)

    x = const0_rtx;

  else

    x = gen_reg_rtx (mode);

  SET_DECL_RTL (var, x);

}

/* A subroutine of expand_one_var.  VAR is a variable that will be

   allocated to the local stack frame.  Return true if we wish to

   add VAR to STACK_VARS so that it will be coalesced with other

   variables.  Return false to allocate VAR immediately.

   This function is used to reduce the number of variables considered

   for coalescing, which reduces the size of the quadratic problem.  */

static bool

defer_stack_allocation (tree var, bool toplevel)

{

  /* If stack protection is enabled, *all* stack variables must be deferred,

     so that we can re-order the strings to the top of the frame.  */

  if (flag_stack_protect)

    return true;

  /* Variables in the outermost scope automatically conflict with

     every other variable.  The only reason to want to defer them

     at all is that, after sorting, we can more efficiently pack

     small variables in the stack frame.  Continue to defer at -O2.  */

  if (toplevel && optimize < 2)

    return false;

  /* Without optimization, *most* variables are allocated from the

     stack, which makes the quadratic problem large exactly when we

     want compilation to proceed as quickly as possible.  On the

     other hand, we don't want the function's stack frame size to

     get completely out of hand.  So we avoid adding scalars and

     "small" aggregates to the list at all.  */

  if (optimize == 0 && tree_low_cst (DECL_SIZE_UNIT (var), 1) < 32)