Subversion Repositories openrisc_me

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

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

   Free Software Foundation, Inc.

   Contributed by Richard Henderson (rth@redhat.com) and Daniel Berlin

   (dberlin@dberlin.org).  Rewritten by Daniel Jacobowitz

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

#include "rtl.h"

#include "tm_p.h"

#include "toplev.h"

#include "varray.h"

#include "flags.h"

#include "ggc.h"

#include "timevar.h"

#include "params.h"

#include "bitmap.h"

#include "plugin.h"

/* 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

#error Zone collector requires mmap

#endif

#if (GCC_VERSION < 3001)

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

#define prefetchw(X) ((void) X)

#else

#define prefetch(X) __builtin_prefetch (X)

#define prefetchw(X) __builtin_prefetch (X, 1, 3)

#endif

/* FUTURE NOTES:

   If we track inter-zone pointers, we can mark single zones at a

   time.

   If we have a zone where we guarantee no inter-zone pointers, we

   could mark that zone separately.

   The garbage zone should not be marked, and we should return 1 in

   ggc_set_mark for any object in the garbage zone, which cuts off

   marking quickly.  */

/* Strategy:

   This garbage-collecting allocator segregates objects into zones.

   It also segregates objects into "large" and "small" bins.  Large

   objects are greater than page size.

   Pages for small objects are broken up into chunks.  The page has

   a bitmap which marks the start position of each chunk (whether

   allocated or free).  Free chunks are on one of the zone's free

   lists and contain a pointer to the next free chunk.  Chunks in

   most of the free lists have a fixed size determined by the

   free list.  Chunks in the "other" sized free list have their size

   stored right after their chain pointer.

   Empty pages (of all sizes) 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.  The free page list is currently per-zone.  */

/* 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

/* This structure manages small free chunks.  The SIZE field is only

   initialized if the chunk is in the "other" sized free list.  Large

   chunks are allocated one at a time to their own page, and so don't

   come in here.  */

struct alloc_chunk {

  struct alloc_chunk *next_free;

  unsigned int size;

};

/* The size of the fixed-size portion of a small page descriptor.  */

#define PAGE_OVERHEAD   (offsetof (struct small_page_entry, alloc_bits))

/* The collector's idea of the page size.  This must be a power of two

   no larger than the system page size, because pages must be aligned

   to this amount and are tracked at this granularity in the page

   table.  We choose a size at compile time for efficiency.

   We could make a better guess at compile time if PAGE_SIZE is a

   constant in system headers, and PAGE_SHIFT is defined...  */

#define GGC_PAGE_SIZE   4096

#define GGC_PAGE_MASK   (GGC_PAGE_SIZE - 1)

#define GGC_PAGE_SHIFT  12

#if 0

/* Alternative definitions which use the runtime page size.  */

#define GGC_PAGE_SIZE   G.pagesize

#define GGC_PAGE_MASK   G.page_mask

#define GGC_PAGE_SHIFT  G.lg_pagesize

#endif

/* The size of a small page managed by the garbage collector.  This

   must currently be GGC_PAGE_SIZE, but with a few changes could

   be any multiple of it to reduce certain kinds of overhead.  */

#define SMALL_PAGE_SIZE GGC_PAGE_SIZE

/* Free bin information.  These numbers may be in need of re-tuning.

   In general, decreasing the number of free bins would seem to

   increase the time it takes to allocate... */

/* FIXME: We can't use anything but MAX_ALIGNMENT for the bin size

   today.  */

#define NUM_FREE_BINS           64

#define FREE_BIN_DELTA          MAX_ALIGNMENT

#define SIZE_BIN_DOWN(SIZE)     ((SIZE) / FREE_BIN_DELTA)

/* Allocation and marking parameters.  */

/* The smallest allocatable unit to keep track of.  */

#define BYTES_PER_ALLOC_BIT     MAX_ALIGNMENT

/* The smallest markable unit.  If we require each allocated object

   to contain at least two allocatable units, we can use half as many

   bits for the mark bitmap.  But this adds considerable complexity

   to sweeping.  */

#define BYTES_PER_MARK_BIT      BYTES_PER_ALLOC_BIT

