Subversion Repositories scarts

/* "Bag-of-pages" garbage collector for the GNU compiler.

   Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005

   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 2, 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 COPYING.  If not, write to the Free

Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA

02110-1301, USA.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "tree.h"

#include "rtl.h"

#include "tm_p.h"

#include "toplev.h"

#include "flags.h"

#include "ggc.h"

#include "timevar.h"

#include "params.h"

#include "tree-flow.h"

#ifdef ENABLE_VALGRIND_CHECKING

# ifdef HAVE_VALGRIND_MEMCHECK_H

#  include <valgrind/memcheck.h>

# elif defined HAVE_MEMCHECK_H

#  include <memcheck.h>

# else

#  include <valgrind.h>

# endif

#else

/* Avoid #ifdef:s when we can help it.  */

#define VALGRIND_DISCARD(x)

#endif

/* Prefer MAP_ANON(YMOUS) to /dev/zero, since we don't need to keep a

   file open.  Prefer either to valloc.  */

#ifdef HAVE_MMAP_ANON

# undef HAVE_MMAP_DEV_ZERO

# include <sys/mman.h>

# ifndef MAP_FAILED

#  define MAP_FAILED -1

# endif

# if !defined (MAP_ANONYMOUS) && defined (MAP_ANON)

#  define MAP_ANONYMOUS MAP_ANON

# endif

# define USING_MMAP

#endif

#ifdef HAVE_MMAP_DEV_ZERO

# include <sys/mman.h>

# ifndef MAP_FAILED

#  define MAP_FAILED -1

# endif

# define USING_MMAP

#endif

#ifndef USING_MMAP

#define USING_MALLOC_PAGE_GROUPS

#endif

/* Strategy:

   This garbage-collecting allocator allocates objects on one of a set

   of pages.  Each page can allocate objects of a single size only;

   available sizes are powers of two starting at four bytes.  The size

   of an allocation request is rounded up to the next power of two

   (`order'), and satisfied from the appropriate page.

   Each page is recorded in a page-entry, which also maintains an

   in-use bitmap of object positions on the page.  This allows the

   allocation state of a particular object to be flipped without

   touching the page itself.

   Each page-entry also has a context depth, which is used to track

   pushing and popping of allocation contexts.  Only objects allocated

   in the current (highest-numbered) context may be collected.

   Page entries are arranged in an array of singly-linked lists.  The

   array is indexed by the allocation size, in bits, of the pages on

   it; i.e. all pages on a list allocate objects of the same size.

   Pages are ordered on the list such that all non-full pages precede

   all full pages, with non-full pages arranged in order of decreasing

   context depth.

   Empty pages (of all orders) are kept on a single page cache list,

   and are considered first when new pages are required; they are

   deallocated at the start of the next collection if they haven't

   been recycled by then.  */

/* Define GGC_DEBUG_LEVEL to print debugging information.

     0: No debugging output.

     1: GC statistics only.

     2: Page-entry allocations/deallocations as well.

     3: Object allocations as well.

     4: Object marks as well.  */

#define GGC_DEBUG_LEVEL (0)

#ifndef HOST_BITS_PER_PTR

#define HOST_BITS_PER_PTR  HOST_BITS_PER_LONG

#endif

/* A two-level tree is used to look up the page-entry for a given

   pointer.  Two chunks of the pointer's bits are extracted to index

   the first and second levels of the tree, as follows:

                                   HOST_PAGE_SIZE_BITS

                           32           |      |

       msb +----------------+----+------+------+ lsb

                            |    |      |

                         PAGE_L1_BITS   |

                                 |      |

                               PAGE_L2_BITS

   The bottommost HOST_PAGE_SIZE_BITS are ignored, since page-entry

   pages are aligned on system page boundaries.  The next most

   significant PAGE_L2_BITS and PAGE_L1_BITS are the second and first

   index values in the lookup table, respectively.

   For 32-bit architectures and the settings below, there are no

   leftover bits.  For architectures with wider pointers, the lookup

   tree points to a list of pages, which must be scanned to find the

   correct one.  */

