1999-09-23 22:00:57 +02:00
|
|
|
|
/* "Bag-of-pages" garbage collector for the GNU compiler.
|
2000-01-16 19:16:55 +01:00
|
|
|
|
Copyright (C) 1999, 2000 Free Software Foundation, Inc.
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
2000-04-15 21:54:26 +02:00
|
|
|
|
This file is part of GNU CC.
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
2000-04-15 21:54:26 +02:00
|
|
|
|
GNU CC 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.
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
2000-04-15 21:54:26 +02:00
|
|
|
|
GNU CC 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.
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
2000-04-15 21:54:26 +02:00
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
|
along with GNU CC; see the file COPYING. If not, write to
|
|
|
|
|
the Free Software Foundation, 59 Temple Place - Suite 330,
|
|
|
|
|
Boston, MA 02111-1307, USA. */
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
|
#include "system.h"
|
|
|
|
|
#include "tree.h"
|
1999-09-30 01:08:11 +02:00
|
|
|
|
#include "rtl.h"
|
1999-10-05 17:42:18 +02:00
|
|
|
|
#include "tm_p.h"
|
2000-04-15 21:54:26 +02:00
|
|
|
|
#include "toplev.h"
|
1999-09-23 22:00:57 +02:00
|
|
|
|
#include "varray.h"
|
|
|
|
|
#include "flags.h"
|
1999-09-30 01:08:11 +02:00
|
|
|
|
#include "ggc.h"
|
Makefile.in (OBJS): Add timevar.o.
hangeLog:
* Makefile.in (OBJS): Add timevar.o.
(toplev.o): Depend on timevar.h.
(ggc-simple.o): Likewise.
(ggc-page.o): Likewise.
(timevar.o): New rule.
(timevar.h): New rule.
* timevar.h: New file.
* timevar.c: Likewise.
* timevar.def: Likewise.
* toplev.h (gc_time, parse_time, varconst_time): Remove.
* toplev.c: Use timevar_push and timevar_pop instead of TIMEVAR
throughout.
(TIMEVAR): Remove macro.
(gc_time, parse_time, varconst_time, integration_time, jump_time,
cse_time, gcse_time, loop_time, cse2_time, branch_prob_time,
flow_time, combine_time, regmove_time, sched_time,
local_alloc_time, global_alloc_time, flow2_time, peephole2_time,
sched2_time, dbr_sched_time, reorder_blocks_time,
rename_registers_time, shorten_branch_time, stack_reg_time,
to_ssa_time, from_ssa_time, final_time, symout_time, dump_time,
all_time): Remove.
(compile_file): Don't initialize time variables. Call
init_timevar and start TV_TOTAL timer. Call timevar_print instead
of many calls to print_time.
(rest_of_compilation): Add timing for reload_cse_regs.
(get_run_time): Removed to timevar.c.
(print_time): Likewise.
(get_run_time): Implement using TV_TOTAL time variable.
(print_time): Get total run time from get_run_time.
* ggc-page.c (ggc_collect): Push and pop TV_GC instead of
computing elapsed time explicitly.
* ggc-simple.c (ggc_collect): Likewise.
(gc_time): Remove declaration.
cp/ChangeLog:
* lex.c (my_get_run_time): Remove.
(init_filename_times): Use get_run_time instead of my_get_run_time.
(check_newline): Likewise.
(dump_time_statistics): Likewise.
* decl2.c (finish_file): Push and pop timevar TV_VARCONST instead
of computing elapsed time explicitly.
From-SVN: r33496
2000-04-28 02:59:40 +02:00
|
|
|
|
#include "timevar.h"
|
1999-09-30 01:08:11 +02:00
|
|
|
|
|
2000-01-16 19:16:55 +01:00
|
|
|
|
#ifdef HAVE_MMAP_ANYWHERE
|
1999-09-30 01:08:11 +02:00
|
|
|
|
#include <sys/mman.h>
|
1999-10-13 19:09:18 +02:00
|
|
|
|
#endif
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
1999-10-14 06:47:48 +02:00
|
|
|
|
#ifndef MAP_FAILED
|
|
|
|
|
#define MAP_FAILED -1
|
|
|
|
|
#endif
|
|
|
|
|
|
1999-10-20 14:53:23 +02:00
|
|
|
|
#if !defined (MAP_ANONYMOUS) && defined (MAP_ANON)
|
|
|
|
|
#define MAP_ANONYMOUS MAP_ANON
|
|
|
|
|
#endif
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
|
|
|
|
/* Stategy:
|
|
|
|
|
|
|
|
|
|
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_POISON to poison memory marked unused by the collector. */
|
|
|
|
|
#undef GGC_POISON
|
|
|
|
|
|
|
|
|
|
/* Define GGC_ALWAYS_COLLECT to perform collection every time
|
|
|
|
|
ggc_collect is invoked. Otherwise, collection is performed only
|
|
|
|
|
when a significant amount of memory has been allocated since the
|
|
|
|
|
last collection. */
|
1999-10-06 01:29:32 +02:00
|
|
|
|
#undef GGC_ALWAYS_COLLECT
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
acconfig.h: New ENABLE flags: TREE_CHECKING, RTL_CHECKING, GC_CHECKING, GC_ALWAYS_COLLECT.
1999-12-26 Zack Weinberg <zack@wolery.cumb.org>
* acconfig.h: New ENABLE flags: TREE_CHECKING, RTL_CHECKING,
GC_CHECKING, GC_ALWAYS_COLLECT.
* configure.in: Allow --enable-checking with an argument
listing check modes to enable.
* config.in, configure: Rebuilt.
* ggc-page.c, ggc-simple.c: Define GGC_POISON (and
GGC_ALWAYS_VERIFY for ggc-simple.c) only if
ENABLE_GC_CHECKING. Define GGC_ALWAYS_COLLECT only if
ENABLE_GC_ALWAYS_COLLECT.
* rtl.h, rtl.c: Change ENABLE_CHECKING to ENABLE_RTL_CHECKING
throughout.
* tree.h, tree.c: Change ENABLE_CHECKING to
ENABLE_TREE_CHECKING throughout.
* cp-tree.h: Replace ENABLE_CHECKING with ENABLE_TREE_CHECKING
throughout.
From-SVN: r31093
1999-12-27 00:06:54 +01:00
|
|
|
|
#ifdef ENABLE_GC_CHECKING
|
1999-09-23 22:00:57 +02:00
|
|
|
|
#define GGC_POISON
|
acconfig.h: New ENABLE flags: TREE_CHECKING, RTL_CHECKING, GC_CHECKING, GC_ALWAYS_COLLECT.
1999-12-26 Zack Weinberg <zack@wolery.cumb.org>
* acconfig.h: New ENABLE flags: TREE_CHECKING, RTL_CHECKING,
GC_CHECKING, GC_ALWAYS_COLLECT.
* configure.in: Allow --enable-checking with an argument
listing check modes to enable.
* config.in, configure: Rebuilt.
* ggc-page.c, ggc-simple.c: Define GGC_POISON (and
GGC_ALWAYS_VERIFY for ggc-simple.c) only if
ENABLE_GC_CHECKING. Define GGC_ALWAYS_COLLECT only if
ENABLE_GC_ALWAYS_COLLECT.
* rtl.h, rtl.c: Change ENABLE_CHECKING to ENABLE_RTL_CHECKING
throughout.
* tree.h, tree.c: Change ENABLE_CHECKING to
ENABLE_TREE_CHECKING throughout.
* cp-tree.h: Replace ENABLE_CHECKING with ENABLE_TREE_CHECKING
throughout.
From-SVN: r31093
1999-12-27 00:06:54 +01:00
|
|
|
|
#endif
|
|
|
|
|
#ifdef ENABLE_GC_ALWAYS_COLLECT
|
1999-09-23 22:00:57 +02:00
|
|
|
|
#define GGC_ALWAYS_COLLECT
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* 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
|
|
|
|
|
|
|
|
|
|
/* The "" allocated string. */
|
|
|
|
|
char *empty_string;
|
|
|
|
|
|
|
|
|
|
/* 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.
|
|
|
|
|
|
1999-10-13 19:09:18 +02:00
|
|
|
|
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. */
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
|
|
|
|
#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))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* 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 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;
|
|
|
|
|
|
|
|
|
|
/* Saved in-use bit vector for pages that aren't in the topmost
|
|
|
|
|
context during collection. */
|
|
|
|
|
unsigned long *save_in_use_p;
|
|
|
|
|
|
|
|
|
|
/* Context depth of this page. */
|
2000-01-23 20:18:45 +01:00
|
|
|
|
unsigned short context_depth;
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
|
2000-01-23 20:18:45 +01:00
|
|
|
|
/* The lg of size of objects allocated from this page. */
|
|
|
|
|
unsigned char order;
|
|
|
|
|
|
1999-09-23 22:00:57 +02:00
|
|
|
|
/* 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;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#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
|
|
|
|
|
|
1999-10-13 19:09:18 +02:00
|
|
|
|
/* 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
|
1999-09-23 22:00:57 +02:00
|
|
|
|
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[HOST_BITS_PER_PTR];
|
|
|
|
|
|
|
|
|
|
/* 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[HOST_BITS_PER_PTR];
|
|
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
|
1999-10-29 06:17:33 +02:00
|
|
|
|
/* Total amount of memory mapped. */
|
|
|
|
|
size_t bytes_mapped;
|
|
|
|
|
|
1999-09-23 22:00:57 +02:00
|
|
|
|
/* The current depth in the context stack. */
|
2000-01-23 21:42:53 +01:00
|
|
|
|
unsigned short context_depth;
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
|
|
|
|
/* A file descriptor open to /dev/zero for reading. */
|
2000-01-16 19:16:55 +01:00
|
|
|
|
#if defined (HAVE_MMAP_ANYWHERE) && !defined(MAP_ANONYMOUS)
|
1999-09-23 22:00:57 +02:00
|
|
|
|
int dev_zero_fd;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* A cache of free system pages. */
|
|
|
|
|
page_entry *free_pages;
|
|
|
|
|
|
|
|
|
|
/* The file descriptor for debugging output. */
|
|
|
|
|
FILE *debug_file;
|
|
|
|
|
} G;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Compute DIVIDEND / DIVISOR, rounded up. */
|
|
|
|
|
#define DIV_ROUND_UP(Dividend, Divisor) \
|
1999-11-01 07:57:01 +01:00
|
|
|
|
(((Dividend) + (Divisor) - 1) / (Divisor))
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
|
|
|
|
/* The number of objects per allocation page, for objects of size
|
|
|
|
|
2^ORDER. */
|
|
|
|
|
#define OBJECTS_PER_PAGE(Order) \
|
|
|
|
|
((Order) >= G.lg_pagesize ? 1 : G.pagesize / ((size_t)1 << (Order)))
|
|
|
|
|
|
|
|
|
|
/* The size in bytes required to maintain a bitmap for the objects
|
|
|
|
|
on a page-entry. */
|
|
|
|
|
#define BITMAP_SIZE(Num_objects) \
|
|
|
|
|
(DIV_ROUND_UP ((Num_objects), HOST_BITS_PER_LONG) * sizeof(long))
|
|
|
|
|
|
|
|
|
|
/* Skip garbage collection if the current allocation is not at least
|
|
|
|
|
this factor times the allocation at the end of the last collection.
|
|
|
|
|
In other words, total allocation must expand by (this factor minus
|
|
|
|
|
one) before collection is performed. */
|
|
|
|
|
#define GGC_MIN_EXPAND_FOR_GC (1.3)
|
|
|
|
|
|
1999-09-28 08:05:53 +02:00
|
|
|
|
/* Bound `allocated_last_gc' to 4MB, to prevent the memory expansion
|
|
|
|
|
test from triggering too often when the heap is small. */
|
|
|
|
|
#define GGC_MIN_LAST_ALLOCATED (4 * 1024 * 1024)
|
|
|
|
|
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
2000-01-17 16:28:05 +01:00
|
|
|
|
static int ggc_allocated_p PARAMS ((const void *));
|
|
|
|
|
static page_entry *lookup_page_table_entry PARAMS ((const void *));
|
|
|
|
|
static void set_page_table_entry PARAMS ((void *, page_entry *));
|
|
|
|
|
static char *alloc_anon PARAMS ((char *, size_t));
|
|
|
|
|
static struct page_entry * alloc_page PARAMS ((unsigned));
|
|
|
|
|
static void free_page PARAMS ((struct page_entry *));
|
|
|
|
|
static void release_pages PARAMS ((void));
|
|
|
|
|
static void clear_marks PARAMS ((void));
|
|
|
|
|
static void sweep_pages PARAMS ((void));
|
|
|
|
|
static void ggc_recalculate_in_use_p PARAMS ((page_entry *));
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
|
|
|
|
#ifdef GGC_POISON
|
2000-01-17 16:28:05 +01:00
|
|
|
|
static void poison_pages PARAMS ((void));
|
1999-09-23 22:00:57 +02:00
|
|
|
|
#endif
|
|
|
|
|
|
2000-01-17 16:28:05 +01:00
|
|
|
|
void debug_print_page_list PARAMS ((int));
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
1999-10-13 19:09:18 +02:00
|
|
|
|
/* Returns non-zero if P was allocated in GC'able memory. */
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
1999-10-13 19:09:18 +02:00
|
|
|
|
static inline int
|
|
|
|
|
ggc_allocated_p (p)
|
|
|
|
|
const void *p;
|
1999-09-23 22:00:57 +02:00
|
|
|
|
{
|
|
|
|
|
page_entry ***base;
|
1999-10-13 19:09:18 +02:00
|
|
|
|
size_t L1, L2;
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
|
|
|
|
#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;
|
1999-10-13 19:09:18 +02:00
|
|
|
|
while (1)
|
|
|
|
|
{
|
|
|
|
|
if (table == NULL)
|
|
|
|
|
return 0;
|
|
|
|
|
if (table->high_bits == high_bits)
|
|
|
|
|
break;
|
|
|
|
|
table = table->next;
|
|
|
|
|
}
|
1999-09-23 22:00:57 +02:00
|
|
|
|
base = &table->table[0];
|
|
|
|
|
#endif
|
|
|
|
|
|
1999-10-11 04:11:21 +02:00
|
|
|
|
/* Extract the level 1 and 2 indicies. */
|
|
|
|
|
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(p)
|
1999-10-13 19:09:18 +02:00
|
|
|
|
const void *p;
|
1999-10-11 04:11:21 +02:00
|
|
|
|
{
|
|
|
|
|
page_entry ***base;
|
|
|
|
|
size_t L1, L2;
|
|
|
|
|
|
1999-10-13 19:09:18 +02:00
|
|
|
|
#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
|
1999-10-11 04:11:21 +02:00
|
|
|
|
|
1999-09-23 22:00:57 +02:00
|
|
|
|
/* Extract the level 1 and 2 indicies. */
|
|
|
|
|
L1 = LOOKUP_L1 (p);
|
|
|
|
|
L2 = LOOKUP_L2 (p);
|
|
|
|
|
|
|
|
|
|
return base[L1][L2];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Set the page table entry for a page. */
|
1999-10-30 23:36:13 +02:00
|
|
|
|
|
1999-09-23 22:00:57 +02:00
|
|
|
|
static void
|
|
|
|
|
set_page_table_entry(p, 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 = (page_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 indicies. */
|
|
|
|
|
L1 = LOOKUP_L1 (p);
|
|
|
|
|
L2 = LOOKUP_L2 (p);
|
|
|
|
|
|
|
|
|
|
if (base[L1] == NULL)
|
|
|
|
|
base[L1] = (page_entry **) xcalloc (PAGE_L2_SIZE, sizeof (page_entry *));
|
|
|
|
|
|
|
|
|
|
base[L1][L2] = entry;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Prints the page-entry for object size ORDER, for debugging. */
|
1999-10-30 23:36:13 +02:00
|
|
|
|
|
1999-09-23 22:00:57 +02:00
|
|
|
|
void
|
|
|
|
|
debug_print_page_list (order)
|
|
|
|
|
int order;
|
|
|
|
|
{
|
|
|
|
|
page_entry *p;
|
|
|
|
|
printf ("Head=%p, Tail=%p:\n", G.pages[order], G.page_tails[order]);
|
|
|
|
|
p = G.pages[order];
|
|
|
|
|
while (p != NULL)
|
|
|
|
|
{
|
|
|
|
|
printf ("%p(%1d|%3d) -> ", p, p->context_depth, p->num_free_objects);
|
|
|
|
|
p = p->next;
|
|
|
|
|
}
|
|
|
|
|
printf ("NULL\n");
|
|
|
|
|
fflush (stdout);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Allocate SIZE bytes of anonymous memory, preferably near PREF,
|
|
|
|
|
(if non-null). */
|
1999-10-30 23:36:13 +02:00
|
|
|
|
|
1999-09-23 22:00:57 +02:00
|
|
|
|
static inline char *
|
|
|
|
|
alloc_anon (pref, size)
|
1999-10-13 19:09:18 +02:00
|
|
|
|
char *pref ATTRIBUTE_UNUSED;
|
1999-09-23 22:00:57 +02:00
|
|
|
|
size_t size;
|
|
|
|
|
{
|
|
|
|
|
char *page;
|
|
|
|
|
|
2000-01-16 19:16:55 +01:00
|
|
|
|
#ifdef HAVE_MMAP_ANYWHERE
|
1999-09-23 22:00:57 +02:00
|
|
|
|
#ifdef MAP_ANONYMOUS
|
|
|
|
|
page = (char *) mmap (pref, size, PROT_READ | PROT_WRITE,
|
|
|
|
|
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
|
|
|
|
|
#else
|
|
|
|
|
page = (char *) mmap (pref, size, PROT_READ | PROT_WRITE,
|
|
|
|
|
MAP_PRIVATE, G.dev_zero_fd, 0);
|
|
|
|
|
#endif
|
|
|
|
|
if (page == (char *) MAP_FAILED)
|
|
|
|
|
{
|
|
|
|
|
fputs ("Virtual memory exhausted!\n", stderr);
|
|
|
|
|
exit(1);
|
|
|
|
|
}
|
1999-10-13 19:09:18 +02:00
|
|
|
|
#else
|
|
|
|
|
#ifdef HAVE_VALLOC
|
|
|
|
|
page = (char *) valloc (size);
|
|
|
|
|
if (!page)
|
|
|
|
|
{
|
|
|
|
|
fputs ("Virtual memory exhausted!\n", stderr);
|
|
|
|
|
exit(1);
|
|
|
|
|
}
|
|
|
|
|
#endif /* HAVE_VALLOC */
|
2000-01-16 19:16:55 +01:00
|
|
|
|
#endif /* HAVE_MMAP_ANYWHERE */
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
1999-10-29 06:17:33 +02:00
|
|
|
|
/* Remember that we allocated this memory. */
|
|
|
|
|
G.bytes_mapped += size;
|
|
|
|
|
|
1999-09-23 22:00:57 +02:00
|
|
|
|
return page;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* 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. */
|
1999-10-30 23:36:13 +02:00
|
|
|
|
|
1999-09-23 22:00:57 +02:00
|
|
|
|
static inline struct page_entry *
|
|
|
|
|
alloc_page (order)
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
|
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 * (1 << order);
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
|
if (p != NULL)
|
|
|
|
|
{
|
|
|
|
|
/* Recycle the allocated memory from this page ... */
|
|
|
|
|
*pp = p->next;
|
|
|
|
|
page = p->page;
|
|
|
|
|
/* ... and, if possible, the page entry itself. */
|
|
|
|
|
if (p->order == order)
|
|
|
|
|
{
|
|
|
|
|
entry = p;
|
|
|
|
|
memset (entry, 0, page_entry_size);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
free (p);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
1999-10-30 23:36:13 +02:00
|
|
|
|
/* Actually allocate the memory. */
|
1999-09-23 22:00:57 +02:00
|
|
|
|
page = alloc_anon (NULL, entry_size);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (entry == NULL)
|
|
|
|
|
entry = (struct page_entry *) xcalloc (1, page_entry_size);
|
|
|
|
|
|
|
|
|
|
entry->bytes = entry_size;
|
|
|
|
|
entry->page = page;
|
|
|
|
|
entry->context_depth = G.context_depth;
|
|
|
|
|
entry->order = order;
|
|
|
|
|
entry->num_free_objects = num_objects;
|
|
|
|
|
entry->next_bit_hint = 1;
|
|
|
|
|
|
|
|
|
|
/* Set the one-past-the-end in-use bit. This acts as a sentry as we
|
|
|
|
|
increment the hint. */
|
|
|
|
|
entry->in_use_p[num_objects / HOST_BITS_PER_LONG]
|
|
|
|
|
= (unsigned long) 1 << (num_objects % HOST_BITS_PER_LONG);
|
|
|
|
|
|
|
|
|
|
set_page_table_entry (page, entry);
|
|
|
|
|
|
|
|
|
|
if (GGC_DEBUG_LEVEL >= 2)
|
|
|
|
|
fprintf (G.debug_file,
|
|
|
|
|
"Allocating page at %p, object size=%d, data %p-%p\n", entry,
|
|
|
|
|
1 << order, page, page + entry_size - 1);
|
|
|
|
|
|
|
|
|
|
return entry;
|
|
|
|
|
}
|
|
|
|
|
|
1999-10-30 23:36:13 +02:00
|
|
|
|
/* For a page that is no longer needed, put it on the free page list. */
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
|
free_page (entry)
|
|
|
|
|
page_entry *entry;
|
|
|
|
|
{
|
|
|
|
|
if (GGC_DEBUG_LEVEL >= 2)
|
|
|
|
|
fprintf (G.debug_file,
|
|
|
|
|
"Deallocating page at %p, data %p-%p\n", entry,
|
|
|
|
|
entry->page, entry->page + entry->bytes - 1);
|
|
|
|
|
|
|
|
|
|
set_page_table_entry (entry->page, NULL);
|
|
|
|
|
|
|
|
|
|
entry->next = G.free_pages;
|
|
|
|
|
G.free_pages = entry;
|
|
|
|
|
}
|
|
|
|
|
|
1999-10-30 23:36:13 +02:00
|
|
|
|
/* Release the free page cache to the system. */
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
1999-11-01 07:57:01 +01:00
|
|
|
|
static void
|
1999-09-23 22:00:57 +02:00
|
|
|
|
release_pages ()
|
|
|
|
|
{
|
2000-01-16 19:16:55 +01:00
|
|
|
|
#ifdef HAVE_MMAP_ANYWHERE
|
1999-09-23 22:00:57 +02:00
|
|
|
|
page_entry *p, *next;
|
|
|
|
|
char *start;
|
|
|
|
|
size_t len;
|
|
|
|
|
|
|
|
|
|
p = G.free_pages;
|
|
|
|
|
if (p == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
next = p->next;
|
|
|
|
|
start = p->page;
|
|
|
|
|
len = p->bytes;
|
|
|
|
|
free (p);
|
|
|
|
|
p = next;
|
|
|
|
|
|
|
|
|
|
while (p)
|
|
|
|
|
{
|
|
|
|
|
next = p->next;
|
|
|
|
|
/* Gather up adjacent pages so they are unmapped together. */
|
|
|
|
|
if (p->page == start + len)
|
|
|
|
|
len += p->bytes;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
munmap (start, len);
|
1999-10-29 06:17:33 +02:00
|
|
|
|
G.bytes_mapped -= len;
|
1999-09-23 22:00:57 +02:00
|
|
|
|
start = p->page;
|
|
|
|
|
len = p->bytes;
|
|
|
|
|
}
|
|
|
|
|
free (p);
|
|
|
|
|
p = next;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
munmap (start, len);
|
1999-10-29 06:17:33 +02:00
|
|
|
|
G.bytes_mapped -= len;
|
1999-10-13 19:09:18 +02:00
|
|
|
|
#else
|
|
|
|
|
#ifdef HAVE_VALLOC
|
|
|
|
|
page_entry *p, *next;
|
|
|
|
|
|
|
|
|
|
for (p = G.free_pages; p ; p = next)
|
|
|
|
|
{
|
|
|
|
|
next = p->next;
|
|
|
|
|
free (p->page);
|
1999-10-29 06:17:33 +02:00
|
|
|
|
G.bytes_mapped -= p->bytes;
|
1999-10-13 19:09:18 +02:00
|
|
|
|
free (p);
|
|
|
|
|
}
|
|
|
|
|
#endif /* HAVE_VALLOC */
|
2000-01-16 19:16:55 +01:00
|
|
|
|
#endif /* HAVE_MMAP_ANYWHERE */
|
1999-10-13 19:09:18 +02:00
|
|
|
|
|
1999-09-23 22:00:57 +02:00
|
|
|
|
G.free_pages = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* This table provides a fast way to determine ceil(log_2(size)) for
|
|
|
|
|
allocation requests. The minimum allocation size is four bytes. */
|
1999-10-30 23:36:13 +02:00
|
|
|
|
|
1999-09-23 22:00:57 +02:00
|
|
|
|
static unsigned char const size_lookup[257] =
|
|
|
|
|
{
|
|
|
|
|
2, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4,
|
|
|
|
|
4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
|
|
|
|
5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
|
|
|
|
|
6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
|
|
|
|
|
6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
|
|
|
|
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
|
|
|
|
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
|
|
|
|
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
|
|
|
|
7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
|
|
|
|
|
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
|
|
|
|
|
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
|
|
|
|
|
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
|
|
|
|
|
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
|
|
|
|
|
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
|
|
|
|
|
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
|
|
|
|
|
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
|
|
|
|
|
8
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* Allocate a chunk of memory of SIZE bytes. If ZERO is non-zero, the
|
|
|
|
|
memory is zeroed; otherwise, its contents are undefined. */
|
1999-10-30 23:36:13 +02:00
|
|
|
|
|
1999-10-13 19:09:18 +02:00
|
|
|
|
void *
|
ggc-none.c, [...] (ggc_alloc_obj): Rename it ggc_alloc, drop second argument, never clear returned memory.
toplevel:
* ggc-none.c, ggc-simple.c, ggc-page.c (ggc_alloc_obj): Rename
it ggc_alloc, drop second argument, never clear returned memory.
* ggc-common.c (ggc_alloc_string): Use ggc_alloc.
(ggc_alloc_cleared): New.
* ggc.h: Prototype ggc_alloc and ggc_alloc_cleared, not
ggc_alloc_obj. Remove ggc_alloc macro.
(ggc_alloc_rtx, ggc_alloc_rtvec, ggc_alloc_tree): Use ggc_alloc.
* rtl.c (rtvec_alloc): Clear the vector always.
(rtx_alloc): Clear the first word always. Remove dirty
obstack tricks (this routine is no longer a bottleneck).
* tree.c (make_node): Clear the new node always.
(make_tree_vec): Likewise.
(tree_cons): Clear the common structure always.
(build1): Likewise; also, clear TREE_COMPLEXITY.
* gengenrtl.c: Use puts wherever possible. Remove extra
newlines.
(gendef): Clear the first word of an RTX in the generator
function, irrespective of ggc_p. Initialize '0' slots to
NULL.
(genlegend): Don't generate obstack_alloc_rtx routine, just a
thin wrapper macro around obstack_alloc.
* stmt.c (expand_fixup): Use ggc_alloc.
* c-typeck.c (add_pending_init): Use ggc_alloc.
* emit-rtl.c (init_emit_once): Clear CONST_DOUBLE_CHAIN(tem).
* varasm.c (immed_double_const): Set CONST_DOUBLE_MEM(r) to
const0_rtx when it is created.
(immed_real_const_1): Set CONST_DOUBLE_CHAIN(r) to NULL_RTX if
we are not in a function.
* tree.c (tree_class_check_failed): Make second arg an int.
* tree.h: Update prototype.
cp:
* call.c (add_candidate): Use ggc_alloc_cleared.
* decl.c (lookup_label): Likewise.
* lex.c (retrofit_lang_decl): Likewise.
From-SVN: r34478
2000-06-09 23:47:40 +02:00
|
|
|
|
ggc_alloc (size)
|
1999-09-23 22:00:57 +02:00
|
|
|
|
size_t size;
|
|
|
|
|
{
|
|
|
|
|
unsigned order, word, bit, object_offset;
|
|
|
|
|
struct page_entry *entry;
|
|
|
|
|
void *result;
|
|
|
|
|
|
|
|
|
|
if (size <= 256)
|
|
|
|
|
order = size_lookup[size];
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
order = 9;
|
|
|
|
|
while (size > ((size_t) 1 << order))
|
|
|
|
|
order++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* If there are non-full pages for this size allocation, they are at
|
|
|
|
|
the head of the list. */
|
|
|
|
|
entry = G.pages[order];
|
|
|
|
|
|
|
|
|
|
/* If there is no page for this object size, or all pages in this
|
|
|
|
|
context are full, allocate a new page. */
|
1999-11-01 07:57:01 +01:00
|
|
|
|
if (entry == NULL || entry->num_free_objects == 0)
|
1999-09-23 22:00:57 +02:00
|
|
|
|
{
|
|
|
|
|
struct page_entry *new_entry;
|
|
|
|
|
new_entry = alloc_page (order);
|
|
|
|
|
|
|
|
|
|
/* If this is the only entry, it's also the tail. */
|
|
|
|
|
if (entry == NULL)
|
|
|
|
|
G.page_tails[order] = new_entry;
|
|
|
|
|
|
|
|
|
|
/* Put new pages at the head of the page list. */
|
|
|
|
|
new_entry->next = entry;
|
|
|
|
|
entry = new_entry;
|
|
|
|
|
G.pages[order] = new_entry;
|
|
|
|
|
|
|
|
|
|
/* For a new page, we know the word and bit positions (in the
|
|
|
|
|
in_use bitmap) of the first available object -- they're zero. */
|
|
|
|
|
new_entry->next_bit_hint = 1;
|
|
|
|
|
word = 0;
|
|
|
|
|
bit = 0;
|
|
|
|
|
object_offset = 0;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* First try to use the hint left from the previous allocation
|
|
|
|
|
to locate a clear bit in the in-use bitmap. We've made sure
|
|
|
|
|
that the one-past-the-end bit is always set, so if the hint
|
|
|
|
|
has run over, this test will fail. */
|
|
|
|
|
unsigned hint = entry->next_bit_hint;
|
|
|
|
|
word = hint / HOST_BITS_PER_LONG;
|
|
|
|
|
bit = hint % HOST_BITS_PER_LONG;
|
|
|
|
|
|
|
|
|
|
/* If the hint didn't work, scan the bitmap from the beginning. */
|
|
|
|
|
if ((entry->in_use_p[word] >> bit) & 1)
|
|
|
|
|
{
|
|
|
|
|
word = bit = 0;
|
|
|
|
|
while (~entry->in_use_p[word] == 0)
|
|
|
|
|
++word;
|
|
|
|
|
while ((entry->in_use_p[word] >> bit) & 1)
|
|
|
|
|
++bit;
|
|
|
|
|
hint = word * HOST_BITS_PER_LONG + bit;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Next time, try the next bit. */
|
|
|
|
|
entry->next_bit_hint = hint + 1;
|
|
|
|
|
|
|
|
|
|
object_offset = hint << order;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Set the in-use bit. */
|
|
|
|
|
entry->in_use_p[word] |= ((unsigned long) 1 << bit);
|
|
|
|
|
|
|
|
|
|
/* Keep a running total of the number of free objects. If this page
|
|
|
|
|
fills up, we may have to move it to the end of the list if the
|
|
|
|
|
next page isn't full. If the next page is full, all subsequent
|
|
|
|
|
pages are full, so there's no need to move it. */
|
|
|
|
|
if (--entry->num_free_objects == 0
|
|
|
|
|
&& entry->next != NULL
|
|
|
|
|
&& entry->next->num_free_objects > 0)
|
|
|
|
|
{
|
|
|
|
|
G.pages[order] = entry->next;
|
|
|
|
|
entry->next = NULL;
|
|
|
|
|
G.page_tails[order]->next = entry;
|
|
|
|
|
G.page_tails[order] = entry;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Calculate the object's address. */
|
|
|
|
|
result = entry->page + object_offset;
|
|
|
|
|
|
|
|
|
|
#ifdef GGC_POISON
|
ggc-none.c, [...] (ggc_alloc_obj): Rename it ggc_alloc, drop second argument, never clear returned memory.
toplevel:
* ggc-none.c, ggc-simple.c, ggc-page.c (ggc_alloc_obj): Rename
it ggc_alloc, drop second argument, never clear returned memory.
* ggc-common.c (ggc_alloc_string): Use ggc_alloc.
(ggc_alloc_cleared): New.
* ggc.h: Prototype ggc_alloc and ggc_alloc_cleared, not
ggc_alloc_obj. Remove ggc_alloc macro.
(ggc_alloc_rtx, ggc_alloc_rtvec, ggc_alloc_tree): Use ggc_alloc.
* rtl.c (rtvec_alloc): Clear the vector always.
(rtx_alloc): Clear the first word always. Remove dirty
obstack tricks (this routine is no longer a bottleneck).
* tree.c (make_node): Clear the new node always.
(make_tree_vec): Likewise.
(tree_cons): Clear the common structure always.
(build1): Likewise; also, clear TREE_COMPLEXITY.
* gengenrtl.c: Use puts wherever possible. Remove extra
newlines.
(gendef): Clear the first word of an RTX in the generator
function, irrespective of ggc_p. Initialize '0' slots to
NULL.
(genlegend): Don't generate obstack_alloc_rtx routine, just a
thin wrapper macro around obstack_alloc.
* stmt.c (expand_fixup): Use ggc_alloc.
* c-typeck.c (add_pending_init): Use ggc_alloc.
* emit-rtl.c (init_emit_once): Clear CONST_DOUBLE_CHAIN(tem).
* varasm.c (immed_double_const): Set CONST_DOUBLE_MEM(r) to
const0_rtx when it is created.
(immed_real_const_1): Set CONST_DOUBLE_CHAIN(r) to NULL_RTX if
we are not in a function.
* tree.c (tree_class_check_failed): Make second arg an int.
* tree.h: Update prototype.
cp:
* call.c (add_candidate): Use ggc_alloc_cleared.
* decl.c (lookup_label): Likewise.
* lex.c (retrofit_lang_decl): Likewise.
From-SVN: r34478
2000-06-09 23:47:40 +02:00
|
|
|
|
/* `Poison' the entire allocated object, including any padding at
|
|
|
|
|
the end. */
|
1999-10-30 23:36:13 +02:00
|
|
|
|
memset (result, 0xaf, 1 << order);
|
1999-09-23 22:00:57 +02:00
|
|
|
|
#endif
|
1999-10-30 23:36:13 +02:00
|
|
|
|
|
1999-09-23 22:00:57 +02:00
|
|
|
|
/* Keep track of how many bytes are being allocated. This
|
|
|
|
|
information is used in deciding when to collect. */
|
|
|
|
|
G.allocated += (size_t) 1 << order;
|
|
|
|
|
|
|
|
|
|
if (GGC_DEBUG_LEVEL >= 3)
|
|
|
|
|
fprintf (G.debug_file,
|
|
|
|
|
"Allocating object, requested size=%d, actual=%d at %p on %p\n",
|
|
|
|
|
(int) size, 1 << order, result, entry);
|
|
|
|
|
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
1999-10-30 23:36:13 +02:00
|
|
|
|
/* If P is not marked, marks it and return false. Otherwise return true.
|
1999-09-23 22:00:57 +02:00
|
|
|
|
P must have been allocated by the GC allocator; it mustn't point to
|
|
|
|
|
static objects, stack variables, or memory allocated with malloc. */
|
1999-10-30 23:36:13 +02:00
|
|
|
|
|
1999-10-13 19:09:18 +02:00
|
|
|
|
int
|
|
|
|
|
ggc_set_mark (p)
|
rtl.h (rtunion_def): Constify member `rtstr'.
* rtl.h (rtunion_def): Constify member `rtstr'.
(emit_line_note_after, emit_line_note, emit_line_note_force,
emit_note, decode_asm_operands): Constify.
* cse.c (canon_hash): Likewise.
* dbxout.c (dbxout_block): Likewise.
* diagnostic.c (file_and_line_for_asm, v_error_for_asm,
v_warning_for_asm): Likewise.
* dwarfout.c (function_start_label): Likewise.
* emit-rtl.c (emit_line_note_after, emit_line_note, emit_note,
emit_line_note_force): Likewise.
* final.c (last_filename, asm_insn_count, final_scan_insn,
output_source_line): Likewise.
* function.h (struct emit_status): Likewise.
* gcse.c (hash_expr_1): Likewise.
* genattr.c (gen_attr, main): Likewise.
* genattrtab.c (struct function_unit, current_alternative_string,
write_attr_valueq, n_comma_elts, next_comma_elt, attr_eq,
attr_numeral, check_attr_test, check_attr_value,
convert_set_attr_alternative, convert_set_attr,
compute_alternative_mask, simplify_by_exploding, gen_attr,
gen_unit): Likewise.
* genflags.c (gen_insn): Likewise.
* gengenrtl.c (type_from_format): Likewise.
* genopinit.c (gen_insn): Likewise.
* genoutput.c (n_occurrences, process_template, process_template):
Likewise.
* ggc-page.c (ggc_set_mark, ggc_mark_if_gcable, ggc_get_size):
Likewise.
* ggc-simple.c (ggc_set_mark, ggc_mark_if_gcable, ggc_get_size):
Likewise.
* ggc.h (ggc_mark_string, ggc_mark, ggc_mark_if_gcable,
ggc_set_mark, ggc_get_size): Likewise.
* objc/objc-act.c (build_module_descriptor, finish_objc): Likewise.
* optabs.c (init_one_libfunc): Likewise.
* output.h (assemble_start_function): Likewise.
* recog.c (decode_asm_operands): Likewise.
* toplev.c (rest_of_compilation): Likewise.
* tree.h (emit_line_note_after, emit_line_note,
emit_line_note_force): Likewise.
* varasm.c (asm_output_bss, asm_output_aligned_bss,
asm_emit_uninitialised, assemble_start_function,
assemble_variable, const_hash, compare_constant_1,
find_pool_constant, mark_constant_pool, assemble_alias): Likewise.
* xcoffout.h (DBX_FINISH_SYMBOL): Likewise.
* alpha/alpha.md (call_vms, call_value_vms): Likewise.
* arm/aof.h (ASM_OUTPUT_ASCII): Likewise.
* arm/aout.h (ASM_OUTPUT_ASCII): Likewise.
* arm/arm-protos.h (output_ascii_pseudo_op, arm_dllexport_name_p,
arm_dllimport_name_p): Likewise.
* arm/arm.c (arm_encode_call_attribute, output_ascii_pseudo_op):
Likewise.
* arm/arm.h (ASM_OUTPUT_MI_THUNK): Likewise.
* arm/elf.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* arm/pe.c (arm_dllexport_name_p, arm_dllimport_name_p,
arm_mark_dllexport, arm_mark_dllimport,
arm_pe_encode_section_info): Likewise.
* arm/telf.h (ASM_OUTPUT_DEF_FROM_DECLS,
ASM_FINISH_DECLARE_OBJECT): Likewise.
* arm/thumb.c (thumb_function_prologue): Likewise.
* arm/thumb.h (ASM_OUTPUT_ASCII): Likewise.
* avr/avr.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* clipper/clix.h (ASM_OUTPUT_ASCII): Likewise.
* fx80/fx80.h (ASM_OUTPUT_ASCII): Likewise.
* i386/cygwin.h (ASM_OUTPUT_SECTION_NAME): Likewise.
* i386/freebsd.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* i386/i386-interix.h (ASM_OUTPUT_LIMITED_STRING,
ASM_OUTPUT_ASCII, ASM_OUTPUT_SECTION_NAME): Likewise.
* i386/i386-protos.h (asm_output_function_prefix): Likewise.
* i386/i386.c (asm_output_function_prefix): Likewise.
* i386/i386elf.h (ASM_OUTPUT_ASCII): Likewise.
* i386/osfrose.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* i386/ptx4-i.h (ASM_OUTPUT_ASCII): Likewise.
* i386/sco5.h (ASM_FINISH_DECLARE_OBJECT,
ASM_OUTPUT_LIMITED_STRING, ASM_OUTPUT_ASCII,
ASM_OUTPUT_SECTION_NAME): Likewise.
* i386/sysv4.h (ASM_OUTPUT_ASCII): Likewise.
* i860/paragon.h (ASM_OUTPUT_ASCII): Likewise.
* i860/sysv3.h (ASM_OUTPUT_ASCII): Likewise.
* m32r/m32r.c (m32r_encode_section_info): Likewise.
* mcore-elf.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* mcore/mcore.c (mcore_encode_section_info): Likewise.
* mips/elf.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* mips/elf64.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* mips/iris6.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* mips/mips.h (ASM_OUTPUT_IDENT): Likewise.
* mips/mips.md (movdi, movsi): Likewise.
* mips/netbsd.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* netbsd.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* openbsd.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* ptx4.h (ASM_FINISH_DECLARE_OBJECT, ASM_OUTPUT_LIMITED_STRING,
ASM_OUTPUT_ASCII): Likewise.
* rs6000/rs6000.c (rs6000_allocate_stack_space, output_epilog,
output_mi_thunk, output_toc): Likewise.
* rs6000/rs6000.md (movsi): Likewise.
* rs6000/sysv4.h (ASM_OUTPUT_INT, ASM_OUTPUT_SECTION_NAME): Likewise.
* tahoe/harris.h (ASM_OUTPUT_ASCII): Likewise.
* v850/v850.c (print_operand, print_operand_address,
v850_encode_data_area): Likewise.
ch:
* grant.c (globalize_decl): Constify a char*.
cp:
* decl2.c (finish_objects): Constify a char*.
* method.c (emit_thunk): Likewise.
From-SVN: r32388
2000-03-07 21:39:10 +01:00
|
|
|
|
const void *p;
|
1999-09-23 22:00:57 +02:00
|
|
|
|
{
|
|
|
|
|
page_entry *entry;
|
|
|
|
|
unsigned bit, word;
|
|
|
|
|
unsigned long mask;
|
|
|
|
|
|
|
|
|
|
/* Look up the page on which the object is alloced. If the object
|
|
|
|
|
wasn't allocated by the collector, we'll probably die. */
|
1999-10-11 04:11:21 +02:00
|
|
|
|
entry = lookup_page_table_entry (p);
|
1999-09-23 22:00:57 +02:00
|
|
|
|
#ifdef ENABLE_CHECKING
|
|
|
|
|
if (entry == NULL)
|
|
|
|
|
abort ();
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* Calculate the index of the object on the page; this is its bit
|
|
|
|
|
position in the in_use_p bitmap. */
|
rtl.h (rtunion_def): Constify member `rtstr'.
* rtl.h (rtunion_def): Constify member `rtstr'.
(emit_line_note_after, emit_line_note, emit_line_note_force,
emit_note, decode_asm_operands): Constify.
* cse.c (canon_hash): Likewise.
* dbxout.c (dbxout_block): Likewise.
* diagnostic.c (file_and_line_for_asm, v_error_for_asm,
v_warning_for_asm): Likewise.
* dwarfout.c (function_start_label): Likewise.
* emit-rtl.c (emit_line_note_after, emit_line_note, emit_note,
emit_line_note_force): Likewise.
* final.c (last_filename, asm_insn_count, final_scan_insn,
output_source_line): Likewise.
* function.h (struct emit_status): Likewise.
* gcse.c (hash_expr_1): Likewise.
* genattr.c (gen_attr, main): Likewise.
* genattrtab.c (struct function_unit, current_alternative_string,
write_attr_valueq, n_comma_elts, next_comma_elt, attr_eq,
attr_numeral, check_attr_test, check_attr_value,
convert_set_attr_alternative, convert_set_attr,
compute_alternative_mask, simplify_by_exploding, gen_attr,
gen_unit): Likewise.
* genflags.c (gen_insn): Likewise.
* gengenrtl.c (type_from_format): Likewise.
* genopinit.c (gen_insn): Likewise.
* genoutput.c (n_occurrences, process_template, process_template):
Likewise.
* ggc-page.c (ggc_set_mark, ggc_mark_if_gcable, ggc_get_size):
Likewise.
* ggc-simple.c (ggc_set_mark, ggc_mark_if_gcable, ggc_get_size):
Likewise.
* ggc.h (ggc_mark_string, ggc_mark, ggc_mark_if_gcable,
ggc_set_mark, ggc_get_size): Likewise.
* objc/objc-act.c (build_module_descriptor, finish_objc): Likewise.
* optabs.c (init_one_libfunc): Likewise.
* output.h (assemble_start_function): Likewise.
* recog.c (decode_asm_operands): Likewise.
* toplev.c (rest_of_compilation): Likewise.
* tree.h (emit_line_note_after, emit_line_note,
emit_line_note_force): Likewise.
* varasm.c (asm_output_bss, asm_output_aligned_bss,
asm_emit_uninitialised, assemble_start_function,
assemble_variable, const_hash, compare_constant_1,
find_pool_constant, mark_constant_pool, assemble_alias): Likewise.
* xcoffout.h (DBX_FINISH_SYMBOL): Likewise.
* alpha/alpha.md (call_vms, call_value_vms): Likewise.
* arm/aof.h (ASM_OUTPUT_ASCII): Likewise.
* arm/aout.h (ASM_OUTPUT_ASCII): Likewise.
* arm/arm-protos.h (output_ascii_pseudo_op, arm_dllexport_name_p,
arm_dllimport_name_p): Likewise.
* arm/arm.c (arm_encode_call_attribute, output_ascii_pseudo_op):
Likewise.
* arm/arm.h (ASM_OUTPUT_MI_THUNK): Likewise.
* arm/elf.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* arm/pe.c (arm_dllexport_name_p, arm_dllimport_name_p,
arm_mark_dllexport, arm_mark_dllimport,
arm_pe_encode_section_info): Likewise.
* arm/telf.h (ASM_OUTPUT_DEF_FROM_DECLS,
ASM_FINISH_DECLARE_OBJECT): Likewise.
* arm/thumb.c (thumb_function_prologue): Likewise.
* arm/thumb.h (ASM_OUTPUT_ASCII): Likewise.
* avr/avr.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* clipper/clix.h (ASM_OUTPUT_ASCII): Likewise.
* fx80/fx80.h (ASM_OUTPUT_ASCII): Likewise.
* i386/cygwin.h (ASM_OUTPUT_SECTION_NAME): Likewise.
* i386/freebsd.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* i386/i386-interix.h (ASM_OUTPUT_LIMITED_STRING,
ASM_OUTPUT_ASCII, ASM_OUTPUT_SECTION_NAME): Likewise.
* i386/i386-protos.h (asm_output_function_prefix): Likewise.
* i386/i386.c (asm_output_function_prefix): Likewise.
* i386/i386elf.h (ASM_OUTPUT_ASCII): Likewise.
* i386/osfrose.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* i386/ptx4-i.h (ASM_OUTPUT_ASCII): Likewise.
* i386/sco5.h (ASM_FINISH_DECLARE_OBJECT,
ASM_OUTPUT_LIMITED_STRING, ASM_OUTPUT_ASCII,
ASM_OUTPUT_SECTION_NAME): Likewise.
* i386/sysv4.h (ASM_OUTPUT_ASCII): Likewise.
* i860/paragon.h (ASM_OUTPUT_ASCII): Likewise.
* i860/sysv3.h (ASM_OUTPUT_ASCII): Likewise.
* m32r/m32r.c (m32r_encode_section_info): Likewise.
* mcore-elf.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* mcore/mcore.c (mcore_encode_section_info): Likewise.
* mips/elf.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* mips/elf64.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* mips/iris6.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* mips/mips.h (ASM_OUTPUT_IDENT): Likewise.
* mips/mips.md (movdi, movsi): Likewise.
* mips/netbsd.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* netbsd.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* openbsd.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* ptx4.h (ASM_FINISH_DECLARE_OBJECT, ASM_OUTPUT_LIMITED_STRING,
ASM_OUTPUT_ASCII): Likewise.
* rs6000/rs6000.c (rs6000_allocate_stack_space, output_epilog,
output_mi_thunk, output_toc): Likewise.
* rs6000/rs6000.md (movsi): Likewise.
* rs6000/sysv4.h (ASM_OUTPUT_INT, ASM_OUTPUT_SECTION_NAME): Likewise.
* tahoe/harris.h (ASM_OUTPUT_ASCII): Likewise.
* v850/v850.c (print_operand, print_operand_address,
v850_encode_data_area): Likewise.
ch:
* grant.c (globalize_decl): Constify a char*.
cp:
* decl2.c (finish_objects): Constify a char*.
* method.c (emit_thunk): Likewise.
From-SVN: r32388
2000-03-07 21:39:10 +01:00
|
|
|
|
bit = (((const char *) p) - entry->page) >> entry->order;
|
1999-09-23 22:00:57 +02:00
|
|
|
|
word = bit / HOST_BITS_PER_LONG;
|
|
|
|
|
mask = (unsigned long) 1 << (bit % HOST_BITS_PER_LONG);
|
|
|
|
|
|
|
|
|
|
/* If the bit was previously set, skip it. */
|
|
|
|
|
if (entry->in_use_p[word] & mask)
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
/* Otherwise set it, and decrement the free object count. */
|
|
|
|
|
entry->in_use_p[word] |= mask;
|
|
|
|
|
entry->num_free_objects -= 1;
|
|
|
|
|
|
|
|
|
|
G.allocated += (size_t) 1 << entry->order;
|
|
|
|
|
|
|
|
|
|
if (GGC_DEBUG_LEVEL >= 4)
|
|
|
|
|
fprintf (G.debug_file, "Marking %p\n", p);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
1999-10-30 23:36:13 +02:00
|
|
|
|
/* Mark P, but check first that it was allocated by the collector. */
|
|
|
|
|
|
1999-10-13 19:09:18 +02:00
|
|
|
|
void
|
|
|
|
|
ggc_mark_if_gcable (p)
|
rtl.h (rtunion_def): Constify member `rtstr'.
* rtl.h (rtunion_def): Constify member `rtstr'.
(emit_line_note_after, emit_line_note, emit_line_note_force,
emit_note, decode_asm_operands): Constify.
* cse.c (canon_hash): Likewise.
* dbxout.c (dbxout_block): Likewise.
* diagnostic.c (file_and_line_for_asm, v_error_for_asm,
v_warning_for_asm): Likewise.
* dwarfout.c (function_start_label): Likewise.
* emit-rtl.c (emit_line_note_after, emit_line_note, emit_note,
emit_line_note_force): Likewise.
* final.c (last_filename, asm_insn_count, final_scan_insn,
output_source_line): Likewise.
* function.h (struct emit_status): Likewise.
* gcse.c (hash_expr_1): Likewise.
* genattr.c (gen_attr, main): Likewise.
* genattrtab.c (struct function_unit, current_alternative_string,
write_attr_valueq, n_comma_elts, next_comma_elt, attr_eq,
attr_numeral, check_attr_test, check_attr_value,
convert_set_attr_alternative, convert_set_attr,
compute_alternative_mask, simplify_by_exploding, gen_attr,
gen_unit): Likewise.
* genflags.c (gen_insn): Likewise.
* gengenrtl.c (type_from_format): Likewise.
* genopinit.c (gen_insn): Likewise.
* genoutput.c (n_occurrences, process_template, process_template):
Likewise.
* ggc-page.c (ggc_set_mark, ggc_mark_if_gcable, ggc_get_size):
Likewise.
* ggc-simple.c (ggc_set_mark, ggc_mark_if_gcable, ggc_get_size):
Likewise.
* ggc.h (ggc_mark_string, ggc_mark, ggc_mark_if_gcable,
ggc_set_mark, ggc_get_size): Likewise.
* objc/objc-act.c (build_module_descriptor, finish_objc): Likewise.
* optabs.c (init_one_libfunc): Likewise.
* output.h (assemble_start_function): Likewise.
* recog.c (decode_asm_operands): Likewise.
* toplev.c (rest_of_compilation): Likewise.
* tree.h (emit_line_note_after, emit_line_note,
emit_line_note_force): Likewise.
* varasm.c (asm_output_bss, asm_output_aligned_bss,
asm_emit_uninitialised, assemble_start_function,
assemble_variable, const_hash, compare_constant_1,
find_pool_constant, mark_constant_pool, assemble_alias): Likewise.
* xcoffout.h (DBX_FINISH_SYMBOL): Likewise.
* alpha/alpha.md (call_vms, call_value_vms): Likewise.
* arm/aof.h (ASM_OUTPUT_ASCII): Likewise.
* arm/aout.h (ASM_OUTPUT_ASCII): Likewise.
* arm/arm-protos.h (output_ascii_pseudo_op, arm_dllexport_name_p,
arm_dllimport_name_p): Likewise.
* arm/arm.c (arm_encode_call_attribute, output_ascii_pseudo_op):
Likewise.
* arm/arm.h (ASM_OUTPUT_MI_THUNK): Likewise.
* arm/elf.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* arm/pe.c (arm_dllexport_name_p, arm_dllimport_name_p,
arm_mark_dllexport, arm_mark_dllimport,
arm_pe_encode_section_info): Likewise.
* arm/telf.h (ASM_OUTPUT_DEF_FROM_DECLS,
ASM_FINISH_DECLARE_OBJECT): Likewise.
* arm/thumb.c (thumb_function_prologue): Likewise.
* arm/thumb.h (ASM_OUTPUT_ASCII): Likewise.
* avr/avr.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* clipper/clix.h (ASM_OUTPUT_ASCII): Likewise.
* fx80/fx80.h (ASM_OUTPUT_ASCII): Likewise.
* i386/cygwin.h (ASM_OUTPUT_SECTION_NAME): Likewise.
* i386/freebsd.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* i386/i386-interix.h (ASM_OUTPUT_LIMITED_STRING,
ASM_OUTPUT_ASCII, ASM_OUTPUT_SECTION_NAME): Likewise.
* i386/i386-protos.h (asm_output_function_prefix): Likewise.
* i386/i386.c (asm_output_function_prefix): Likewise.
* i386/i386elf.h (ASM_OUTPUT_ASCII): Likewise.
* i386/osfrose.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* i386/ptx4-i.h (ASM_OUTPUT_ASCII): Likewise.
* i386/sco5.h (ASM_FINISH_DECLARE_OBJECT,
ASM_OUTPUT_LIMITED_STRING, ASM_OUTPUT_ASCII,
ASM_OUTPUT_SECTION_NAME): Likewise.
* i386/sysv4.h (ASM_OUTPUT_ASCII): Likewise.
* i860/paragon.h (ASM_OUTPUT_ASCII): Likewise.
* i860/sysv3.h (ASM_OUTPUT_ASCII): Likewise.
* m32r/m32r.c (m32r_encode_section_info): Likewise.
* mcore-elf.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* mcore/mcore.c (mcore_encode_section_info): Likewise.
* mips/elf.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* mips/elf64.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* mips/iris6.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* mips/mips.h (ASM_OUTPUT_IDENT): Likewise.
* mips/mips.md (movdi, movsi): Likewise.
* mips/netbsd.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* netbsd.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* openbsd.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* ptx4.h (ASM_FINISH_DECLARE_OBJECT, ASM_OUTPUT_LIMITED_STRING,
ASM_OUTPUT_ASCII): Likewise.
* rs6000/rs6000.c (rs6000_allocate_stack_space, output_epilog,
output_mi_thunk, output_toc): Likewise.
* rs6000/rs6000.md (movsi): Likewise.
* rs6000/sysv4.h (ASM_OUTPUT_INT, ASM_OUTPUT_SECTION_NAME): Likewise.
* tahoe/harris.h (ASM_OUTPUT_ASCII): Likewise.
* v850/v850.c (print_operand, print_operand_address,
v850_encode_data_area): Likewise.
ch:
* grant.c (globalize_decl): Constify a char*.
cp:
* decl2.c (finish_objects): Constify a char*.
* method.c (emit_thunk): Likewise.
From-SVN: r32388
2000-03-07 21:39:10 +01:00
|
|
|
|
const void *p;
|
1999-10-13 19:09:18 +02:00
|
|
|
|
{
|
|
|
|
|
if (p && ggc_allocated_p (p))
|
|
|
|
|
ggc_set_mark (p);
|
|
|
|
|
}
|
1999-10-29 06:17:33 +02:00
|
|
|
|
|
1999-10-30 23:36:13 +02:00
|
|
|
|
/* Return the size of the gc-able object P. */
|
|
|
|
|
|
1999-10-29 06:17:33 +02:00
|
|
|
|
size_t
|
|
|
|
|
ggc_get_size (p)
|
rtl.h (rtunion_def): Constify member `rtstr'.
* rtl.h (rtunion_def): Constify member `rtstr'.
(emit_line_note_after, emit_line_note, emit_line_note_force,
emit_note, decode_asm_operands): Constify.
* cse.c (canon_hash): Likewise.
* dbxout.c (dbxout_block): Likewise.
* diagnostic.c (file_and_line_for_asm, v_error_for_asm,
v_warning_for_asm): Likewise.
* dwarfout.c (function_start_label): Likewise.
* emit-rtl.c (emit_line_note_after, emit_line_note, emit_note,
emit_line_note_force): Likewise.
* final.c (last_filename, asm_insn_count, final_scan_insn,
output_source_line): Likewise.
* function.h (struct emit_status): Likewise.
* gcse.c (hash_expr_1): Likewise.
* genattr.c (gen_attr, main): Likewise.
* genattrtab.c (struct function_unit, current_alternative_string,
write_attr_valueq, n_comma_elts, next_comma_elt, attr_eq,
attr_numeral, check_attr_test, check_attr_value,
convert_set_attr_alternative, convert_set_attr,
compute_alternative_mask, simplify_by_exploding, gen_attr,
gen_unit): Likewise.
* genflags.c (gen_insn): Likewise.
* gengenrtl.c (type_from_format): Likewise.
* genopinit.c (gen_insn): Likewise.
* genoutput.c (n_occurrences, process_template, process_template):
Likewise.
* ggc-page.c (ggc_set_mark, ggc_mark_if_gcable, ggc_get_size):
Likewise.
* ggc-simple.c (ggc_set_mark, ggc_mark_if_gcable, ggc_get_size):
Likewise.
* ggc.h (ggc_mark_string, ggc_mark, ggc_mark_if_gcable,
ggc_set_mark, ggc_get_size): Likewise.
* objc/objc-act.c (build_module_descriptor, finish_objc): Likewise.
* optabs.c (init_one_libfunc): Likewise.
* output.h (assemble_start_function): Likewise.
* recog.c (decode_asm_operands): Likewise.
* toplev.c (rest_of_compilation): Likewise.
* tree.h (emit_line_note_after, emit_line_note,
emit_line_note_force): Likewise.
* varasm.c (asm_output_bss, asm_output_aligned_bss,
asm_emit_uninitialised, assemble_start_function,
assemble_variable, const_hash, compare_constant_1,
find_pool_constant, mark_constant_pool, assemble_alias): Likewise.
* xcoffout.h (DBX_FINISH_SYMBOL): Likewise.
* alpha/alpha.md (call_vms, call_value_vms): Likewise.
* arm/aof.h (ASM_OUTPUT_ASCII): Likewise.
* arm/aout.h (ASM_OUTPUT_ASCII): Likewise.
* arm/arm-protos.h (output_ascii_pseudo_op, arm_dllexport_name_p,
arm_dllimport_name_p): Likewise.
* arm/arm.c (arm_encode_call_attribute, output_ascii_pseudo_op):
Likewise.
* arm/arm.h (ASM_OUTPUT_MI_THUNK): Likewise.
* arm/elf.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* arm/pe.c (arm_dllexport_name_p, arm_dllimport_name_p,
arm_mark_dllexport, arm_mark_dllimport,
arm_pe_encode_section_info): Likewise.
* arm/telf.h (ASM_OUTPUT_DEF_FROM_DECLS,
ASM_FINISH_DECLARE_OBJECT): Likewise.
* arm/thumb.c (thumb_function_prologue): Likewise.
* arm/thumb.h (ASM_OUTPUT_ASCII): Likewise.
* avr/avr.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* clipper/clix.h (ASM_OUTPUT_ASCII): Likewise.
* fx80/fx80.h (ASM_OUTPUT_ASCII): Likewise.
* i386/cygwin.h (ASM_OUTPUT_SECTION_NAME): Likewise.
* i386/freebsd.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* i386/i386-interix.h (ASM_OUTPUT_LIMITED_STRING,
ASM_OUTPUT_ASCII, ASM_OUTPUT_SECTION_NAME): Likewise.
* i386/i386-protos.h (asm_output_function_prefix): Likewise.
* i386/i386.c (asm_output_function_prefix): Likewise.
* i386/i386elf.h (ASM_OUTPUT_ASCII): Likewise.
* i386/osfrose.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* i386/ptx4-i.h (ASM_OUTPUT_ASCII): Likewise.
* i386/sco5.h (ASM_FINISH_DECLARE_OBJECT,
ASM_OUTPUT_LIMITED_STRING, ASM_OUTPUT_ASCII,
ASM_OUTPUT_SECTION_NAME): Likewise.
* i386/sysv4.h (ASM_OUTPUT_ASCII): Likewise.
* i860/paragon.h (ASM_OUTPUT_ASCII): Likewise.
* i860/sysv3.h (ASM_OUTPUT_ASCII): Likewise.
* m32r/m32r.c (m32r_encode_section_info): Likewise.
* mcore-elf.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* mcore/mcore.c (mcore_encode_section_info): Likewise.
* mips/elf.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* mips/elf64.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* mips/iris6.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* mips/mips.h (ASM_OUTPUT_IDENT): Likewise.
* mips/mips.md (movdi, movsi): Likewise.
* mips/netbsd.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* netbsd.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* openbsd.h (ASM_FINISH_DECLARE_OBJECT): Likewise.
* ptx4.h (ASM_FINISH_DECLARE_OBJECT, ASM_OUTPUT_LIMITED_STRING,
ASM_OUTPUT_ASCII): Likewise.
* rs6000/rs6000.c (rs6000_allocate_stack_space, output_epilog,
output_mi_thunk, output_toc): Likewise.
* rs6000/rs6000.md (movsi): Likewise.
* rs6000/sysv4.h (ASM_OUTPUT_INT, ASM_OUTPUT_SECTION_NAME): Likewise.
* tahoe/harris.h (ASM_OUTPUT_ASCII): Likewise.
* v850/v850.c (print_operand, print_operand_address,
v850_encode_data_area): Likewise.
ch:
* grant.c (globalize_decl): Constify a char*.
cp:
* decl2.c (finish_objects): Constify a char*.
* method.c (emit_thunk): Likewise.
From-SVN: r32388
2000-03-07 21:39:10 +01:00
|
|
|
|
const void *p;
|
1999-10-29 06:17:33 +02:00
|
|
|
|
{
|
|
|
|
|
page_entry *pe = lookup_page_table_entry (p);
|
|
|
|
|
return 1 << pe->order;
|
|
|
|
|
}
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
|
|
|
|
/* Initialize the ggc-mmap allocator. */
|
1999-10-30 23:36:13 +02:00
|
|
|
|
|
1999-09-23 22:00:57 +02:00
|
|
|
|
void
|
|
|
|
|
init_ggc ()
|
|
|
|
|
{
|
|
|
|
|
G.pagesize = getpagesize();
|
|
|
|
|
G.lg_pagesize = exact_log2 (G.pagesize);
|
|
|
|
|
|
2000-01-16 19:16:55 +01:00
|
|
|
|
#if defined (HAVE_MMAP_ANYWHERE) && !defined(MAP_ANONYMOUS)
|
1999-09-23 22:00:57 +02:00
|
|
|
|
G.dev_zero_fd = open ("/dev/zero", O_RDONLY);
|
|
|
|
|
if (G.dev_zero_fd == -1)
|
|
|
|
|
abort ();
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
|
G.debug_file = fopen ("ggc-mmap.debug", "w");
|
|
|
|
|
#else
|
|
|
|
|
G.debug_file = stdout;
|
|
|
|
|
#endif
|
|
|
|
|
|
1999-09-28 08:05:53 +02:00
|
|
|
|
G.allocated_last_gc = GGC_MIN_LAST_ALLOCATED;
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
2000-01-16 19:16:55 +01:00
|
|
|
|
#ifdef HAVE_MMAP_ANYWHERE
|
1999-10-18 18:38:40 +02:00
|
|
|
|
/* StunOS has an amazing off-by-one error for the first mmap allocation
|
|
|
|
|
after fiddling with RLIMIT_STACK. The result, as hard as it is to
|
|
|
|
|
believe, is an unaligned page allocation, which would cause us to
|
|
|
|
|
hork badly if we tried to use it. */
|
|
|
|
|
{
|
|
|
|
|
char *p = alloc_anon (NULL, G.pagesize);
|
|
|
|
|
if ((size_t)p & (G.pagesize - 1))
|
|
|
|
|
{
|
|
|
|
|
/* How losing. Discard this one and try another. If we still
|
|
|
|
|
can't get something useful, give up. */
|
|
|
|
|
|
|
|
|
|
p = alloc_anon (NULL, G.pagesize);
|
|
|
|
|
if ((size_t)p & (G.pagesize - 1))
|
|
|
|
|
abort ();
|
|
|
|
|
}
|
|
|
|
|
munmap (p, G.pagesize);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
1999-09-23 22:00:57 +02:00
|
|
|
|
empty_string = ggc_alloc_string ("", 0);
|
|
|
|
|
ggc_add_string_root (&empty_string, 1);
|
|
|
|
|
}
|
|
|
|
|
|
1999-10-30 23:36:13 +02:00
|
|
|
|
/* Increment the `GC context'. Objects allocated in an outer context
|
|
|
|
|
are never freed, eliminating the need to register their roots. */
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
ggc_push_context ()
|
|
|
|
|
{
|
|
|
|
|
++G.context_depth;
|
|
|
|
|
|
|
|
|
|
/* Die on wrap. */
|
|
|
|
|
if (G.context_depth == 0)
|
|
|
|
|
abort ();
|
|
|
|
|
}
|
|
|
|
|
|
1999-11-01 07:57:01 +01:00
|
|
|
|
/* Merge the SAVE_IN_USE_P and IN_USE_P arrays in P so that IN_USE_P
|
|
|
|
|
reflects reality. Recalculate NUM_FREE_OBJECTS as well. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
ggc_recalculate_in_use_p (p)
|
|
|
|
|
page_entry *p;
|
|
|
|
|
{
|
|
|
|
|
unsigned int i;
|
|
|
|
|
size_t num_objects;
|
|
|
|
|
|
|
|
|
|
/* Because the past-the-end bit in in_use_p is always set, we
|
|
|
|
|
pretend there is one additional object. */
|
|
|
|
|
num_objects = OBJECTS_PER_PAGE (p->order) + 1;
|
|
|
|
|
|
|
|
|
|
/* Reset the free object count. */
|
|
|
|
|
p->num_free_objects = num_objects;
|
|
|
|
|
|
|
|
|
|
/* Combine the IN_USE_P and SAVE_IN_USE_P arrays. */
|
|
|
|
|
for (i = 0;
|
|
|
|
|
i < DIV_ROUND_UP (BITMAP_SIZE (num_objects),
|
|
|
|
|
sizeof (*p->in_use_p));
|
|
|
|
|
++i)
|
|
|
|
|
{
|
|
|
|
|
unsigned long j;
|
|
|
|
|
|
|
|
|
|
/* Something is in use if it is marked, or if it was in use in a
|
|
|
|
|
context further down the context stack. */
|
|
|
|
|
p->in_use_p[i] |= p->save_in_use_p[i];
|
|
|
|
|
|
|
|
|
|
/* Decrement the free object count for every object allocated. */
|
|
|
|
|
for (j = p->in_use_p[i]; j; j >>= 1)
|
|
|
|
|
p->num_free_objects -= (j & 1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (p->num_free_objects >= num_objects)
|
|
|
|
|
abort ();
|
|
|
|
|
}
|
|
|
|
|
|
1999-10-30 23:36:13 +02:00
|
|
|
|
/* Decrement the `GC context'. All objects allocated since the
|
|
|
|
|
previous ggc_push_context are migrated to the outer context. */
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
ggc_pop_context ()
|
|
|
|
|
{
|
|
|
|
|
unsigned order, depth;
|
|
|
|
|
|
|
|
|
|
depth = --G.context_depth;
|
|
|
|
|
|
|
|
|
|
/* Any remaining pages in the popped context are lowered to the new
|
|
|
|
|
current context; i.e. objects allocated in the popped context and
|
|
|
|
|
left over are imported into the previous context. */
|
|
|
|
|
for (order = 2; order < HOST_BITS_PER_PTR; order++)
|
|
|
|
|
{
|
|
|
|
|
page_entry *p;
|
|
|
|
|
|
|
|
|
|
for (p = G.pages[order]; p != NULL; p = p->next)
|
|
|
|
|
{
|
|
|
|
|
if (p->context_depth > depth)
|
1999-11-01 07:57:01 +01:00
|
|
|
|
p->context_depth = depth;
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
|
|
|
|
/* If this page is now in the topmost context, and we'd
|
|
|
|
|
saved its allocation state, restore it. */
|
|
|
|
|
else if (p->context_depth == depth && p->save_in_use_p)
|
|
|
|
|
{
|
1999-11-01 07:57:01 +01:00
|
|
|
|
ggc_recalculate_in_use_p (p);
|
1999-09-23 22:00:57 +02:00
|
|
|
|
free (p->save_in_use_p);
|
|
|
|
|
p->save_in_use_p = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
1999-10-30 23:36:13 +02:00
|
|
|
|
/* Unmark all objects. */
|
|
|
|
|
|
1999-09-23 22:00:57 +02:00
|
|
|
|
static inline void
|
|
|
|
|
clear_marks ()
|
|
|
|
|
{
|
|
|
|
|
unsigned order;
|
|
|
|
|
|
|
|
|
|
for (order = 2; order < HOST_BITS_PER_PTR; order++)
|
|
|
|
|
{
|
|
|
|
|
size_t num_objects = OBJECTS_PER_PAGE (order);
|
1999-11-01 07:57:01 +01:00
|
|
|
|
size_t bitmap_size = BITMAP_SIZE (num_objects + 1);
|
1999-09-23 22:00:57 +02:00
|
|
|
|
page_entry *p;
|
|
|
|
|
|
|
|
|
|
for (p = G.pages[order]; p != NULL; p = p->next)
|
|
|
|
|
{
|
|
|
|
|
#ifdef ENABLE_CHECKING
|
|
|
|
|
/* The data should be page-aligned. */
|
|
|
|
|
if ((size_t) p->page & (G.pagesize - 1))
|
|
|
|
|
abort ();
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* Pages that aren't in the topmost context are not collected;
|
|
|
|
|
nevertheless, we need their in-use bit vectors to store GC
|
|
|
|
|
marks. So, back them up first. */
|
1999-11-01 07:57:01 +01:00
|
|
|
|
if (p->context_depth < G.context_depth)
|
1999-09-23 22:00:57 +02:00
|
|
|
|
{
|
1999-11-01 07:57:01 +01:00
|
|
|
|
if (! p->save_in_use_p)
|
|
|
|
|
p->save_in_use_p = xmalloc (bitmap_size);
|
1999-09-23 22:00:57 +02:00
|
|
|
|
memcpy (p->save_in_use_p, p->in_use_p, bitmap_size);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Reset reset the number of free objects and clear the
|
|
|
|
|
in-use bits. These will be adjusted by mark_obj. */
|
|
|
|
|
p->num_free_objects = num_objects;
|
|
|
|
|
memset (p->in_use_p, 0, bitmap_size);
|
|
|
|
|
|
|
|
|
|
/* Make sure the one-past-the-end bit is always set. */
|
|
|
|
|
p->in_use_p[num_objects / HOST_BITS_PER_LONG]
|
|
|
|
|
= ((unsigned long) 1 << (num_objects % HOST_BITS_PER_LONG));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
1999-10-30 23:36:13 +02:00
|
|
|
|
/* Free all empty pages. Partially empty pages need no attention
|
|
|
|
|
because the `mark' bit doubles as an `unused' bit. */
|
|
|
|
|
|
1999-09-23 22:00:57 +02:00
|
|
|
|
static inline void
|
|
|
|
|
sweep_pages ()
|
|
|
|
|
{
|
|
|
|
|
unsigned order;
|
|
|
|
|
|
|
|
|
|
for (order = 2; order < HOST_BITS_PER_PTR; order++)
|
|
|
|
|
{
|
|
|
|
|
/* The last page-entry to consider, regardless of entries
|
|
|
|
|
placed at the end of the list. */
|
|
|
|
|
page_entry * const last = G.page_tails[order];
|
|
|
|
|
|
|
|
|
|
size_t num_objects = OBJECTS_PER_PAGE (order);
|
|
|
|
|
page_entry *p, *previous;
|
|
|
|
|
int done;
|
|
|
|
|
|
|
|
|
|
p = G.pages[order];
|
|
|
|
|
if (p == NULL)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
previous = NULL;
|
|
|
|
|
do
|
|
|
|
|
{
|
|
|
|
|
page_entry *next = p->next;
|
|
|
|
|
|
|
|
|
|
/* Loop until all entries have been examined. */
|
|
|
|
|
done = (p == last);
|
|
|
|
|
|
|
|
|
|
/* Only objects on pages in the topmost context should get
|
|
|
|
|
collected. */
|
|
|
|
|
if (p->context_depth < G.context_depth)
|
|
|
|
|
;
|
|
|
|
|
|
|
|
|
|
/* Remove the page if it's empty. */
|
|
|
|
|
else if (p->num_free_objects == num_objects)
|
|
|
|
|
{
|
|
|
|
|
if (! previous)
|
|
|
|
|
G.pages[order] = next;
|
|
|
|
|
else
|
|
|
|
|
previous->next = next;
|
|
|
|
|
|
|
|
|
|
/* Are we removing the last element? */
|
|
|
|
|
if (p == G.page_tails[order])
|
|
|
|
|
G.page_tails[order] = previous;
|
|
|
|
|
free_page (p);
|
|
|
|
|
p = previous;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* If the page is full, move it to the end. */
|
|
|
|
|
else if (p->num_free_objects == 0)
|
|
|
|
|
{
|
|
|
|
|
/* Don't move it if it's already at the end. */
|
|
|
|
|
if (p != G.page_tails[order])
|
|
|
|
|
{
|
|
|
|
|
/* Move p to the end of the list. */
|
|
|
|
|
p->next = NULL;
|
|
|
|
|
G.page_tails[order]->next = p;
|
|
|
|
|
|
|
|
|
|
/* Update the tail pointer... */
|
|
|
|
|
G.page_tails[order] = p;
|
|
|
|
|
|
|
|
|
|
/* ... and the head pointer, if necessary. */
|
|
|
|
|
if (! previous)
|
|
|
|
|
G.pages[order] = next;
|
|
|
|
|
else
|
|
|
|
|
previous->next = next;
|
|
|
|
|
p = previous;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* If we've fallen through to here, it's a page in the
|
|
|
|
|
topmost context that is neither full nor empty. Such a
|
|
|
|
|
page must precede pages at lesser context depth in the
|
|
|
|
|
list, so move it to the head. */
|
|
|
|
|
else if (p != G.pages[order])
|
|
|
|
|
{
|
|
|
|
|
previous->next = p->next;
|
|
|
|
|
p->next = G.pages[order];
|
|
|
|
|
G.pages[order] = p;
|
|
|
|
|
/* Are we moving the last element? */
|
|
|
|
|
if (G.page_tails[order] == p)
|
|
|
|
|
G.page_tails[order] = previous;
|
|
|
|
|
p = previous;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
previous = p;
|
|
|
|
|
p = next;
|
|
|
|
|
}
|
|
|
|
|
while (! done);
|
1999-11-01 07:57:01 +01:00
|
|
|
|
|
|
|
|
|
/* Now, restore the in_use_p vectors for any pages from contexts
|
|
|
|
|
other than the current one. */
|
|
|
|
|
for (p = G.pages[order]; p; p = p->next)
|
|
|
|
|
if (p->context_depth != G.context_depth)
|
|
|
|
|
ggc_recalculate_in_use_p (p);
|
1999-09-23 22:00:57 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef GGC_POISON
|
1999-10-30 23:36:13 +02:00
|
|
|
|
/* Clobber all free objects. */
|
|
|
|
|
|
1999-09-23 22:00:57 +02:00
|
|
|
|
static inline void
|
|
|
|
|
poison_pages ()
|
|
|
|
|
{
|
|
|
|
|
unsigned order;
|
|
|
|
|
|
|
|
|
|
for (order = 2; order < HOST_BITS_PER_PTR; order++)
|
|
|
|
|
{
|
|
|
|
|
size_t num_objects = OBJECTS_PER_PAGE (order);
|
|
|
|
|
size_t size = (size_t) 1 << order;
|
|
|
|
|
page_entry *p;
|
|
|
|
|
|
|
|
|
|
for (p = G.pages[order]; p != NULL; p = p->next)
|
|
|
|
|
{
|
|
|
|
|
size_t i;
|
1999-10-27 08:12:31 +02:00
|
|
|
|
|
|
|
|
|
if (p->context_depth != G.context_depth)
|
|
|
|
|
/* Since we don't do any collection for pages in pushed
|
|
|
|
|
contexts, there's no need to do any poisoning. And
|
|
|
|
|
besides, the IN_USE_P array isn't valid until we pop
|
|
|
|
|
contexts. */
|
|
|
|
|
continue;
|
|
|
|
|
|
1999-09-23 22:00:57 +02:00
|
|
|
|
for (i = 0; i < num_objects; i++)
|
|
|
|
|
{
|
|
|
|
|
size_t word, bit;
|
|
|
|
|
word = i / HOST_BITS_PER_LONG;
|
|
|
|
|
bit = i % HOST_BITS_PER_LONG;
|
|
|
|
|
if (((p->in_use_p[word] >> bit) & 1) == 0)
|
1999-10-30 23:36:13 +02:00
|
|
|
|
memset (p->page + i * size, 0xa5, size);
|
1999-09-23 22:00:57 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
1999-10-30 23:36:13 +02:00
|
|
|
|
/* Top level mark-and-sweep routine. */
|
|
|
|
|
|
1999-09-23 22:00:57 +02:00
|
|
|
|
void
|
|
|
|
|
ggc_collect ()
|
|
|
|
|
{
|
|
|
|
|
/* Avoid frequent unnecessary work by skipping collection if the
|
|
|
|
|
total allocations haven't expanded much since the last
|
|
|
|
|
collection. */
|
|
|
|
|
#ifndef GGC_ALWAYS_COLLECT
|
|
|
|
|
if (G.allocated < GGC_MIN_EXPAND_FOR_GC * G.allocated_last_gc)
|
|
|
|
|
return;
|
|
|
|
|
#endif
|
|
|
|
|
|
Makefile.in (OBJS): Add timevar.o.
hangeLog:
* Makefile.in (OBJS): Add timevar.o.
(toplev.o): Depend on timevar.h.
(ggc-simple.o): Likewise.
(ggc-page.o): Likewise.
(timevar.o): New rule.
(timevar.h): New rule.
* timevar.h: New file.
* timevar.c: Likewise.
* timevar.def: Likewise.
* toplev.h (gc_time, parse_time, varconst_time): Remove.
* toplev.c: Use timevar_push and timevar_pop instead of TIMEVAR
throughout.
(TIMEVAR): Remove macro.
(gc_time, parse_time, varconst_time, integration_time, jump_time,
cse_time, gcse_time, loop_time, cse2_time, branch_prob_time,
flow_time, combine_time, regmove_time, sched_time,
local_alloc_time, global_alloc_time, flow2_time, peephole2_time,
sched2_time, dbr_sched_time, reorder_blocks_time,
rename_registers_time, shorten_branch_time, stack_reg_time,
to_ssa_time, from_ssa_time, final_time, symout_time, dump_time,
all_time): Remove.
(compile_file): Don't initialize time variables. Call
init_timevar and start TV_TOTAL timer. Call timevar_print instead
of many calls to print_time.
(rest_of_compilation): Add timing for reload_cse_regs.
(get_run_time): Removed to timevar.c.
(print_time): Likewise.
(get_run_time): Implement using TV_TOTAL time variable.
(print_time): Get total run time from get_run_time.
* ggc-page.c (ggc_collect): Push and pop TV_GC instead of
computing elapsed time explicitly.
* ggc-simple.c (ggc_collect): Likewise.
(gc_time): Remove declaration.
cp/ChangeLog:
* lex.c (my_get_run_time): Remove.
(init_filename_times): Use get_run_time instead of my_get_run_time.
(check_newline): Likewise.
(dump_time_statistics): Likewise.
* decl2.c (finish_file): Push and pop timevar TV_VARCONST instead
of computing elapsed time explicitly.
From-SVN: r33496
2000-04-28 02:59:40 +02:00
|
|
|
|
timevar_push (TV_GC);
|
1999-09-23 22:00:57 +02:00
|
|
|
|
if (!quiet_flag)
|
2000-04-15 21:54:26 +02:00
|
|
|
|
fprintf (stderr, " {GC %luk -> ", (unsigned long) G.allocated / 1024);
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
|
|
|
|
/* Zero the total allocated bytes. We'll reaccumulate this while
|
|
|
|
|
marking. */
|
|
|
|
|
G.allocated = 0;
|
|
|
|
|
|
|
|
|
|
/* Release the pages we freed the last time we collected, but didn't
|
|
|
|
|
reuse in the interim. */
|
|
|
|
|
release_pages ();
|
|
|
|
|
|
|
|
|
|
clear_marks ();
|
|
|
|
|
ggc_mark_roots ();
|
|
|
|
|
|
|
|
|
|
#ifdef GGC_POISON
|
|
|
|
|
poison_pages ();
|
|
|
|
|
#endif
|
|
|
|
|
|
1999-10-30 23:36:13 +02:00
|
|
|
|
sweep_pages ();
|
|
|
|
|
|
1999-09-23 22:00:57 +02:00
|
|
|
|
G.allocated_last_gc = G.allocated;
|
1999-09-28 08:05:53 +02:00
|
|
|
|
if (G.allocated_last_gc < GGC_MIN_LAST_ALLOCATED)
|
|
|
|
|
G.allocated_last_gc = GGC_MIN_LAST_ALLOCATED;
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
Makefile.in (OBJS): Add timevar.o.
hangeLog:
* Makefile.in (OBJS): Add timevar.o.
(toplev.o): Depend on timevar.h.
(ggc-simple.o): Likewise.
(ggc-page.o): Likewise.
(timevar.o): New rule.
(timevar.h): New rule.
* timevar.h: New file.
* timevar.c: Likewise.
* timevar.def: Likewise.
* toplev.h (gc_time, parse_time, varconst_time): Remove.
* toplev.c: Use timevar_push and timevar_pop instead of TIMEVAR
throughout.
(TIMEVAR): Remove macro.
(gc_time, parse_time, varconst_time, integration_time, jump_time,
cse_time, gcse_time, loop_time, cse2_time, branch_prob_time,
flow_time, combine_time, regmove_time, sched_time,
local_alloc_time, global_alloc_time, flow2_time, peephole2_time,
sched2_time, dbr_sched_time, reorder_blocks_time,
rename_registers_time, shorten_branch_time, stack_reg_time,
to_ssa_time, from_ssa_time, final_time, symout_time, dump_time,
all_time): Remove.
(compile_file): Don't initialize time variables. Call
init_timevar and start TV_TOTAL timer. Call timevar_print instead
of many calls to print_time.
(rest_of_compilation): Add timing for reload_cse_regs.
(get_run_time): Removed to timevar.c.
(print_time): Likewise.
(get_run_time): Implement using TV_TOTAL time variable.
(print_time): Get total run time from get_run_time.
* ggc-page.c (ggc_collect): Push and pop TV_GC instead of
computing elapsed time explicitly.
* ggc-simple.c (ggc_collect): Likewise.
(gc_time): Remove declaration.
cp/ChangeLog:
* lex.c (my_get_run_time): Remove.
(init_filename_times): Use get_run_time instead of my_get_run_time.
(check_newline): Likewise.
(dump_time_statistics): Likewise.
* decl2.c (finish_file): Push and pop timevar TV_VARCONST instead
of computing elapsed time explicitly.
From-SVN: r33496
2000-04-28 02:59:40 +02:00
|
|
|
|
timevar_pop (TV_GC);
|
1999-09-23 22:00:57 +02:00
|
|
|
|
|
|
|
|
|
if (!quiet_flag)
|
Makefile.in (OBJS): Add timevar.o.
hangeLog:
* Makefile.in (OBJS): Add timevar.o.
(toplev.o): Depend on timevar.h.
(ggc-simple.o): Likewise.
(ggc-page.o): Likewise.
(timevar.o): New rule.
(timevar.h): New rule.
* timevar.h: New file.
* timevar.c: Likewise.
* timevar.def: Likewise.
* toplev.h (gc_time, parse_time, varconst_time): Remove.
* toplev.c: Use timevar_push and timevar_pop instead of TIMEVAR
throughout.
(TIMEVAR): Remove macro.
(gc_time, parse_time, varconst_time, integration_time, jump_time,
cse_time, gcse_time, loop_time, cse2_time, branch_prob_time,
flow_time, combine_time, regmove_time, sched_time,
local_alloc_time, global_alloc_time, flow2_time, peephole2_time,
sched2_time, dbr_sched_time, reorder_blocks_time,
rename_registers_time, shorten_branch_time, stack_reg_time,
to_ssa_time, from_ssa_time, final_time, symout_time, dump_time,
all_time): Remove.
(compile_file): Don't initialize time variables. Call
init_timevar and start TV_TOTAL timer. Call timevar_print instead
of many calls to print_time.
(rest_of_compilation): Add timing for reload_cse_regs.
(get_run_time): Removed to timevar.c.
(print_time): Likewise.
(get_run_time): Implement using TV_TOTAL time variable.
(print_time): Get total run time from get_run_time.
* ggc-page.c (ggc_collect): Push and pop TV_GC instead of
computing elapsed time explicitly.
* ggc-simple.c (ggc_collect): Likewise.
(gc_time): Remove declaration.
cp/ChangeLog:
* lex.c (my_get_run_time): Remove.
(init_filename_times): Use get_run_time instead of my_get_run_time.
(check_newline): Likewise.
(dump_time_statistics): Likewise.
* decl2.c (finish_file): Push and pop timevar TV_VARCONST instead
of computing elapsed time explicitly.
From-SVN: r33496
2000-04-28 02:59:40 +02:00
|
|
|
|
fprintf (stderr, "%luk}", (unsigned long) G.allocated / 1024);
|
1999-09-23 22:00:57 +02:00
|
|
|
|
}
|
1999-10-29 06:17:33 +02:00
|
|
|
|
|
|
|
|
|
/* Print allocation statistics. */
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
ggc_page_print_statistics ()
|
|
|
|
|
{
|
|
|
|
|
struct ggc_statistics stats;
|
1999-11-01 07:57:01 +01:00
|
|
|
|
unsigned int i;
|
1999-10-29 06:17:33 +02:00
|
|
|
|
|
|
|
|
|
/* Clear the statistics. */
|
2000-02-10 17:45:23 +01:00
|
|
|
|
memset (&stats, 0, sizeof (stats));
|
1999-10-29 06:17:33 +02:00
|
|
|
|
|
|
|
|
|
/* Make sure collection will really occur. */
|
|
|
|
|
G.allocated_last_gc = 0;
|
|
|
|
|
|
|
|
|
|
/* Collect and print the statistics common across collectors. */
|
|
|
|
|
ggc_print_statistics (stderr, &stats);
|
|
|
|
|
|
1999-11-01 07:57:01 +01:00
|
|
|
|
/* Release free pages so that we will not count the bytes allocated
|
|
|
|
|
there as part of the total allocated memory. */
|
|
|
|
|
release_pages ();
|
|
|
|
|
|
1999-10-29 06:17:33 +02:00
|
|
|
|
/* Collect some information about the various sizes of
|
|
|
|
|
allocation. */
|
|
|
|
|
fprintf (stderr, "\n%-4s%-16s%-16s\n", "Log", "Allocated", "Used");
|
|
|
|
|
for (i = 0; i < HOST_BITS_PER_PTR; ++i)
|
|
|
|
|
{
|
|
|
|
|
page_entry *p;
|
|
|
|
|
size_t allocated;
|
|
|
|
|
size_t in_use;
|
|
|
|
|
|
|
|
|
|
/* Skip empty entries. */
|
|
|
|
|
if (!G.pages[i])
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
allocated = in_use = 0;
|
|
|
|
|
|
|
|
|
|
/* Figure out the total number of bytes allocated for objects of
|
|
|
|
|
this size, and how many of them are actually in use. */
|
|
|
|
|
for (p = G.pages[i]; p; p = p->next)
|
|
|
|
|
{
|
|
|
|
|
allocated += p->bytes;
|
|
|
|
|
in_use +=
|
|
|
|
|
(OBJECTS_PER_PAGE (i) - p->num_free_objects) * (1 << i);
|
|
|
|
|
}
|
1999-11-30 23:28:43 +01:00
|
|
|
|
fprintf (stderr, "%-3d %-15lu %-15lu\n", i,
|
|
|
|
|
(unsigned long) allocated, (unsigned long) in_use);
|
1999-10-29 06:17:33 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Print out some global information. */
|
1999-10-30 23:26:13 +02:00
|
|
|
|
fprintf (stderr, "\nTotal bytes marked: %lu\n",
|
|
|
|
|
(unsigned long) G.allocated);
|
|
|
|
|
fprintf (stderr, "Total bytes mapped: %lu\n",
|
|
|
|
|
(unsigned long) G.bytes_mapped);
|
1999-10-29 06:17:33 +02:00
|
|
|
|
}
|