#define BYTES_PER_MARK_WORD     (8 * BYTES_PER_MARK_BIT * sizeof (mark_type))

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

   allocations.

   There are several things wrong with this estimation of alignment.

   The maximum alignment for a structure is often less than the

   maximum alignment for a basic data type; for instance, on some

   targets long long must be aligned to sizeof (int) in a structure

   and sizeof (long long) in a variable.  i386-linux is one example;

   Darwin is another (sometimes, depending on the compiler in use).

   Also, long double is not included.  Nothing in GCC uses long

   double, so we assume that this is OK.  On powerpc-darwin, adding

   long double would bring the maximum alignment up to 16 bytes,

   and until we need long double (or to vectorize compiler operations)

   that's painfully wasteful.  This will need to change, some day.  */

struct max_alignment {

  char c;

  union {

    HOST_WIDEST_INT i;

    double d;

  } u;

};

/* The biggest alignment required.  */

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

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

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

/* Types to use for the allocation and mark bitmaps.  It might be

   a good idea to add ffsl to libiberty and use unsigned long

   instead; that could speed us up where long is wider than int.  */

typedef unsigned int alloc_type;

typedef unsigned int mark_type;

#define alloc_ffs(x) ffs(x)

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

   common data between all three kinds of pages - small, large, and

   PCH.  */

typedef struct page_entry

{

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

  char *page;

  /* The zone that this page entry belongs to.  */

  struct alloc_zone *zone;

#ifdef GATHER_STATISTICS

  /* How many collections we've survived.  */

  size_t survived;

#endif

  /* Does this page contain small objects, or one large object?  */

  bool large_p;

  /* Is this page part of the loaded PCH?  */

  bool pch_p;

} page_entry;

/* Additional data needed for small pages.  */

struct small_page_entry

{

  struct page_entry common;

  /* The next small page entry, or NULL if this is the last.  */

  struct small_page_entry *next;

  /* If currently marking this zone, a pointer to the mark bits

     for this page.  If we aren't currently marking this zone,

     this pointer may be stale (pointing to freed memory).  */

  mark_type *mark_bits;

  /* The allocation bitmap.  This array extends far enough to have

     one bit for every BYTES_PER_ALLOC_BIT bytes in the page.  */

  alloc_type alloc_bits[1];

};

/* Additional data needed for large pages.  */

struct large_page_entry

{

  struct page_entry common;

  /* The next large page entry, or NULL if this is the last.  */

  struct large_page_entry *next;

  /* The number of bytes allocated, not including the page entry.  */

  size_t bytes;

  /* The previous page in the list, so that we can unlink this one.  */

  struct large_page_entry *prev;

  /* During marking, is this object marked?  */

  bool mark_p;

};

/* 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 - GGC_PAGE_SHIFT)

#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) >> GGC_PAGE_SHIFT) & ((1 << PAGE_L2_BITS) - 1))

#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 global variables.  */

static struct globals

{

  /* The linked list of zones.  */

  struct alloc_zone *zones;

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

  page_table lookup;

  /* The system's page size, and related constants.  */

  size_t pagesize;

  size_t lg_pagesize;

  size_t page_mask;

  /* The size to allocate for a small page entry.  This includes

     the size of the structure and the size of the allocation

     bitmap.  */

  size_t small_page_overhead;

#if defined (HAVE_MMAP_DEV_ZERO)

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

  int dev_zero_fd;

#endif

  /* 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.  */

  size_t quire_size;

  /* The file descriptor for debugging output.  */

  FILE *debug_file;

} G;

/* A zone allocation structure.  There is one of these for every

   distinct allocation zone.  */

struct alloc_zone

{

  /* The most recent free chunk is saved here, instead of in the linked

     free list, to decrease list manipulation.  It is most likely that we

     will want this one.  */

  char *cached_free;

  size_t cached_free_size;

  /* Linked lists of free storage.  Slots 1 ... NUM_FREE_BINS have chunks of size

     FREE_BIN_DELTA.  All other chunks are in slot 0.  */

  struct alloc_chunk *free_chunks[NUM_FREE_BINS + 1];

  /* The highest bin index which might be non-empty.  It may turn out

     to be empty, in which case we have to search downwards.  */

  size_t high_free_bin;

  /* Bytes currently allocated in this zone.  */

  size_t allocated;

  /* Linked list of the small pages in this zone.  */

  struct small_page_entry *pages;

  /* Doubly linked list of large pages in this zone.  */

  struct large_page_entry *large_pages;

  /* If we are currently marking this zone, a pointer to the mark bits.  */

  mark_type *mark_bits;

  /* Name of the zone.  */

  const char *name;

  /* The number of small pages currently allocated in this zone.  */

