Subversion Repositories openrisc_2011-10-31

/* Expands front end tree to back end RTL for GCC.

   Copyright (C) 1987, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,

   1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 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/>.  */

/* This file handles the generation of rtl code from tree structure

   at the level of the function as a whole.

   It creates the rtl expressions for parameters and auto variables

   and has full responsibility for allocating stack slots.

   `expand_function_start' is called at the beginning of a function,

   before the function body is parsed, and `expand_function_end' is

   called after parsing the body.

   Call `assign_stack_local' to allocate a stack slot for a local variable.

   This is usually done during the RTL generation for the function body,

   but it can also be done in the reload pass when a pseudo-register does

   not get a hard register.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "rtl.h"

#include "tree.h"

#include "flags.h"

#include "except.h"

#include "function.h"

#include "expr.h"

#include "optabs.h"

#include "libfuncs.h"

#include "regs.h"

#include "hard-reg-set.h"

#include "insn-config.h"

#include "recog.h"

#include "output.h"

#include "basic-block.h"

#include "toplev.h"

#include "hashtab.h"

#include "ggc.h"

#include "tm_p.h"

#include "integrate.h"

#include "langhooks.h"

#include "target.h"

#include "cfglayout.h"

#include "tree-gimple.h"

#include "tree-pass.h"

#include "predict.h"

#include "vecprim.h"

#ifndef LOCAL_ALIGNMENT

#define LOCAL_ALIGNMENT(TYPE, ALIGNMENT) ALIGNMENT

#endif

#ifndef STACK_ALIGNMENT_NEEDED

#define STACK_ALIGNMENT_NEEDED 1

#endif

#define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)

/* Some systems use __main in a way incompatible with its use in gcc, in these

   cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to

   give the same symbol without quotes for an alternative entry point.  You

   must define both, or neither.  */

#ifndef NAME__MAIN

#define NAME__MAIN "__main"

#endif

/* Round a value to the lowest integer less than it that is a multiple of

   the required alignment.  Avoid using division in case the value is

   negative.  Assume the alignment is a power of two.  */

#define FLOOR_ROUND(VALUE,ALIGN) ((VALUE) & ~((ALIGN) - 1))

/* Similar, but round to the next highest integer that meets the

   alignment.  */

#define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))

/* Nonzero if function being compiled doesn't contain any calls

   (ignoring the prologue and epilogue).  This is set prior to

   local register allocation and is valid for the remaining

   compiler passes.  */

int current_function_is_leaf;

/* Nonzero if function being compiled doesn't modify the stack pointer

   (ignoring the prologue and epilogue).  This is only valid after

   life_analysis has run.  */

int current_function_sp_is_unchanging;

/* Nonzero if the function being compiled is a leaf function which only

   uses leaf registers.  This is valid after reload (specifically after

   sched2) and is useful only if the port defines LEAF_REGISTERS.  */

int current_function_uses_only_leaf_regs;

/* Nonzero once virtual register instantiation has been done.

   assign_stack_local uses frame_pointer_rtx when this is nonzero.

   calls.c:emit_library_call_value_1 uses it to set up

   post-instantiation libcalls.  */

int virtuals_instantiated;

/* Assign unique numbers to labels generated for profiling, debugging, etc.  */

static GTY(()) int funcdef_no;

/* These variables hold pointers to functions to create and destroy

   target specific, per-function data structures.  */

struct machine_function * (*init_machine_status) (void);

/* The currently compiled function.  */

struct function *cfun = 0;

/* These arrays record the INSN_UIDs of the prologue and epilogue insns.  */

static VEC(int,heap) *prologue;

static VEC(int,heap) *epilogue;

/* Array of INSN_UIDs to hold the INSN_UIDs for each sibcall epilogue

   in this function.  */

static VEC(int,heap) *sibcall_epilogue;