#define PAGE_L1_BITS    (8)

#define PAGE_L2_BITS    (32 - PAGE_L1_BITS - G.lg_pagesize)

#define PAGE_L1_SIZE    ((size_t) 1 << PAGE_L1_BITS)

#define PAGE_L2_SIZE    ((size_t) 1 << PAGE_L2_BITS)

#define LOOKUP_L1(p) \

  (((size_t) (p) >> (32 - PAGE_L1_BITS)) & ((1 << PAGE_L1_BITS) - 1))

#define LOOKUP_L2(p) \

  (((size_t) (p) >> G.lg_pagesize) & ((1 << PAGE_L2_BITS) - 1))

/* The number of objects per allocation page, for objects on a page of

   the indicated ORDER.  */

#define OBJECTS_PER_PAGE(ORDER) objects_per_page_table[ORDER]

/* The number of objects in P.  */

#define OBJECTS_IN_PAGE(P) ((P)->bytes / OBJECT_SIZE ((P)->order))

/* The size of an object on a page of the indicated ORDER.  */

#define OBJECT_SIZE(ORDER) object_size_table[ORDER]

/* For speed, we avoid doing a general integer divide to locate the

   offset in the allocation bitmap, by precalculating numbers M, S

   such that (O * M) >> S == O / Z (modulo 2^32), for any offset O

   within the page which is evenly divisible by the object size Z.  */

#define DIV_MULT(ORDER) inverse_table[ORDER].mult

#define DIV_SHIFT(ORDER) inverse_table[ORDER].shift

#define OFFSET_TO_BIT(OFFSET, ORDER) \

  (((OFFSET) * DIV_MULT (ORDER)) >> DIV_SHIFT (ORDER))

/* The number of extra orders, not corresponding to power-of-two sized

   objects.  */

#define NUM_EXTRA_ORDERS ARRAY_SIZE (extra_order_size_table)

#define RTL_SIZE(NSLOTS) \

  (RTX_HDR_SIZE + (NSLOTS) * sizeof (rtunion))

#define TREE_EXP_SIZE(OPS) \

  (sizeof (struct tree_exp) + ((OPS) - 1) * sizeof (tree))

/* The Ith entry is the maximum size of an object to be stored in the

   Ith extra order.  Adding a new entry to this array is the *only*

   thing you need to do to add a new special allocation size.  */

static const size_t extra_order_size_table[] = {

  sizeof (struct stmt_ann_d),

  sizeof (struct tree_decl_non_common),

  sizeof (struct tree_field_decl),

  sizeof (struct tree_parm_decl),

  sizeof (struct tree_var_decl),

  sizeof (struct tree_list),

  TREE_EXP_SIZE (2),

  RTL_SIZE (2),                 /* MEM, PLUS, etc.  */

  RTL_SIZE (9),                 /* INSN */

};

/* The total number of orders.  */

#define NUM_ORDERS (HOST_BITS_PER_PTR + NUM_EXTRA_ORDERS)

/* We use this structure to determine the alignment required for

   allocations.  For power-of-two sized allocations, that's not a

   problem, but it does matter for odd-sized allocations.  */

struct max_alignment {

  char c;

  union {

    HOST_WIDEST_INT i;

    long double d;

  } u;

};

/* The biggest alignment required.  */

#define MAX_ALIGNMENT (offsetof (struct max_alignment, u))

/* Compute the smallest nonnegative number which when added to X gives

   a multiple of F.  */

#define ROUND_UP_VALUE(x, f) ((f) - 1 - ((f) - 1 + (x)) % (f))

/* Compute the smallest multiple of F that is >= X.  */

#define ROUND_UP(x, f) (CEIL (x, f) * (f))

/* The Ith entry is the number of objects on a page or order I.  */

static unsigned objects_per_page_table[NUM_ORDERS];