  size_t n_small_pages;

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

  size_t allocated_last_gc;

  /* Total amount of memory mapped.  */

  size_t bytes_mapped;

  /* A cache of free system pages.  */

  struct small_page_entry *free_pages;

  /* Next zone in the linked list of zones.  */

  struct alloc_zone *next_zone;

  /* True if this zone was collected during this collection.  */

  bool was_collected;

  /* True if this zone should be destroyed after the next collection.  */

  bool dead;

#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;

  } stats;

#endif

} main_zone;

/* Some default zones.  */

struct alloc_zone rtl_zone;

struct alloc_zone tree_zone;

struct alloc_zone tree_id_zone;

/* The PCH zone does not need a normal zone structure, and it does

   not live on the linked list of zones.  */

struct pch_zone

{

  /* The start of the PCH zone.  NULL if there is none.  */

  char *page;

  /* The end of the PCH zone.  NULL if there is none.  */

  char *end;

  /* The size of the PCH zone.  0 if there is none.  */

  size_t bytes;

  /* The allocation bitmap for the PCH zone.  */

  alloc_type *alloc_bits;

  /* If we are currently marking, the mark bitmap for the PCH zone.

     When it is first read in, we could avoid marking the PCH,

     because it will not contain any pointers to GC memory outside

     of the PCH; however, the PCH is currently mapped as writable,

     so we must mark it in case new pointers are added.  */

  mark_type *mark_bits;

} pch_zone;

#ifdef USING_MMAP

static char *alloc_anon (char *, size_t, struct alloc_zone *);

#endif

static struct small_page_entry * alloc_small_page (struct alloc_zone *);

static struct large_page_entry * alloc_large_page (size_t, struct alloc_zone *);

static void free_chunk (char *, size_t, struct alloc_zone *);

static void free_small_page (struct small_page_entry *);

static void free_large_page (struct large_page_entry *);

static void release_pages (struct alloc_zone *);

static void sweep_pages (struct alloc_zone *);

static bool ggc_collect_1 (struct alloc_zone *, bool);

static void new_ggc_zone_1 (struct alloc_zone *, const char *);

/* 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];

}

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

   Return NULL if the object wasn't allocated via the GC.  */

static inline page_entry *

lookup_page_table_if_allocated (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 NULL;

      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);

  if (! base[L1])

    return NULL;

  L2 = LOOKUP_L2 (p);

  if (L2 >= PAGE_L2_SIZE)

    return NULL;

  /* We might have a page entry which does not correspond exactly to a

     system page.  */

  if (base[L1][L2] && (const char *) p < base[L1][L2]->page)

    return NULL;

  return base[L1][L2];

}

/* Set the page table entry for the page that starts at P.  If ENTRY

   is NULL, clear the entry.  */

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 = XCNEW (struct page_table_chain);

  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] = XCNEWVEC (page_entry *, PAGE_L2_SIZE);

  base[L1][L2] = entry;

}

/* Find the page table entry associated with OBJECT.  */

static inline struct page_entry *

zone_get_object_page (const void *object)

{

  return lookup_page_table_entry (object);

}

/* Find which element of the alloc_bits array OBJECT should be

   recorded in.  */

static inline unsigned int

zone_get_object_alloc_word (const void *object)

{

  return (((size_t) object & (GGC_PAGE_SIZE - 1))

          / (8 * sizeof (alloc_type) * BYTES_PER_ALLOC_BIT));

}

/* Find which bit of the appropriate word in the alloc_bits array

   OBJECT should be recorded in.  */

static inline unsigned int

zone_get_object_alloc_bit (const void *object)

{

  return (((size_t) object / BYTES_PER_ALLOC_BIT)

          % (8 * sizeof (alloc_type)));

}

/* Find which element of the mark_bits array OBJECT should be recorded

   in.  */

static inline unsigned int

zone_get_object_mark_word (const void *object)

{

  return (((size_t) object & (GGC_PAGE_SIZE - 1))

          / (8 * sizeof (mark_type) * BYTES_PER_MARK_BIT));

}

/* Find which bit of the appropriate word in the mark_bits array

   OBJECT should be recorded in.  */

static inline unsigned int

zone_get_object_mark_bit (const void *object)

{

  return (((size_t) object / BYTES_PER_MARK_BIT)

          % (8 * sizeof (mark_type)));

}

/* Set the allocation bit corresponding to OBJECT in its page's

   bitmap.  Used to split this object from the preceding one.  */