/* In order to evaluate some expressions, such as function calls returning

   structures in memory, we need to temporarily allocate stack locations.

   We record each allocated temporary in the following structure.

   Associated with each temporary slot is a nesting level.  When we pop up

   one level, all temporaries associated with the previous level are freed.

   Normally, all temporaries are freed after the execution of the statement

   in which they were created.  However, if we are inside a ({...}) grouping,

   the result may be in a temporary and hence must be preserved.  If the

   result could be in a temporary, we preserve it if we can determine which

   one it is in.  If we cannot determine which temporary may contain the

   result, all temporaries are preserved.  A temporary is preserved by

   pretending it was allocated at the previous nesting level.

   Automatic variables are also assigned temporary slots, at the nesting

   level where they are defined.  They are marked a "kept" so that

   free_temp_slots will not free them.  */

struct temp_slot GTY(())

{

  /* Points to next temporary slot.  */

  struct temp_slot *next;

  /* Points to previous temporary slot.  */

  struct temp_slot *prev;

  /* The rtx to used to reference the slot.  */

  rtx slot;

  /* The rtx used to represent the address if not the address of the

     slot above.  May be an EXPR_LIST if multiple addresses exist.  */

  rtx address;

  /* The alignment (in bits) of the slot.  */

  unsigned int align;

  /* The size, in units, of the slot.  */

  HOST_WIDE_INT size;

  /* The type of the object in the slot, or zero if it doesn't correspond

     to a type.  We use this to determine whether a slot can be reused.

     It can be reused if objects of the type of the new slot will always

     conflict with objects of the type of the old slot.  */

  tree type;

  /* Nonzero if this temporary is currently in use.  */

  char in_use;

  /* Nonzero if this temporary has its address taken.  */

  char addr_taken;

  /* Nesting level at which this slot is being used.  */

  int level;

  /* Nonzero if this should survive a call to free_temp_slots.  */

  int keep;

  /* The offset of the slot from the frame_pointer, including extra space

     for alignment.  This info is for combine_temp_slots.  */

  HOST_WIDE_INT base_offset;

  /* The size of the slot, including extra space for alignment.  This

     info is for combine_temp_slots.  */

  HOST_WIDE_INT full_size;

};

/* Forward declarations.  */

static rtx assign_stack_local_1 (enum machine_mode, HOST_WIDE_INT, int,

                                 struct function *);

static struct temp_slot *find_temp_slot_from_address (rtx);

static void pad_to_arg_alignment (struct args_size *, int, struct args_size *);

static void pad_below (struct args_size *, enum machine_mode, tree);

static void reorder_blocks_1 (rtx, tree, VEC(tree,heap) **);

static int all_blocks (tree, tree *);

static tree *get_block_vector (tree, int *);

extern tree debug_find_var_in_block_tree (tree, tree);

/* We always define `record_insns' even if it's not used so that we

   can always export `prologue_epilogue_contains'.  */

static void record_insns (rtx, VEC(int,heap) **) ATTRIBUTE_UNUSED;

static int contains (rtx, VEC(int,heap) **);

#ifdef HAVE_return

static void emit_return_into_block (basic_block, rtx);

#endif

#if defined(HAVE_epilogue) && defined(INCOMING_RETURN_ADDR_RTX)

static rtx keep_stack_depressed (rtx);

#endif

static void prepare_function_start (tree);

static void do_clobber_return_reg (rtx, void *);

static void do_use_return_reg (rtx, void *);

static void set_insn_locators (rtx, int) ATTRIBUTE_UNUSED;

/* Pointer to chain of `struct function' for containing functions.  */

struct function *outer_function_chain;

/* Given a function decl for a containing function,

   return the `struct function' for it.  */

struct function *

find_function_data (tree decl)

{

  struct function *p;

  for (p = outer_function_chain; p; p = p->outer)

    if (p->decl == decl)

      return p;

  gcc_unreachable ();

}

/* Save the current context for compilation of a nested function.

   This is called from language-specific code.  The caller should use

   the enter_nested langhook to save any language-specific state,

   since this function knows only about language-independent

   variables.  */

void