/* The Ith entry is the size of an object on a page of order I.  */

static size_t object_size_table[NUM_ORDERS];

/* The Ith entry is a pair of numbers (mult, shift) such that

   ((k * mult) >> shift) mod 2^32 == (k / OBJECT_SIZE(I)) mod 2^32,

   for all k evenly divisible by OBJECT_SIZE(I).  */

static struct

{

  size_t mult;

  unsigned int shift;

}

inverse_table[NUM_ORDERS];

/* A page_entry records the status of an allocation page.  This

   structure is dynamically sized to fit the bitmap in_use_p.  */

typedef struct page_entry

{

  /* The next page-entry with objects of the same size, or NULL if

     this is the last page-entry.  */

  struct page_entry *next;

  /* The previous page-entry with objects of the same size, or NULL if

     this is the first page-entry.   The PREV pointer exists solely to

     keep the cost of ggc_free manageable.  */

  struct page_entry *prev;

  /* The number of bytes allocated.  (This will always be a multiple

     of the host system page size.)  */

  size_t bytes;

  /* The address at which the memory is allocated.  */

  char *page;

#ifdef USING_MALLOC_PAGE_GROUPS

  /* Back pointer to the page group this page came from.  */

  struct page_group *group;

#endif

  /* This is the index in the by_depth varray where this page table

     can be found.  */

  unsigned long index_by_depth;

  /* Context depth of this page.  */

  unsigned short context_depth;

  /* The number of free objects remaining on this page.  */

  unsigned short num_free_objects;

  /* A likely candidate for the bit position of a free object for the

     next allocation from this page.  */

  unsigned short next_bit_hint;

  /* The lg of size of objects allocated from this page.  */

  unsigned char order;

  /* A bit vector indicating whether or not objects are in use.  The

     Nth bit is one if the Nth object on this page is allocated.  This

     array is dynamically sized.  */

  unsigned long in_use_p[1];

} page_entry;

#ifdef USING_MALLOC_PAGE_GROUPS

/* A page_group describes a large allocation from malloc, from which

   we parcel out aligned pages.  */

typedef struct page_group

{

  /* A linked list of all extant page groups.  */

  struct page_group *next;

  /* The address we received from malloc.  */

  char *allocation;

  /* The size of the block.  */

  size_t alloc_size;

  /* A bitmask of pages in use.  */

  unsigned int in_use;

} page_group;

#endif

#if HOST_BITS_PER_PTR <= 32

/* On 32-bit hosts, we use a two level page table, as pictured above.  */

typedef page_entry **page_table[PAGE_L1_SIZE];

#else

/* On 64-bit hosts, we use the same two level page tables plus a linked

   list that disambiguates the top 32-bits.  There will almost always be

   exactly one entry in the list.  */

typedef struct page_table_chain

{

  struct page_table_chain *next;

  size_t high_bits;

  page_entry **table[PAGE_L1_SIZE];

} *page_table;

#endif

/* The rest of the global variables.  */

static struct globals

{

  /* The Nth element in this array is a page with objects of size 2^N.

     If there are any pages with free objects, they will be at the

     head of the list.  NULL if there are no page-entries for this

     object size.  */

  page_entry *pages[NUM_ORDERS];

  /* The Nth element in this array is the last page with objects of

     size 2^N.  NULL if there are no page-entries for this object

     size.  */

  page_entry *page_tails[NUM_ORDERS];

  /* Lookup table for associating allocation pages with object addresses.  */

  page_table lookup;

  /* The system's page size.  */

  size_t pagesize;

  size_t lg_pagesize;

  /* Bytes currently allocated.  */

  size_t allocated;

  /* Bytes currently allocated at the end of the last collection.  */

  size_t allocated_last_gc;

  /* Total amount of memory mapped.  */

  size_t bytes_mapped;

  /* Bit N set if any allocations have been done at context depth N.  */

  unsigned long context_depth_allocations;