static inline void

zone_set_object_alloc_bit (const void *object)

{

  struct small_page_entry *page

    = (struct small_page_entry *) zone_get_object_page (object);

  unsigned int start_word = zone_get_object_alloc_word (object);

  unsigned int start_bit = zone_get_object_alloc_bit (object);

  page->alloc_bits[start_word] |= 1L << start_bit;

}

/* Clear the allocation bit corresponding to OBJECT in PAGE's

   bitmap.  Used to coalesce this object with the preceding

   one.  */

static inline void

zone_clear_object_alloc_bit (struct small_page_entry *page,

                             const void *object)

{

  unsigned int start_word = zone_get_object_alloc_word (object);

  unsigned int start_bit = zone_get_object_alloc_bit (object);

  /* Would xor be quicker?  */

  page->alloc_bits[start_word] &= ~(1L << start_bit);

}

/* Find the size of the object which starts at START_WORD and

   START_BIT in ALLOC_BITS, which is at most MAX_SIZE bytes.

   Helper function for ggc_get_size and zone_find_object_size.  */

static inline size_t

zone_object_size_1 (alloc_type *alloc_bits,

                    size_t start_word, size_t start_bit,

                    size_t max_size)

{

  size_t size;

  alloc_type alloc_word;

  int indx;

  /* Load the first word.  */

  alloc_word = alloc_bits[start_word++];

  /* If that was the last bit in this word, we'll want to continue

     with the next word.  Otherwise, handle the rest of this word.  */

  if (start_bit)

    {

      indx = alloc_ffs (alloc_word >> start_bit);

      if (indx)

        /* indx is 1-based.  We started at the bit after the object's

           start, but we also ended at the bit after the object's end.

           It cancels out.  */

        return indx * BYTES_PER_ALLOC_BIT;

      /* The extra 1 accounts for the starting unit, before start_bit.  */

      size = (sizeof (alloc_type) * 8 - start_bit + 1) * BYTES_PER_ALLOC_BIT;

      if (size >= max_size)

        return max_size;

      alloc_word = alloc_bits[start_word++];

    }

  else

    size = BYTES_PER_ALLOC_BIT;

  while (alloc_word == 0)

    {

      size += sizeof (alloc_type) * 8 * BYTES_PER_ALLOC_BIT;

      if (size >= max_size)

        return max_size;

      alloc_word = alloc_bits[start_word++];

    }

  indx = alloc_ffs (alloc_word);

  return size + (indx - 1) * BYTES_PER_ALLOC_BIT;

}

/* Find the size of OBJECT on small page PAGE.  */

static inline size_t

zone_find_object_size (struct small_page_entry *page,

                       const void *object)

{

  const char *object_midptr = (const char *) object + BYTES_PER_ALLOC_BIT;

  unsigned int start_word = zone_get_object_alloc_word (object_midptr);

  unsigned int start_bit = zone_get_object_alloc_bit (object_midptr);

  size_t max_size = (page->common.page + SMALL_PAGE_SIZE

                     - (const char *) object);

  return zone_object_size_1 (page->alloc_bits, start_word, start_bit,

                             max_size);

}

/* highest_bit assumes that alloc_type is 32 bits.  */

extern char check_alloc_type_size[(sizeof (alloc_type) == 4) ? 1 : -1];

/* Find the highest set bit in VALUE.  Returns the bit number of that

   bit, using the same values as ffs.  */

static inline alloc_type

highest_bit (alloc_type value)

{

  /* This also assumes that alloc_type is unsigned.  */

  value |= value >> 1;

  value |= value >> 2;

  value |= value >> 4;

  value |= value >> 8;

  value |= value >> 16;

  value = value ^ (value >> 1);

  return alloc_ffs (value);

}

/* Find the offset from the start of an object to P, which may point

   into the interior of the object.  */

static unsigned long

zone_find_object_offset (alloc_type *alloc_bits, size_t start_word,

                         size_t start_bit)

{

  unsigned int offset_in_bits;

  alloc_type alloc_word = alloc_bits[start_word];

  /* Mask off any bits after the initial bit, but make sure to include

     the initial bit in the result.  Note that START_BIT is

     0-based.  */

  if (start_bit < 8 * sizeof (alloc_type) - 1)

    alloc_word &= (1 << (start_bit + 1)) - 1;

  offset_in_bits = start_bit;

  /* Search for the start of the object.  */