push_function_context_to (tree context ATTRIBUTE_UNUSED)

{

  struct function *p;

  if (cfun == 0)

    init_dummy_function_start ();

  p = cfun;

  p->outer = outer_function_chain;

  outer_function_chain = p;

  lang_hooks.function.enter_nested (p);

  cfun = 0;

}

void

push_function_context (void)

{

  push_function_context_to (current_function_decl);

}

/* Restore the last saved context, at the end of a nested function.

   This function is called from language-specific code.  */

void

pop_function_context_from (tree context ATTRIBUTE_UNUSED)

{

  struct function *p = outer_function_chain;

  cfun = p;

  outer_function_chain = p->outer;

  current_function_decl = p->decl;

  lang_hooks.function.leave_nested (p);

  /* Reset variables that have known state during rtx generation.  */

  virtuals_instantiated = 0;

  generating_concat_p = 1;

}

void

pop_function_context (void)

{

  pop_function_context_from (current_function_decl);

}

/* Clear out all parts of the state in F that can safely be discarded

   after the function has been parsed, but not compiled, to let

   garbage collection reclaim the memory.  */

void

free_after_parsing (struct function *f)

{

  /* f->expr->forced_labels is used by code generation.  */

  /* f->emit->regno_reg_rtx is used by code generation.  */

  /* f->varasm is used by code generation.  */

  /* f->eh->eh_return_stub_label is used by code generation.  */

  lang_hooks.function.final (f);

}

/* Clear out all parts of the state in F that can safely be discarded

   after the function has been compiled, to let garbage collection

   reclaim the memory.  */

void

free_after_compilation (struct function *f)

{

  VEC_free (int, heap, prologue);

  VEC_free (int, heap, epilogue);

  VEC_free (int, heap, sibcall_epilogue);

  f->eh = NULL;

  f->expr = NULL;

  f->emit = NULL;

  f->varasm = NULL;

  f->machine = NULL;

  f->cfg = NULL;

  f->x_avail_temp_slots = NULL;

  f->x_used_temp_slots = NULL;

  f->arg_offset_rtx = NULL;

  f->return_rtx = NULL;

  f->internal_arg_pointer = NULL;

  f->x_nonlocal_goto_handler_labels = NULL;

  f->x_return_label = NULL;

  f->x_naked_return_label = NULL;

  f->x_stack_slot_list = NULL;

  f->x_stack_check_probe_note = NULL;

  f->x_arg_pointer_save_area = NULL;

  f->x_parm_birth_insn = NULL;

  f->epilogue_delay_list = NULL;

}

/* Allocate fixed slots in the stack frame of the current function.  */

/* Return size needed for stack frame based on slots so far allocated in

   function F.

   This size counts from zero.  It is not rounded to PREFERRED_STACK_BOUNDARY;

   the caller may have to do that.  */

static HOST_WIDE_INT

get_func_frame_size (struct function *f)

{

  if (FRAME_GROWS_DOWNWARD)

    return -f->x_frame_offset;

  else

    return f->x_frame_offset;

}

/* Return size needed for stack frame based on slots so far allocated.

   This size counts from zero.  It is not rounded to PREFERRED_STACK_BOUNDARY;

   the caller may have to do that.  */

HOST_WIDE_INT

get_frame_size (void)

{

  return get_func_frame_size (cfun);

}

/* Issue an error message and return TRUE if frame OFFSET overflows in

   the signed target pointer arithmetics for function FUNC.  Otherwise

   return FALSE.  */

bool

frame_offset_overflow (HOST_WIDE_INT offset, tree func)

{

  unsigned HOST_WIDE_INT size = FRAME_GROWS_DOWNWARD ? -offset : offset;

  if (size > ((unsigned HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE (Pmode) - 1))

               /* Leave room for the fixed part of the frame.  */

               - 64 * UNITS_PER_WORD)

    {

      error ("%Jtotal size of local objects too large", func);

      return TRUE;

    }

  return FALSE;

}