  /* Bit N set if any collections have been done at context depth N.  */

  unsigned long context_depth_collections;

  /* The current depth in the context stack.  */

  unsigned short context_depth;

  /* A file descriptor open to /dev/zero for reading.  */

#if defined (HAVE_MMAP_DEV_ZERO)

  int dev_zero_fd;

#endif

  /* A cache of free system pages.  */

  page_entry *free_pages;

#ifdef USING_MALLOC_PAGE_GROUPS

  page_group *page_groups;

#endif

  /* The file descriptor for debugging output.  */

  FILE *debug_file;

  /* Current number of elements in use in depth below.  */

  unsigned int depth_in_use;

  /* Maximum number of elements that can be used before resizing.  */

  unsigned int depth_max;

  /* Each element of this arry is an index in by_depth where the given

     depth starts.  This structure is indexed by that given depth we

     are interested in.  */

  unsigned int *depth;

  /* Current number of elements in use in by_depth below.  */

  unsigned int by_depth_in_use;

  /* Maximum number of elements that can be used before resizing.  */

  unsigned int by_depth_max;

  /* Each element of this array is a pointer to a page_entry, all

     page_entries can be found in here by increasing depth.

     index_by_depth in the page_entry is the index into this data

     structure where that page_entry can be found.  This is used to

     speed up finding all page_entries at a particular depth.  */

  page_entry **by_depth;

  /* Each element is a pointer to the saved in_use_p bits, if any,

     zero otherwise.  We allocate them all together, to enable a

     better runtime data access pattern.  */

  unsigned long **save_in_use;

#ifdef ENABLE_GC_ALWAYS_COLLECT

  /* List of free objects to be verified as actually free on the

     next collection.  */

  struct free_object

  {

    void *object;

    struct free_object *next;

  } *free_object_list;

#endif

#ifdef GATHER_STATISTICS

  struct

  {

    /* Total memory allocated with ggc_alloc.  */

    unsigned long long total_allocated;

    /* Total overhead for memory to be allocated with ggc_alloc.  */

    unsigned long long total_overhead;

    /* Total allocations and overhead for sizes less than 32, 64 and 128.

       These sizes are interesting because they are typical cache line

       sizes.  */

    unsigned long long total_allocated_under32;

    unsigned long long total_overhead_under32;

    unsigned long long total_allocated_under64;

    unsigned long long total_overhead_under64;

    unsigned long long total_allocated_under128;

    unsigned long long total_overhead_under128;

    /* The allocations for each of the allocation orders.  */

    unsigned long long total_allocated_per_order[NUM_ORDERS];

    /* The overhead for each of the allocation orders.  */

    unsigned long long total_overhead_per_order[NUM_ORDERS];

  } stats;

#endif

} G;

/* The size in bytes required to maintain a bitmap for the objects

   on a page-entry.  */

#define BITMAP_SIZE(Num_objects) \

  (CEIL ((Num_objects), HOST_BITS_PER_LONG) * sizeof(long))

/* Allocate pages in chunks of this size, to throttle calls to memory

   allocation routines.  The first page is used, the rest go onto the

   free list.  This cannot be larger than HOST_BITS_PER_INT for the

   in_use bitmask for page_group.  Hosts that need a different value

   can override this by defining GGC_QUIRE_SIZE explicitly.  */

#ifndef GGC_QUIRE_SIZE

# ifdef USING_MMAP

#  define GGC_QUIRE_SIZE 256

# else

#  define GGC_QUIRE_SIZE 16

# endif

#endif

/* Initial guess as to how many page table entries we might need.  */

#define INITIAL_PTE_COUNT 128

static int ggc_allocated_p (const void *);

static page_entry *lookup_page_table_entry (const void *);

static void set_page_table_entry (void *, page_entry *);

#ifdef USING_MMAP

static char *alloc_anon (char *, size_t);

#endif

#ifdef USING_MALLOC_PAGE_GROUPS

static size_t page_group_index (char *, char *);

static void set_page_group_in_use (page_group *, char *);

static void clear_page_group_in_use (page_group *, char *);

#endif

static struct page_entry * alloc_page (unsigned);

static void free_page (struct page_entry *);

static void release_pages (void);

static void clear_marks (void);

static void sweep_pages (void);

static void ggc_recalculate_in_use_p (page_entry *);

static void compute_inverse (unsigned);

static inline void adjust_depth (void);

static void move_ptes_to_front (int, int);

void debug_print_page_list (int);

static void push_depth (unsigned int);

static void push_by_depth (page_entry *, unsigned long *);

/* Push an entry onto G.depth.  */

inline static void

push_depth (unsigned int i)

{

  if (G.depth_in_use >= G.depth_max)

    {

      G.depth_max *= 2;

      G.depth = xrealloc (G.depth, G.depth_max * sizeof (unsigned int));

    }

  G.depth[G.depth_in_use++] = i;

}

/* Push an entry onto G.by_depth and G.save_in_use.  */

inline static void

push_by_depth (page_entry *p, unsigned long *s)

{

  if (G.by_depth_in_use >= G.by_depth_max)

    {

      G.by_depth_max *= 2;

      G.by_depth = xrealloc (G.by_depth,

                             G.by_depth_max * sizeof (page_entry *));

      G.save_in_use = xrealloc (G.save_in_use,

                                G.by_depth_max * sizeof (unsigned long *));

    }

  G.by_depth[G.by_depth_in_use] = p;

  G.save_in_use[G.by_depth_in_use++] = s;

}

#if (GCC_VERSION < 3001)

#define prefetch(X) ((void) X)

#else

#define prefetch(X) __builtin_prefetch (X)

#endif

#define save_in_use_p_i(__i) \

  (G.save_in_use[__i])

#define save_in_use_p(__p) \

  (save_in_use_p_i (__p->index_by_depth))

/* Returns nonzero if P was allocated in GC'able memory.  */

static inline int

ggc_allocated_p (const void *p)

{

  page_entry ***base;

  size_t L1, L2;

#if HOST_BITS_PER_PTR <= 32

  base = &G.lookup[0];

#else

  page_table table = G.lookup;

  size_t high_bits = (size_t) p & ~ (size_t) 0xffffffff;

  while (1)

    {

      if (table == NULL)

        return 0;

      if (table->high_bits == high_bits)

        break;

      table = table->next;

    }

  base = &table->table[0];

#endif

  /* Extract the level 1 and 2 indices.  */

  L1 = LOOKUP_L1 (p);

  L2 = LOOKUP_L2 (p);

  return base[L1] && base[L1][L2];

}

/* Traverse the page table and find the entry for a page.

   Die (probably) if the object wasn't allocated via GC.  */

static inline page_entry *

lookup_page_table_entry (const void *p)

{

  page_entry ***base;

  size_t L1, L2;

#if HOST_BITS_PER_PTR <= 32

  base = &G.lookup[0];

#else

  page_table table = G.lookup;

  size_t high_bits = (size_t) p & ~ (size_t) 0xffffffff;

  while (table->high_bits != high_bits)

    table = table->next;

  base = &table->table[0];

#endif

  /* Extract the level 1 and 2 indices.  */

  L1 = LOOKUP_L1 (p);

  L2 = LOOKUP_L2 (p);

  return base[L1][L2];

}

/* Set the page table entry for a page.  */

static void

set_page_table_entry (void *p, page_entry *entry)