/* Allocate a stack slot of SIZE bytes and return a MEM rtx for it

   with machine mode MODE.

   ALIGN controls the amount of alignment for the address of the slot:

   -1 means use BIGGEST_ALIGNMENT and round size to multiple of that,

   -2 means use BITS_PER_UNIT,

   positive specifies alignment boundary in bits.

   We do not round to stack_boundary here.

   FUNCTION specifies the function to allocate in.  */

static rtx

assign_stack_local_1 (enum machine_mode mode, HOST_WIDE_INT size, int align,

                      struct function *function)

{

  rtx x, addr;

  int bigend_correction = 0;

  unsigned int alignment;

  int frame_off, frame_alignment, frame_phase;

  if (align == 0)

    {

      tree type;

      if (mode == BLKmode)

        alignment = BIGGEST_ALIGNMENT;

      else

        alignment = GET_MODE_ALIGNMENT (mode);

      /* Allow the target to (possibly) increase the alignment of this

         stack slot.  */

      type = lang_hooks.types.type_for_mode (mode, 0);

      if (type)

        alignment = LOCAL_ALIGNMENT (type, alignment);

      alignment /= BITS_PER_UNIT;

    }

  else if (align == -1)

    {

      alignment = BIGGEST_ALIGNMENT / BITS_PER_UNIT;

      size = CEIL_ROUND (size, alignment);

    }

  else if (align == -2)

    alignment = 1; /* BITS_PER_UNIT / BITS_PER_UNIT */

  else

    alignment = align / BITS_PER_UNIT;

  if (FRAME_GROWS_DOWNWARD)

    function->x_frame_offset -= size;

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

  if (alignment * BITS_PER_UNIT > PREFERRED_STACK_BOUNDARY)

    alignment = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;

  if (function->stack_alignment_needed < alignment * BITS_PER_UNIT)

    function->stack_alignment_needed = alignment * BITS_PER_UNIT;

  /* Calculate how many bytes the start of local variables is off from

     stack alignment.  */

  frame_alignment = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;

  frame_off = STARTING_FRAME_OFFSET % frame_alignment;

  frame_phase = frame_off ? frame_alignment - frame_off : 0;

  /* Round the frame offset to the specified alignment.  The default is

     to always honor requests to align the stack but a port may choose to

     do its own stack alignment by defining STACK_ALIGNMENT_NEEDED.  */

  if (STACK_ALIGNMENT_NEEDED

      || mode != BLKmode

      || size != 0)

    {

      /*  We must be careful here, since FRAME_OFFSET might be negative and

          division with a negative dividend isn't as well defined as we might

          like.  So we instead assume that ALIGNMENT is a power of two and

          use logical operations which are unambiguous.  */

      if (FRAME_GROWS_DOWNWARD)

        function->x_frame_offset

          = (FLOOR_ROUND (function->x_frame_offset - frame_phase,

                          (unsigned HOST_WIDE_INT) alignment)

             + frame_phase);

      else

        function->x_frame_offset

          = (CEIL_ROUND (function->x_frame_offset - frame_phase,

                         (unsigned HOST_WIDE_INT) alignment)

             + frame_phase);

    }

  /* On a big-endian machine, if we are allocating more space than we will use,

     use the least significant bytes of those that are allocated.  */

  if (BYTES_BIG_ENDIAN && mode != BLKmode && GET_MODE_SIZE (mode) < size)

    bigend_correction = size - GET_MODE_SIZE (mode);

  /* If we have already instantiated virtual registers, return the actual

     address relative to the frame pointer.  */

  if (function == cfun && virtuals_instantiated)

    addr = plus_constant (frame_pointer_rtx,

                          trunc_int_for_mode

                          (frame_offset + bigend_correction

                           + STARTING_FRAME_OFFSET, Pmode));

  else

    addr = plus_constant (virtual_stack_vars_rtx,

                          trunc_int_for_mode

                          (function->x_frame_offset + bigend_correction,

                           Pmode));

  if (!FRAME_GROWS_DOWNWARD)