{

  page_entry ***base;

  size_t L1, L2;

#if HOST_BITS_PER_PTR <= 32

  base = &G.lookup[0];

#else

  page_table table;

  size_t high_bits = (size_t) p & ~ (size_t) 0xffffffff;

  for (table = G.lookup; table; table = table->next)

    if (table->high_bits == high_bits)

      goto found;

  /* Not found -- allocate a new table.  */

  table = xcalloc (1, sizeof(*table));

  table->next = G.lookup;

  table->high_bits = high_bits;

  G.lookup = table;

found:

  base = &table->table[0];

#endif

  /* Extract the level 1 and 2 indices.  */

  L1 = LOOKUP_L1 (p);

  L2 = LOOKUP_L2 (p);

  if (base[L1] == NULL)

    base[L1] = xcalloc (PAGE_L2_SIZE, sizeof (page_entry *));

  base[L1][L2] = entry;

}

/* Prints the page-entry for object size ORDER, for debugging.  */

void

debug_print_page_list (int order)

{

  page_entry *p;

  printf ("Head=%p, Tail=%p:\n", (void *) G.pages[order],

          (void *) G.page_tails[order]);

  p = G.pages[order];

  while (p != NULL)

    {

      printf ("%p(%1d|%3d) -> ", (void *) p, p->context_depth,

              p->num_free_objects);

      p = p->next;

    }

  printf ("NULL\n");

  fflush (stdout);

}

#ifdef USING_MMAP

/* Allocate SIZE bytes of anonymous memory, preferably near PREF,

   (if non-null).  The ifdef structure here is intended to cause a

   compile error unless exactly one of the HAVE_* is defined.  */

static inline char *

alloc_anon (char *pref ATTRIBUTE_UNUSED, size_t size)

{

#ifdef HAVE_MMAP_ANON

  char *page = mmap (pref, size, PROT_READ | PROT_WRITE,

                     MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

#endif

#ifdef HAVE_MMAP_DEV_ZERO

  char *page = mmap (pref, size, PROT_READ | PROT_WRITE,

                     MAP_PRIVATE, G.dev_zero_fd, 0);

#endif

  if (page == (char *) MAP_FAILED)

    {

      perror ("virtual memory exhausted");

      exit (FATAL_EXIT_CODE);

    }

  /* Remember that we allocated this memory.  */

  G.bytes_mapped += size;

  /* Pretend we don't have access to the allocated pages.  We'll enable

     access to smaller pieces of the area in ggc_alloc.  Discard the

     handle to avoid handle leak.  */

  VALGRIND_DISCARD (VALGRIND_MAKE_NOACCESS (page, size));

  return page;

}

#endif

#ifdef USING_MALLOC_PAGE_GROUPS

/* Compute the index for this page into the page group.  */

static inline size_t

page_group_index (char *allocation, char *page)

{

  return (size_t) (page - allocation) >> G.lg_pagesize;

}

/* Set and clear the in_use bit for this page in the page group.  */

static inline void

set_page_group_in_use (page_group *group, char *page)

{

  group->in_use |= 1 << page_group_index (group->allocation, page);

}

static inline void

clear_page_group_in_use (page_group *group, char *page)

{

  group->in_use &= ~(1 << page_group_index (group->allocation, page));

}

#endif

/* Allocate a new page for allocating objects of size 2^ORDER,

   and return an entry for it.  The entry is not added to the

   appropriate page_table list.  */

static inline struct page_entry *

alloc_page (unsigned order)

{

  struct page_entry *entry, *p, **pp;

  char *page;

  size_t num_objects;

  size_t bitmap_size;

  size_t page_entry_size;

  size_t entry_size;

#ifdef USING_MALLOC_PAGE_GROUPS

  page_group *group;

#endif

  num_objects = OBJECTS_PER_PAGE (order);

  bitmap_size = BITMAP_SIZE (num_objects + 1);

  page_entry_size = sizeof (page_entry) - sizeof (long) + bitmap_size;

  entry_size = num_objects * OBJECT_SIZE (order);

  if (entry_size < G.pagesize)

    entry_size = G.pagesize;

  entry = NULL;

  page = NULL;

  /* Check the list of free pages for one we can use.  */

  for (pp = &G.free_pages, p = *pp; p; pp = &p->next, p = *pp)

    if (p->bytes == entry_size)

      break;