    function->x_frame_offset += size;

  x = gen_rtx_MEM (mode, addr);

  MEM_NOTRAP_P (x) = 1;

  function->x_stack_slot_list

    = gen_rtx_EXPR_LIST (VOIDmode, x, function->x_stack_slot_list);

  if (frame_offset_overflow (function->x_frame_offset, function->decl))

    function->x_frame_offset = 0;

  return x;

}

/* Wrapper around assign_stack_local_1;  assign a local stack slot for the

   current function.  */

rtx

assign_stack_local (enum machine_mode mode, HOST_WIDE_INT size, int align)

{

  return assign_stack_local_1 (mode, size, align, cfun);

}

/* Removes temporary slot TEMP from LIST.  */

static void

cut_slot_from_list (struct temp_slot *temp, struct temp_slot **list)

{

  if (temp->next)

    temp->next->prev = temp->prev;

  if (temp->prev)

    temp->prev->next = temp->next;

  else

    *list = temp->next;

  temp->prev = temp->next = NULL;

}

/* Inserts temporary slot TEMP to LIST.  */

static void

insert_slot_to_list (struct temp_slot *temp, struct temp_slot **list)

{

  temp->next = *list;

  if (*list)

    (*list)->prev = temp;

  temp->prev = NULL;

  *list = temp;

}

/* Returns the list of used temp slots at LEVEL.  */

static struct temp_slot **

temp_slots_at_level (int level)

{

  if (level >= (int) VEC_length (temp_slot_p, used_temp_slots))

    {

      size_t old_length = VEC_length (temp_slot_p, used_temp_slots);

      temp_slot_p *p;

      VEC_safe_grow (temp_slot_p, gc, used_temp_slots, level + 1);

      p = VEC_address (temp_slot_p, used_temp_slots);

      memset (&p[old_length], 0,

              sizeof (temp_slot_p) * (level + 1 - old_length));

    }

  return &(VEC_address (temp_slot_p, used_temp_slots)[level]);

}

/* Returns the maximal temporary slot level.  */

static int

max_slot_level (void)

{

  if (!used_temp_slots)

    return -1;

  return VEC_length (temp_slot_p, used_temp_slots) - 1;

}

/* Moves temporary slot TEMP to LEVEL.  */

static void

move_slot_to_level (struct temp_slot *temp, int level)

{

  cut_slot_from_list (temp, temp_slots_at_level (temp->level));

  insert_slot_to_list (temp, temp_slots_at_level (level));

  temp->level = level;

}

/* Make temporary slot TEMP available.  */

static void

make_slot_available (struct temp_slot *temp)

{

  cut_slot_from_list (temp, temp_slots_at_level (temp->level));

  insert_slot_to_list (temp, &avail_temp_slots);

  temp->in_use = 0;

  temp->level = -1;

}

/* Allocate a temporary stack slot and record it for possible later

   reuse.

   MODE is the machine mode to be given to the returned rtx.

   SIZE is the size in units of the space required.  We do no rounding here

   since assign_stack_local will do any required rounding.

   KEEP is 1 if this slot is to be retained after a call to

   free_temp_slots.  Automatic variables for a block are allocated

   with this flag.  KEEP values of 2 or 3 were needed respectively

   for variables whose lifetime is controlled by CLEANUP_POINT_EXPRs

   or for SAVE_EXPRs, but they are now unused.

   TYPE is the type that will be used for the stack slot.  */

rtx

assign_stack_temp_for_type (enum machine_mode mode, HOST_WIDE_INT size,

                            int keep, tree type)

{

  unsigned int align;

  struct temp_slot *p, *best_p = 0, *selected = NULL, **pp;

  rtx slot;

  /* If SIZE is -1 it means that somebody tried to allocate a temporary

     of a variable size.  */

  gcc_assert (size != -1);

  /* These are now unused.  */

  gcc_assert (keep <= 1);

  if (mode == BLKmode)

    align = BIGGEST_ALIGNMENT;

  else

    align = GET_MODE_ALIGNMENT (mode);

  if (! type)

    type = lang_hooks.types.type_for_mode (mode, 0);

  if (type)

    align = LOCAL_ALIGNMENT (type, align);

  /* Try to find an available, already-allocated temporary of the proper

     mode which meets the size and alignment requirements.  Choose the

     smallest one with the closest alignment.

     If assign_stack_temp is called outside of the tree->rtl expansion,

     we cannot reuse the stack slots (that may still refer to

     VIRTUAL_STACK_VARS_REGNUM).  */

  if (!virtuals_instantiated)

    {

      for (p = avail_temp_slots; p; p = p->next)

        {

          if (p->align >= align && p->size >= size

              && GET_MODE (p->slot) == mode

              && objects_must_conflict_p (p->type, type)

              && (best_p == 0 || best_p->size > p->size

                  || (best_p->size == p->size && best_p->align > p->align)))

            {

              if (p->align == align && p->size == size)

                {

                  selected = p;

                  cut_slot_from_list (selected, &avail_temp_slots);

                  best_p = 0;

                  break;

                }

              best_p = p;

            }

        }

    }

  /* Make our best, if any, the one to use.  */

  if (best_p)

    {

      selected = best_p;

      cut_slot_from_list (selected, &avail_temp_slots);

      /* If there are enough aligned bytes left over, make them into a new

         temp_slot so that the extra bytes don't get wasted.  Do this only

         for BLKmode slots, so that we can be sure of the alignment.  */

      if (GET_MODE (best_p->slot) == BLKmode)

        {

          int alignment = best_p->align / BITS_PER_UNIT;

          HOST_WIDE_INT rounded_size = CEIL_ROUND (size, alignment);

          if (best_p->size - rounded_size >= alignment)

            {

              p = ggc_alloc (sizeof (struct temp_slot));

              p->in_use = p->addr_taken = 0;

              p->size = best_p->size - rounded_size;

              p->base_offset = best_p->base_offset + rounded_size;

              p->full_size = best_p->full_size - rounded_size;

              p->slot = adjust_address_nv (best_p->slot, BLKmode, rounded_size);

              p->align = best_p->align;

              p->address = 0;

              p->type = best_p->type;

              insert_slot_to_list (p, &avail_temp_slots);

              stack_slot_list = gen_rtx_EXPR_LIST (VOIDmode, p->slot,

                                                   stack_slot_list);

              best_p->size = rounded_size;

              best_p->full_size = rounded_size;

            }

        }

    }

  /* If we still didn't find one, make a new temporary.  */

  if (selected == 0)

    {

      HOST_WIDE_INT frame_offset_old = frame_offset;

      p = ggc_alloc (sizeof (struct temp_slot));

      /* We are passing an explicit alignment request to assign_stack_local.

         One side effect of that is assign_stack_local will not round SIZE

         to ensure the frame offset remains suitably aligned.

         So for requests which depended on the rounding of SIZE, we go ahead

         and round it now.  We also make sure ALIGNMENT is at least

         BIGGEST_ALIGNMENT.  */

      gcc_assert (mode != BLKmode || align == BIGGEST_ALIGNMENT);

      p->slot = assign_stack_local (mode,

                                    (mode == BLKmode

                                     ? CEIL_ROUND (size, (int) align / BITS_PER_UNIT)

                                     : size),

                                    align);

      p->align = align;

      /* The following slot size computation is necessary because we don't

         know the actual size of the temporary slot until assign_stack_local

         has performed all the frame alignment and size rounding for the

         requested temporary.  Note that extra space added for alignment

         can be either above or below this stack slot depending on which

         way the frame grows.  We include the extra space if and only if it

         is above this slot.  */

      if (FRAME_GROWS_DOWNWARD)

        p->size = frame_offset_old - frame_offset;

      else

        p->size = size;

      /* Now define the fields used by combine_temp_slots.  */

      if (FRAME_GROWS_DOWNWARD)

        {