Mercurial > hg > CbC > CbC_gcc
annotate gcc/ggc-common.c @ 88:f214c1d5b862
merge 89
author | Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp> |
---|---|
date | Tue, 20 Dec 2011 18:53:46 +0900 |
parents | f6334be47118 |
children | 04ced10e8804 |
rev | line source |
---|---|
0 | 1 /* Simple garbage collection for the GNU compiler. |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3 2009, 2010 Free Software Foundation, Inc. |
0 | 4 |
5 This file is part of GCC. | |
6 | |
7 GCC is free software; you can redistribute it and/or modify it under | |
8 the terms of the GNU General Public License as published by the Free | |
9 Software Foundation; either version 3, or (at your option) any later | |
10 version. | |
11 | |
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
15 for more details. | |
16 | |
17 You should have received a copy of the GNU General Public License | |
18 along with GCC; see the file COPYING3. If not see | |
19 <http://www.gnu.org/licenses/>. */ | |
20 | |
21 /* Generic garbage collection (GC) functions and data, not specific to | |
22 any particular GC implementation. */ | |
23 | |
24 #include "config.h" | |
25 #include "system.h" | |
26 #include "coretypes.h" | |
27 #include "hashtab.h" | |
28 #include "ggc.h" | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
29 #include "ggc-internal.h" |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
30 #include "diagnostic-core.h" |
0 | 31 #include "params.h" |
32 #include "hosthooks.h" | |
33 #include "hosthooks-def.h" | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
34 #include "plugin.h" |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
35 #include "vec.h" |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
36 #include "timevar.h" |
0 | 37 |
38 /* When set, ggc_collect will do collection. */ | |
39 bool ggc_force_collect; | |
40 | |
41 /* When true, protect the contents of the identifier hash table. */ | |
42 bool ggc_protect_identifiers = true; | |
43 | |
44 /* Statistics about the allocation. */ | |
45 static ggc_statistics *ggc_stats; | |
46 | |
47 struct traversal_state; | |
48 | |
49 static int ggc_htab_delete (void **, void *); | |
50 static hashval_t saving_htab_hash (const void *); | |
51 static int saving_htab_eq (const void *, const void *); | |
52 static int call_count (void **, void *); | |
53 static int call_alloc (void **, void *); | |
54 static int compare_ptr_data (const void *, const void *); | |
55 static void relocate_ptrs (void *, void *); | |
56 static void write_pch_globals (const struct ggc_root_tab * const *tab, | |
57 struct traversal_state *state); | |
58 | |
59 /* Maintain global roots that are preserved during GC. */ | |
60 | |
61 /* Process a slot of an htab by deleting it if it has not been marked. */ | |
62 | |
63 static int | |
64 ggc_htab_delete (void **slot, void *info) | |
65 { | |
66 const struct ggc_cache_tab *r = (const struct ggc_cache_tab *) info; | |
67 | |
68 if (! (*r->marked_p) (*slot)) | |
69 htab_clear_slot (*r->base, slot); | |
70 else | |
71 (*r->cb) (*slot); | |
72 | |
73 return 1; | |
74 } | |
75 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
76 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
77 /* This extra vector of dynamically registered root_tab-s is used by |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
78 ggc_mark_roots and gives the ability to dynamically add new GGC root |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
79 tables, for instance from some plugins; this vector is on the heap |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
80 since it is used by GGC internally. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
81 typedef const struct ggc_root_tab *const_ggc_root_tab_t; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
82 DEF_VEC_P(const_ggc_root_tab_t); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
83 DEF_VEC_ALLOC_P(const_ggc_root_tab_t, heap); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
84 static VEC(const_ggc_root_tab_t, heap) *extra_root_vec; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
85 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
86 /* Dynamically register a new GGC root table RT. This is useful for |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
87 plugins. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
88 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
89 void |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
90 ggc_register_root_tab (const struct ggc_root_tab* rt) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
91 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
92 if (rt) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
93 VEC_safe_push (const_ggc_root_tab_t, heap, extra_root_vec, rt); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
94 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
95 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
96 /* This extra vector of dynamically registered cache_tab-s is used by |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
97 ggc_mark_roots and gives the ability to dynamically add new GGC cache |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
98 tables, for instance from some plugins; this vector is on the heap |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
99 since it is used by GGC internally. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
100 typedef const struct ggc_cache_tab *const_ggc_cache_tab_t; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
101 DEF_VEC_P(const_ggc_cache_tab_t); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
102 DEF_VEC_ALLOC_P(const_ggc_cache_tab_t, heap); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
103 static VEC(const_ggc_cache_tab_t, heap) *extra_cache_vec; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
104 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
105 /* Dynamically register a new GGC cache table CT. This is useful for |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
106 plugins. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
107 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
108 void |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
109 ggc_register_cache_tab (const struct ggc_cache_tab* ct) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
110 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
111 if (ct) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
112 VEC_safe_push (const_ggc_cache_tab_t, heap, extra_cache_vec, ct); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
113 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
114 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
115 /* Scan a hash table that has objects which are to be deleted if they are not |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
116 already marked. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
117 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
118 static void |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
119 ggc_scan_cache_tab (const_ggc_cache_tab_t ctp) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
120 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
121 const struct ggc_cache_tab *cti; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
122 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
123 for (cti = ctp; cti->base != NULL; cti++) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
124 if (*cti->base) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
125 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
126 ggc_set_mark (*cti->base); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
127 htab_traverse_noresize (*cti->base, ggc_htab_delete, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
128 CONST_CAST (void *, (const void *)cti)); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
129 ggc_set_mark ((*cti->base)->entries); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
130 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
131 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
132 |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
133 /* Mark all the roots in the table RT. */ |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
134 |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
135 static void |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
136 ggc_mark_root_tab (const_ggc_root_tab_t rt) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
137 { |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
138 size_t i; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
139 |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
140 for ( ; rt->base != NULL; rt++) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
141 for (i = 0; i < rt->nelt; i++) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
142 (*rt->cb) (*(void **) ((char *)rt->base + rt->stride * i)); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
143 } |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
144 |
0 | 145 /* Iterate through all registered roots and mark each element. */ |
146 | |
147 void | |
148 ggc_mark_roots (void) | |
149 { | |
150 const struct ggc_root_tab *const *rt; | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
151 const_ggc_root_tab_t rtp, rti; |
0 | 152 const struct ggc_cache_tab *const *ct; |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
153 const_ggc_cache_tab_t ctp; |
0 | 154 size_t i; |
155 | |
156 for (rt = gt_ggc_deletable_rtab; *rt; rt++) | |
157 for (rti = *rt; rti->base != NULL; rti++) | |
158 memset (rti->base, 0, rti->stride); | |
159 | |
160 for (rt = gt_ggc_rtab; *rt; rt++) | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
161 ggc_mark_root_tab (*rt); |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
162 |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
163 FOR_EACH_VEC_ELT (const_ggc_root_tab_t, extra_root_vec, i, rtp) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
164 ggc_mark_root_tab (rtp); |
0 | 165 |
166 if (ggc_protect_identifiers) | |
167 ggc_mark_stringpool (); | |
168 | |
169 /* Now scan all hash tables that have objects which are to be deleted if | |
170 they are not already marked. */ | |
171 for (ct = gt_ggc_cache_rtab; *ct; ct++) | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
172 ggc_scan_cache_tab (*ct); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
173 |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
174 FOR_EACH_VEC_ELT (const_ggc_cache_tab_t, extra_cache_vec, i, ctp) |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
175 ggc_scan_cache_tab (ctp); |
0 | 176 |
177 if (! ggc_protect_identifiers) | |
178 ggc_purge_stringpool (); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
179 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
180 /* Some plugins may call ggc_set_mark from here. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
181 invoke_plugin_callbacks (PLUGIN_GGC_MARKING, NULL); |
0 | 182 } |
183 | |
184 /* Allocate a block of memory, then clear it. */ | |
185 void * | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
186 ggc_internal_cleared_alloc_stat (size_t size MEM_STAT_DECL) |
0 | 187 { |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
188 void *buf = ggc_internal_alloc_stat (size PASS_MEM_STAT); |
0 | 189 memset (buf, 0, size); |
190 return buf; | |
191 } | |
192 | |
193 /* Resize a block of memory, possibly re-allocating it. */ | |
194 void * | |
195 ggc_realloc_stat (void *x, size_t size MEM_STAT_DECL) | |
196 { | |
197 void *r; | |
198 size_t old_size; | |
199 | |
200 if (x == NULL) | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
201 return ggc_internal_alloc_stat (size PASS_MEM_STAT); |
0 | 202 |
203 old_size = ggc_get_size (x); | |
204 | |
205 if (size <= old_size) | |
206 { | |
207 /* Mark the unwanted memory as unaccessible. We also need to make | |
208 the "new" size accessible, since ggc_get_size returns the size of | |
209 the pool, not the size of the individually allocated object, the | |
210 size which was previously made accessible. Unfortunately, we | |
211 don't know that previously allocated size. Without that | |
212 knowledge we have to lose some initialization-tracking for the | |
213 old parts of the object. An alternative is to mark the whole | |
214 old_size as reachable, but that would lose tracking of writes | |
215 after the end of the object (by small offsets). Discard the | |
216 handle to avoid handle leak. */ | |
217 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS ((char *) x + size, | |
218 old_size - size)); | |
219 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (x, size)); | |
220 return x; | |
221 } | |
222 | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
223 r = ggc_internal_alloc_stat (size PASS_MEM_STAT); |
0 | 224 |
225 /* Since ggc_get_size returns the size of the pool, not the size of the | |
226 individually allocated object, we'd access parts of the old object | |
227 that were marked invalid with the memcpy below. We lose a bit of the | |
228 initialization-tracking since some of it may be uninitialized. */ | |
229 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (x, old_size)); | |
230 | |
231 memcpy (r, x, old_size); | |
232 | |
233 /* The old object is not supposed to be used anymore. */ | |
234 ggc_free (x); | |
235 | |
236 return r; | |
237 } | |
238 | |
239 void * | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
240 ggc_cleared_alloc_htab_ignore_args (size_t c ATTRIBUTE_UNUSED, |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
241 size_t n ATTRIBUTE_UNUSED) |
0 | 242 { |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
243 gcc_assert (c * n == sizeof (struct htab)); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
244 return ggc_alloc_cleared_htab (); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
245 } |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
246 |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
247 /* TODO: once we actually use type information in GGC, create a new tag |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
248 gt_gcc_ptr_array and use it for pointer arrays. */ |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
249 void * |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
250 ggc_cleared_alloc_ptr_array_two_args (size_t c, size_t n) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
251 { |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
252 gcc_assert (sizeof (PTR *) == n); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
253 return ggc_internal_cleared_vec_alloc (sizeof (PTR *), c); |
0 | 254 } |
255 | |
256 /* These are for splay_tree_new_ggc. */ | |
257 void * | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
258 ggc_splay_alloc (enum gt_types_enum obj_type ATTRIBUTE_UNUSED, int sz, |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
259 void *nl) |
0 | 260 { |
261 gcc_assert (!nl); | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
262 return ggc_internal_alloc (sz); |
0 | 263 } |
264 | |
265 void | |
266 ggc_splay_dont_free (void * x ATTRIBUTE_UNUSED, void *nl) | |
267 { | |
268 gcc_assert (!nl); | |
269 } | |
270 | |
271 /* Print statistics that are independent of the collector in use. */ | |
272 #define SCALE(x) ((unsigned long) ((x) < 1024*10 \ | |
273 ? (x) \ | |
274 : ((x) < 1024*1024*10 \ | |
275 ? (x) / 1024 \ | |
276 : (x) / (1024*1024)))) | |
277 #define LABEL(x) ((x) < 1024*10 ? ' ' : ((x) < 1024*1024*10 ? 'k' : 'M')) | |
278 | |
279 void | |
280 ggc_print_common_statistics (FILE *stream ATTRIBUTE_UNUSED, | |
281 ggc_statistics *stats) | |
282 { | |
283 /* Set the pointer so that during collection we will actually gather | |
284 the statistics. */ | |
285 ggc_stats = stats; | |
286 | |
287 /* Then do one collection to fill in the statistics. */ | |
288 ggc_collect (); | |
289 | |
290 /* At present, we don't really gather any interesting statistics. */ | |
291 | |
292 /* Don't gather statistics any more. */ | |
293 ggc_stats = NULL; | |
294 } | |
295 | |
296 /* Functions for saving and restoring GCable memory to disk. */ | |
297 | |
298 static htab_t saving_htab; | |
299 | |
300 struct ptr_data | |
301 { | |
302 void *obj; | |
303 void *note_ptr_cookie; | |
304 gt_note_pointers note_ptr_fn; | |
305 gt_handle_reorder reorder_fn; | |
306 size_t size; | |
307 void *new_addr; | |
308 enum gt_types_enum type; | |
309 }; | |
310 | |
311 #define POINTER_HASH(x) (hashval_t)((long)x >> 3) | |
312 | |
313 /* Register an object in the hash table. */ | |
314 | |
315 int | |
316 gt_pch_note_object (void *obj, void *note_ptr_cookie, | |
317 gt_note_pointers note_ptr_fn, | |
318 enum gt_types_enum type) | |
319 { | |
320 struct ptr_data **slot; | |
321 | |
322 if (obj == NULL || obj == (void *) 1) | |
323 return 0; | |
324 | |
325 slot = (struct ptr_data **) | |
326 htab_find_slot_with_hash (saving_htab, obj, POINTER_HASH (obj), | |
327 INSERT); | |
328 if (*slot != NULL) | |
329 { | |
330 gcc_assert ((*slot)->note_ptr_fn == note_ptr_fn | |
331 && (*slot)->note_ptr_cookie == note_ptr_cookie); | |
332 return 0; | |
333 } | |
334 | |
335 *slot = XCNEW (struct ptr_data); | |
336 (*slot)->obj = obj; | |
337 (*slot)->note_ptr_fn = note_ptr_fn; | |
338 (*slot)->note_ptr_cookie = note_ptr_cookie; | |
339 if (note_ptr_fn == gt_pch_p_S) | |
340 (*slot)->size = strlen ((const char *)obj) + 1; | |
341 else | |
342 (*slot)->size = ggc_get_size (obj); | |
343 (*slot)->type = type; | |
344 return 1; | |
345 } | |
346 | |
347 /* Register an object in the hash table. */ | |
348 | |
349 void | |
350 gt_pch_note_reorder (void *obj, void *note_ptr_cookie, | |
351 gt_handle_reorder reorder_fn) | |
352 { | |
353 struct ptr_data *data; | |
354 | |
355 if (obj == NULL || obj == (void *) 1) | |
356 return; | |
357 | |
358 data = (struct ptr_data *) | |
359 htab_find_with_hash (saving_htab, obj, POINTER_HASH (obj)); | |
360 gcc_assert (data && data->note_ptr_cookie == note_ptr_cookie); | |
361 | |
362 data->reorder_fn = reorder_fn; | |
363 } | |
364 | |
365 /* Hash and equality functions for saving_htab, callbacks for htab_create. */ | |
366 | |
367 static hashval_t | |
368 saving_htab_hash (const void *p) | |
369 { | |
370 return POINTER_HASH (((const struct ptr_data *)p)->obj); | |
371 } | |
372 | |
373 static int | |
374 saving_htab_eq (const void *p1, const void *p2) | |
375 { | |
376 return ((const struct ptr_data *)p1)->obj == p2; | |
377 } | |
378 | |
379 /* Handy state for the traversal functions. */ | |
380 | |
381 struct traversal_state | |
382 { | |
383 FILE *f; | |
384 struct ggc_pch_data *d; | |
385 size_t count; | |
386 struct ptr_data **ptrs; | |
387 size_t ptrs_i; | |
388 }; | |
389 | |
390 /* Callbacks for htab_traverse. */ | |
391 | |
392 static int | |
393 call_count (void **slot, void *state_p) | |
394 { | |
395 struct ptr_data *d = (struct ptr_data *)*slot; | |
396 struct traversal_state *state = (struct traversal_state *)state_p; | |
397 | |
398 ggc_pch_count_object (state->d, d->obj, d->size, | |
399 d->note_ptr_fn == gt_pch_p_S, | |
400 d->type); | |
401 state->count++; | |
402 return 1; | |
403 } | |
404 | |
405 static int | |
406 call_alloc (void **slot, void *state_p) | |
407 { | |
408 struct ptr_data *d = (struct ptr_data *)*slot; | |
409 struct traversal_state *state = (struct traversal_state *)state_p; | |
410 | |
411 d->new_addr = ggc_pch_alloc_object (state->d, d->obj, d->size, | |
412 d->note_ptr_fn == gt_pch_p_S, | |
413 d->type); | |
414 state->ptrs[state->ptrs_i++] = d; | |
415 return 1; | |
416 } | |
417 | |
418 /* Callback for qsort. */ | |
419 | |
420 static int | |
421 compare_ptr_data (const void *p1_p, const void *p2_p) | |
422 { | |
423 const struct ptr_data *const p1 = *(const struct ptr_data *const *)p1_p; | |
424 const struct ptr_data *const p2 = *(const struct ptr_data *const *)p2_p; | |
425 return (((size_t)p1->new_addr > (size_t)p2->new_addr) | |
426 - ((size_t)p1->new_addr < (size_t)p2->new_addr)); | |
427 } | |
428 | |
429 /* Callbacks for note_ptr_fn. */ | |
430 | |
431 static void | |
432 relocate_ptrs (void *ptr_p, void *state_p) | |
433 { | |
434 void **ptr = (void **)ptr_p; | |
435 struct traversal_state *state ATTRIBUTE_UNUSED | |
436 = (struct traversal_state *)state_p; | |
437 struct ptr_data *result; | |
438 | |
439 if (*ptr == NULL || *ptr == (void *)1) | |
440 return; | |
441 | |
442 result = (struct ptr_data *) | |
443 htab_find_with_hash (saving_htab, *ptr, POINTER_HASH (*ptr)); | |
444 gcc_assert (result); | |
445 *ptr = result->new_addr; | |
446 } | |
447 | |
448 /* Write out, after relocation, the pointers in TAB. */ | |
449 static void | |
450 write_pch_globals (const struct ggc_root_tab * const *tab, | |
451 struct traversal_state *state) | |
452 { | |
453 const struct ggc_root_tab *const *rt; | |
454 const struct ggc_root_tab *rti; | |
455 size_t i; | |
456 | |
457 for (rt = tab; *rt; rt++) | |
458 for (rti = *rt; rti->base != NULL; rti++) | |
459 for (i = 0; i < rti->nelt; i++) | |
460 { | |
461 void *ptr = *(void **)((char *)rti->base + rti->stride * i); | |
462 struct ptr_data *new_ptr; | |
463 if (ptr == NULL || ptr == (void *)1) | |
464 { | |
465 if (fwrite (&ptr, sizeof (void *), 1, state->f) | |
466 != 1) | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
467 fatal_error ("can%'t write PCH file: %m"); |
0 | 468 } |
469 else | |
470 { | |
471 new_ptr = (struct ptr_data *) | |
472 htab_find_with_hash (saving_htab, ptr, POINTER_HASH (ptr)); | |
473 if (fwrite (&new_ptr->new_addr, sizeof (void *), 1, state->f) | |
474 != 1) | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
475 fatal_error ("can%'t write PCH file: %m"); |
0 | 476 } |
477 } | |
478 } | |
479 | |
480 /* Hold the information we need to mmap the file back in. */ | |
481 | |
482 struct mmap_info | |
483 { | |
484 size_t offset; | |
485 size_t size; | |
486 void *preferred_base; | |
487 }; | |
488 | |
489 /* Write out the state of the compiler to F. */ | |
490 | |
491 void | |
492 gt_pch_save (FILE *f) | |
493 { | |
494 const struct ggc_root_tab *const *rt; | |
495 const struct ggc_root_tab *rti; | |
496 size_t i; | |
497 struct traversal_state state; | |
498 char *this_object = NULL; | |
499 size_t this_object_size = 0; | |
500 struct mmap_info mmi; | |
501 const size_t mmap_offset_alignment = host_hooks.gt_pch_alloc_granularity(); | |
502 | |
503 gt_pch_save_stringpool (); | |
504 | |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
505 timevar_push (TV_PCH_PTR_REALLOC); |
0 | 506 saving_htab = htab_create (50000, saving_htab_hash, saving_htab_eq, free); |
507 | |
508 for (rt = gt_ggc_rtab; *rt; rt++) | |
509 for (rti = *rt; rti->base != NULL; rti++) | |
510 for (i = 0; i < rti->nelt; i++) | |
511 (*rti->pchw)(*(void **)((char *)rti->base + rti->stride * i)); | |
512 | |
513 for (rt = gt_pch_cache_rtab; *rt; rt++) | |
514 for (rti = *rt; rti->base != NULL; rti++) | |
515 for (i = 0; i < rti->nelt; i++) | |
516 (*rti->pchw)(*(void **)((char *)rti->base + rti->stride * i)); | |
517 | |
518 /* Prepare the objects for writing, determine addresses and such. */ | |
519 state.f = f; | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
520 state.d = init_ggc_pch (); |
0 | 521 state.count = 0; |
522 htab_traverse (saving_htab, call_count, &state); | |
523 | |
524 mmi.size = ggc_pch_total_size (state.d); | |
525 | |
526 /* Try to arrange things so that no relocation is necessary, but | |
527 don't try very hard. On most platforms, this will always work, | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
528 and on the rest it's a lot of work to do better. |
0 | 529 (The extra work goes in HOST_HOOKS_GT_PCH_GET_ADDRESS and |
530 HOST_HOOKS_GT_PCH_USE_ADDRESS.) */ | |
531 mmi.preferred_base = host_hooks.gt_pch_get_address (mmi.size, fileno (f)); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
532 |
0 | 533 ggc_pch_this_base (state.d, mmi.preferred_base); |
534 | |
535 state.ptrs = XNEWVEC (struct ptr_data *, state.count); | |
536 state.ptrs_i = 0; | |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
537 |
0 | 538 htab_traverse (saving_htab, call_alloc, &state); |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
539 timevar_pop (TV_PCH_PTR_REALLOC); |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
540 |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
541 timevar_push (TV_PCH_PTR_SORT); |
0 | 542 qsort (state.ptrs, state.count, sizeof (*state.ptrs), compare_ptr_data); |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
543 timevar_pop (TV_PCH_PTR_SORT); |
0 | 544 |
545 /* Write out all the scalar variables. */ | |
546 for (rt = gt_pch_scalar_rtab; *rt; rt++) | |
547 for (rti = *rt; rti->base != NULL; rti++) | |
548 if (fwrite (rti->base, rti->stride, 1, f) != 1) | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
549 fatal_error ("can%'t write PCH file: %m"); |
0 | 550 |
551 /* Write out all the global pointers, after translation. */ | |
552 write_pch_globals (gt_ggc_rtab, &state); | |
553 write_pch_globals (gt_pch_cache_rtab, &state); | |
554 | |
555 /* Pad the PCH file so that the mmapped area starts on an allocation | |
556 granularity (usually page) boundary. */ | |
557 { | |
558 long o; | |
559 o = ftell (state.f) + sizeof (mmi); | |
560 if (o == -1) | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
561 fatal_error ("can%'t get position in PCH file: %m"); |
0 | 562 mmi.offset = mmap_offset_alignment - o % mmap_offset_alignment; |
563 if (mmi.offset == mmap_offset_alignment) | |
564 mmi.offset = 0; | |
565 mmi.offset += o; | |
566 } | |
567 if (fwrite (&mmi, sizeof (mmi), 1, state.f) != 1) | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
568 fatal_error ("can%'t write PCH file: %m"); |
0 | 569 if (mmi.offset != 0 |
570 && fseek (state.f, mmi.offset, SEEK_SET) != 0) | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
571 fatal_error ("can%'t write padding to PCH file: %m"); |
0 | 572 |
573 ggc_pch_prepare_write (state.d, state.f); | |
574 | |
575 /* Actually write out the objects. */ | |
576 for (i = 0; i < state.count; i++) | |
577 { | |
578 if (this_object_size < state.ptrs[i]->size) | |
579 { | |
580 this_object_size = state.ptrs[i]->size; | |
581 this_object = XRESIZEVAR (char, this_object, this_object_size); | |
582 } | |
583 memcpy (this_object, state.ptrs[i]->obj, state.ptrs[i]->size); | |
584 if (state.ptrs[i]->reorder_fn != NULL) | |
585 state.ptrs[i]->reorder_fn (state.ptrs[i]->obj, | |
586 state.ptrs[i]->note_ptr_cookie, | |
587 relocate_ptrs, &state); | |
588 state.ptrs[i]->note_ptr_fn (state.ptrs[i]->obj, | |
589 state.ptrs[i]->note_ptr_cookie, | |
590 relocate_ptrs, &state); | |
591 ggc_pch_write_object (state.d, state.f, state.ptrs[i]->obj, | |
592 state.ptrs[i]->new_addr, state.ptrs[i]->size, | |
593 state.ptrs[i]->note_ptr_fn == gt_pch_p_S); | |
594 if (state.ptrs[i]->note_ptr_fn != gt_pch_p_S) | |
595 memcpy (state.ptrs[i]->obj, this_object, state.ptrs[i]->size); | |
596 } | |
597 ggc_pch_finish (state.d, state.f); | |
598 gt_pch_fixup_stringpool (); | |
599 | |
600 free (state.ptrs); | |
601 htab_delete (saving_htab); | |
602 } | |
603 | |
604 /* Read the state of the compiler back in from F. */ | |
605 | |
606 void | |
607 gt_pch_restore (FILE *f) | |
608 { | |
609 const struct ggc_root_tab *const *rt; | |
610 const struct ggc_root_tab *rti; | |
611 size_t i; | |
612 struct mmap_info mmi; | |
613 int result; | |
614 | |
615 /* Delete any deletable objects. This makes ggc_pch_read much | |
616 faster, as it can be sure that no GCable objects remain other | |
617 than the ones just read in. */ | |
618 for (rt = gt_ggc_deletable_rtab; *rt; rt++) | |
619 for (rti = *rt; rti->base != NULL; rti++) | |
620 memset (rti->base, 0, rti->stride); | |
621 | |
622 /* Read in all the scalar variables. */ | |
623 for (rt = gt_pch_scalar_rtab; *rt; rt++) | |
624 for (rti = *rt; rti->base != NULL; rti++) | |
625 if (fread (rti->base, rti->stride, 1, f) != 1) | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
626 fatal_error ("can%'t read PCH file: %m"); |
0 | 627 |
628 /* Read in all the global pointers, in 6 easy loops. */ | |
629 for (rt = gt_ggc_rtab; *rt; rt++) | |
630 for (rti = *rt; rti->base != NULL; rti++) | |
631 for (i = 0; i < rti->nelt; i++) | |
632 if (fread ((char *)rti->base + rti->stride * i, | |
633 sizeof (void *), 1, f) != 1) | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
634 fatal_error ("can%'t read PCH file: %m"); |
0 | 635 |
636 for (rt = gt_pch_cache_rtab; *rt; rt++) | |
637 for (rti = *rt; rti->base != NULL; rti++) | |
638 for (i = 0; i < rti->nelt; i++) | |
639 if (fread ((char *)rti->base + rti->stride * i, | |
640 sizeof (void *), 1, f) != 1) | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
641 fatal_error ("can%'t read PCH file: %m"); |
0 | 642 |
643 if (fread (&mmi, sizeof (mmi), 1, f) != 1) | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
644 fatal_error ("can%'t read PCH file: %m"); |
0 | 645 |
646 result = host_hooks.gt_pch_use_address (mmi.preferred_base, mmi.size, | |
647 fileno (f), mmi.offset); | |
648 if (result < 0) | |
649 fatal_error ("had to relocate PCH"); | |
650 if (result == 0) | |
651 { | |
652 if (fseek (f, mmi.offset, SEEK_SET) != 0 | |
653 || fread (mmi.preferred_base, mmi.size, 1, f) != 1) | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
654 fatal_error ("can%'t read PCH file: %m"); |
0 | 655 } |
656 else if (fseek (f, mmi.offset + mmi.size, SEEK_SET) != 0) | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
657 fatal_error ("can%'t read PCH file: %m"); |
0 | 658 |
659 ggc_pch_read (f, mmi.preferred_base); | |
660 | |
661 gt_pch_restore_stringpool (); | |
662 } | |
663 | |
664 /* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS when mmap is not present. | |
665 Select no address whatsoever, and let gt_pch_save choose what it will with | |
666 malloc, presumably. */ | |
667 | |
668 void * | |
669 default_gt_pch_get_address (size_t size ATTRIBUTE_UNUSED, | |
670 int fd ATTRIBUTE_UNUSED) | |
671 { | |
672 return NULL; | |
673 } | |
674 | |
675 /* Default version of HOST_HOOKS_GT_PCH_USE_ADDRESS when mmap is not present. | |
676 Allocate SIZE bytes with malloc. Return 0 if the address we got is the | |
677 same as base, indicating that the memory has been allocated but needs to | |
678 be read in from the file. Return -1 if the address differs, to relocation | |
679 of the PCH file would be required. */ | |
680 | |
681 int | |
682 default_gt_pch_use_address (void *base, size_t size, int fd ATTRIBUTE_UNUSED, | |
683 size_t offset ATTRIBUTE_UNUSED) | |
684 { | |
685 void *addr = xmalloc (size); | |
686 return (addr == base) - 1; | |
687 } | |
688 | |
689 /* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS. Return the | |
690 alignment required for allocating virtual memory. Usually this is the | |
691 same as pagesize. */ | |
692 | |
693 size_t | |
694 default_gt_pch_alloc_granularity (void) | |
695 { | |
696 return getpagesize(); | |
697 } | |
698 | |
699 #if HAVE_MMAP_FILE | |
700 /* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS when mmap is present. | |
701 We temporarily allocate SIZE bytes, and let the kernel place the data | |
702 wherever it will. If it worked, that's our spot, if not we're likely | |
703 to be in trouble. */ | |
704 | |
705 void * | |
706 mmap_gt_pch_get_address (size_t size, int fd) | |
707 { | |
708 void *ret; | |
709 | |
710 ret = mmap (NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0); | |
711 if (ret == (void *) MAP_FAILED) | |
712 ret = NULL; | |
713 else | |
714 munmap ((caddr_t) ret, size); | |
715 | |
716 return ret; | |
717 } | |
718 | |
719 /* Default version of HOST_HOOKS_GT_PCH_USE_ADDRESS when mmap is present. | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
720 Map SIZE bytes of FD+OFFSET at BASE. Return 1 if we succeeded at |
0 | 721 mapping the data at BASE, -1 if we couldn't. |
722 | |
723 This version assumes that the kernel honors the START operand of mmap | |
724 even without MAP_FIXED if START through START+SIZE are not currently | |
725 mapped with something. */ | |
726 | |
727 int | |
728 mmap_gt_pch_use_address (void *base, size_t size, int fd, size_t offset) | |
729 { | |
730 void *addr; | |
731 | |
732 /* We're called with size == 0 if we're not planning to load a PCH | |
733 file at all. This allows the hook to free any static space that | |
734 we might have allocated at link time. */ | |
735 if (size == 0) | |
736 return -1; | |
737 | |
738 addr = mmap ((caddr_t) base, size, PROT_READ | PROT_WRITE, MAP_PRIVATE, | |
739 fd, offset); | |
740 | |
741 return addr == base ? 1 : -1; | |
742 } | |
743 #endif /* HAVE_MMAP_FILE */ | |
744 | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
745 #if !defined ENABLE_GC_CHECKING && !defined ENABLE_GC_ALWAYS_COLLECT |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
746 |
0 | 747 /* Modify the bound based on rlimits. */ |
748 static double | |
749 ggc_rlimit_bound (double limit) | |
750 { | |
751 #if defined(HAVE_GETRLIMIT) | |
752 struct rlimit rlim; | |
753 # if defined (RLIMIT_AS) | |
754 /* RLIMIT_AS is what POSIX says is the limit on mmap. Presumably | |
755 any OS which has RLIMIT_AS also has a working mmap that GCC will use. */ | |
756 if (getrlimit (RLIMIT_AS, &rlim) == 0 | |
757 && rlim.rlim_cur != (rlim_t) RLIM_INFINITY | |
758 && rlim.rlim_cur < limit) | |
759 limit = rlim.rlim_cur; | |
760 # elif defined (RLIMIT_DATA) | |
761 /* ... but some older OSs bound mmap based on RLIMIT_DATA, or we | |
762 might be on an OS that has a broken mmap. (Others don't bound | |
763 mmap at all, apparently.) */ | |
764 if (getrlimit (RLIMIT_DATA, &rlim) == 0 | |
765 && rlim.rlim_cur != (rlim_t) RLIM_INFINITY | |
766 && rlim.rlim_cur < limit | |
767 /* Darwin has this horribly bogus default setting of | |
768 RLIMIT_DATA, to 6144Kb. No-one notices because RLIMIT_DATA | |
769 appears to be ignored. Ignore such silliness. If a limit | |
770 this small was actually effective for mmap, GCC wouldn't even | |
771 start up. */ | |
772 && rlim.rlim_cur >= 8 * 1024 * 1024) | |
773 limit = rlim.rlim_cur; | |
774 # endif /* RLIMIT_AS or RLIMIT_DATA */ | |
775 #endif /* HAVE_GETRLIMIT */ | |
776 | |
777 return limit; | |
778 } | |
779 | |
780 /* Heuristic to set a default for GGC_MIN_EXPAND. */ | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
781 static int |
0 | 782 ggc_min_expand_heuristic (void) |
783 { | |
784 double min_expand = physmem_total(); | |
785 | |
786 /* Adjust for rlimits. */ | |
787 min_expand = ggc_rlimit_bound (min_expand); | |
788 | |
789 /* The heuristic is a percentage equal to 30% + 70%*(RAM/1GB), yielding | |
790 a lower bound of 30% and an upper bound of 100% (when RAM >= 1GB). */ | |
791 min_expand /= 1024*1024*1024; | |
792 min_expand *= 70; | |
793 min_expand = MIN (min_expand, 70); | |
794 min_expand += 30; | |
795 | |
796 return min_expand; | |
797 } | |
798 | |
799 /* Heuristic to set a default for GGC_MIN_HEAPSIZE. */ | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
800 static int |
0 | 801 ggc_min_heapsize_heuristic (void) |
802 { | |
803 double phys_kbytes = physmem_total(); | |
804 double limit_kbytes = ggc_rlimit_bound (phys_kbytes * 2); | |
805 | |
806 phys_kbytes /= 1024; /* Convert to Kbytes. */ | |
807 limit_kbytes /= 1024; | |
808 | |
809 /* The heuristic is RAM/8, with a lower bound of 4M and an upper | |
810 bound of 128M (when RAM >= 1GB). */ | |
811 phys_kbytes /= 8; | |
812 | |
813 #if defined(HAVE_GETRLIMIT) && defined (RLIMIT_RSS) | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
814 /* Try not to overrun the RSS limit while doing garbage collection. |
0 | 815 The RSS limit is only advisory, so no margin is subtracted. */ |
816 { | |
817 struct rlimit rlim; | |
818 if (getrlimit (RLIMIT_RSS, &rlim) == 0 | |
819 && rlim.rlim_cur != (rlim_t) RLIM_INFINITY) | |
820 phys_kbytes = MIN (phys_kbytes, rlim.rlim_cur / 1024); | |
821 } | |
822 # endif | |
823 | |
824 /* Don't blindly run over our data limit; do GC at least when the | |
825 *next* GC would be within 20Mb of the limit or within a quarter of | |
826 the limit, whichever is larger. If GCC does hit the data limit, | |
827 compilation will fail, so this tries to be conservative. */ | |
828 limit_kbytes = MAX (0, limit_kbytes - MAX (limit_kbytes / 4, 20 * 1024)); | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
829 limit_kbytes = (limit_kbytes * 100) / (110 + ggc_min_expand_heuristic ()); |
0 | 830 phys_kbytes = MIN (phys_kbytes, limit_kbytes); |
831 | |
832 phys_kbytes = MAX (phys_kbytes, 4 * 1024); | |
833 phys_kbytes = MIN (phys_kbytes, 128 * 1024); | |
834 | |
835 return phys_kbytes; | |
836 } | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
837 #endif |
0 | 838 |
839 void | |
840 init_ggc_heuristics (void) | |
841 { | |
842 #if !defined ENABLE_GC_CHECKING && !defined ENABLE_GC_ALWAYS_COLLECT | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
843 set_default_param_value (GGC_MIN_EXPAND, ggc_min_expand_heuristic ()); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
844 set_default_param_value (GGC_MIN_HEAPSIZE, ggc_min_heapsize_heuristic ()); |
0 | 845 #endif |
846 } | |
847 | |
848 #ifdef GATHER_STATISTICS | |
849 | |
850 /* Datastructure used to store per-call-site statistics. */ | |
851 struct loc_descriptor | |
852 { | |
853 const char *file; | |
854 int line; | |
855 const char *function; | |
856 int times; | |
857 size_t allocated; | |
858 size_t overhead; | |
859 size_t freed; | |
860 size_t collected; | |
861 }; | |
862 | |
863 /* Hashtable used for statistics. */ | |
864 static htab_t loc_hash; | |
865 | |
866 /* Hash table helpers functions. */ | |
867 static hashval_t | |
868 hash_descriptor (const void *p) | |
869 { | |
870 const struct loc_descriptor *const d = (const struct loc_descriptor *) p; | |
871 | |
872 return htab_hash_pointer (d->function) | d->line; | |
873 } | |
874 | |
875 static int | |
876 eq_descriptor (const void *p1, const void *p2) | |
877 { | |
878 const struct loc_descriptor *const d = (const struct loc_descriptor *) p1; | |
879 const struct loc_descriptor *const d2 = (const struct loc_descriptor *) p2; | |
880 | |
881 return (d->file == d2->file && d->line == d2->line | |
882 && d->function == d2->function); | |
883 } | |
884 | |
885 /* Hashtable converting address of allocated field to loc descriptor. */ | |
886 static htab_t ptr_hash; | |
887 struct ptr_hash_entry | |
888 { | |
889 void *ptr; | |
890 struct loc_descriptor *loc; | |
891 size_t size; | |
892 }; | |
893 | |
894 /* Hash table helpers functions. */ | |
895 static hashval_t | |
896 hash_ptr (const void *p) | |
897 { | |
898 const struct ptr_hash_entry *const d = (const struct ptr_hash_entry *) p; | |
899 | |
900 return htab_hash_pointer (d->ptr); | |
901 } | |
902 | |
903 static int | |
904 eq_ptr (const void *p1, const void *p2) | |
905 { | |
906 const struct ptr_hash_entry *const p = (const struct ptr_hash_entry *) p1; | |
907 | |
908 return (p->ptr == p2); | |
909 } | |
910 | |
911 /* Return descriptor for given call site, create new one if needed. */ | |
912 static struct loc_descriptor * | |
913 loc_descriptor (const char *name, int line, const char *function) | |
914 { | |
915 struct loc_descriptor loc; | |
916 struct loc_descriptor **slot; | |
917 | |
918 loc.file = name; | |
919 loc.line = line; | |
920 loc.function = function; | |
921 if (!loc_hash) | |
922 loc_hash = htab_create (10, hash_descriptor, eq_descriptor, NULL); | |
923 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
924 slot = (struct loc_descriptor **) htab_find_slot (loc_hash, &loc, INSERT); |
0 | 925 if (*slot) |
926 return *slot; | |
927 *slot = XCNEW (struct loc_descriptor); | |
928 (*slot)->file = name; | |
929 (*slot)->line = line; | |
930 (*slot)->function = function; | |
931 return *slot; | |
932 } | |
933 | |
934 /* Record ALLOCATED and OVERHEAD bytes to descriptor NAME:LINE (FUNCTION). */ | |
935 void | |
936 ggc_record_overhead (size_t allocated, size_t overhead, void *ptr, | |
937 const char *name, int line, const char *function) | |
938 { | |
939 struct loc_descriptor *loc = loc_descriptor (name, line, function); | |
940 struct ptr_hash_entry *p = XNEW (struct ptr_hash_entry); | |
941 PTR *slot; | |
942 | |
943 p->ptr = ptr; | |
944 p->loc = loc; | |
945 p->size = allocated + overhead; | |
946 if (!ptr_hash) | |
947 ptr_hash = htab_create (10, hash_ptr, eq_ptr, NULL); | |
948 slot = htab_find_slot_with_hash (ptr_hash, ptr, htab_hash_pointer (ptr), INSERT); | |
949 gcc_assert (!*slot); | |
950 *slot = p; | |
951 | |
952 loc->times++; | |
953 loc->allocated+=allocated; | |
954 loc->overhead+=overhead; | |
955 } | |
956 | |
957 /* Helper function for prune_overhead_list. See if SLOT is still marked and | |
958 remove it from hashtable if it is not. */ | |
959 static int | |
960 ggc_prune_ptr (void **slot, void *b ATTRIBUTE_UNUSED) | |
961 { | |
962 struct ptr_hash_entry *p = (struct ptr_hash_entry *) *slot; | |
963 if (!ggc_marked_p (p->ptr)) | |
964 { | |
965 p->loc->collected += p->size; | |
966 htab_clear_slot (ptr_hash, slot); | |
967 free (p); | |
968 } | |
969 return 1; | |
970 } | |
971 | |
972 /* After live values has been marked, walk all recorded pointers and see if | |
973 they are still live. */ | |
974 void | |
975 ggc_prune_overhead_list (void) | |
976 { | |
977 htab_traverse (ptr_hash, ggc_prune_ptr, NULL); | |
978 } | |
979 | |
980 /* Notice that the pointer has been freed. */ | |
981 void | |
982 ggc_free_overhead (void *ptr) | |
983 { | |
984 PTR *slot = htab_find_slot_with_hash (ptr_hash, ptr, htab_hash_pointer (ptr), | |
985 NO_INSERT); | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
986 struct ptr_hash_entry *p; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
987 /* The pointer might be not found if a PCH read happened between allocation |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
988 and ggc_free () call. FIXME: account memory properly in the presence of |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
989 PCH. */ |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
990 if (!slot) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
991 return; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
992 p = (struct ptr_hash_entry *) *slot; |
0 | 993 p->loc->freed += p->size; |
994 htab_clear_slot (ptr_hash, slot); | |
995 free (p); | |
996 } | |
997 | |
998 /* Helper for qsort; sort descriptors by amount of memory consumed. */ | |
999 static int | |
1000 final_cmp_statistic (const void *loc1, const void *loc2) | |
1001 { | |
1002 const struct loc_descriptor *const l1 = | |
1003 *(const struct loc_descriptor *const *) loc1; | |
1004 const struct loc_descriptor *const l2 = | |
1005 *(const struct loc_descriptor *const *) loc2; | |
1006 long diff; | |
1007 diff = ((long)(l1->allocated + l1->overhead - l1->freed) - | |
1008 (l2->allocated + l2->overhead - l2->freed)); | |
1009 return diff > 0 ? 1 : diff < 0 ? -1 : 0; | |
1010 } | |
1011 | |
1012 /* Helper for qsort; sort descriptors by amount of memory consumed. */ | |
1013 static int | |
1014 cmp_statistic (const void *loc1, const void *loc2) | |
1015 { | |
1016 const struct loc_descriptor *const l1 = | |
1017 *(const struct loc_descriptor *const *) loc1; | |
1018 const struct loc_descriptor *const l2 = | |
1019 *(const struct loc_descriptor *const *) loc2; | |
1020 long diff; | |
1021 | |
1022 diff = ((long)(l1->allocated + l1->overhead - l1->freed - l1->collected) - | |
1023 (l2->allocated + l2->overhead - l2->freed - l2->collected)); | |
1024 if (diff) | |
1025 return diff > 0 ? 1 : diff < 0 ? -1 : 0; | |
1026 diff = ((long)(l1->allocated + l1->overhead - l1->freed) - | |
1027 (l2->allocated + l2->overhead - l2->freed)); | |
1028 return diff > 0 ? 1 : diff < 0 ? -1 : 0; | |
1029 } | |
1030 | |
1031 /* Collect array of the descriptors from hashtable. */ | |
1032 static struct loc_descriptor **loc_array; | |
1033 static int | |
1034 add_statistics (void **slot, void *b) | |
1035 { | |
1036 int *n = (int *)b; | |
1037 loc_array[*n] = (struct loc_descriptor *) *slot; | |
1038 (*n)++; | |
1039 return 1; | |
1040 } | |
1041 | |
1042 /* Dump per-site memory statistics. */ | |
1043 #endif | |
1044 void | |
1045 dump_ggc_loc_statistics (bool final ATTRIBUTE_UNUSED) | |
1046 { | |
1047 #ifdef GATHER_STATISTICS | |
1048 int nentries = 0; | |
1049 char s[4096]; | |
1050 size_t collected = 0, freed = 0, allocated = 0, overhead = 0, times = 0; | |
1051 int i; | |
1052 | |
1053 ggc_force_collect = true; | |
1054 ggc_collect (); | |
1055 | |
1056 loc_array = XCNEWVEC (struct loc_descriptor *, loc_hash->n_elements); | |
1057 fprintf (stderr, "-------------------------------------------------------\n"); | |
1058 fprintf (stderr, "\n%-48s %10s %10s %10s %10s %10s\n", | |
1059 "source location", "Garbage", "Freed", "Leak", "Overhead", "Times"); | |
1060 fprintf (stderr, "-------------------------------------------------------\n"); | |
1061 htab_traverse (loc_hash, add_statistics, &nentries); | |
1062 qsort (loc_array, nentries, sizeof (*loc_array), | |
1063 final ? final_cmp_statistic : cmp_statistic); | |
1064 for (i = 0; i < nentries; i++) | |
1065 { | |
1066 struct loc_descriptor *d = loc_array[i]; | |
1067 allocated += d->allocated; | |
1068 times += d->times; | |
1069 freed += d->freed; | |
1070 collected += d->collected; | |
1071 overhead += d->overhead; | |
1072 } | |
1073 for (i = 0; i < nentries; i++) | |
1074 { | |
1075 struct loc_descriptor *d = loc_array[i]; | |
1076 if (d->allocated) | |
1077 { | |
1078 const char *s1 = d->file; | |
1079 const char *s2; | |
1080 while ((s2 = strstr (s1, "gcc/"))) | |
1081 s1 = s2 + 4; | |
1082 sprintf (s, "%s:%i (%s)", s1, d->line, d->function); | |
1083 s[48] = 0; | |
1084 fprintf (stderr, "%-48s %10li:%4.1f%% %10li:%4.1f%% %10li:%4.1f%% %10li:%4.1f%% %10li\n", s, | |
1085 (long)d->collected, | |
1086 (d->collected) * 100.0 / collected, | |
1087 (long)d->freed, | |
1088 (d->freed) * 100.0 / freed, | |
1089 (long)(d->allocated + d->overhead - d->freed - d->collected), | |
1090 (d->allocated + d->overhead - d->freed - d->collected) * 100.0 | |
1091 / (allocated + overhead - freed - collected), | |
1092 (long)d->overhead, | |
1093 d->overhead * 100.0 / overhead, | |
1094 (long)d->times); | |
1095 } | |
1096 } | |
1097 fprintf (stderr, "%-48s %10ld %10ld %10ld %10ld %10ld\n", | |
1098 "Total", (long)collected, (long)freed, | |
1099 (long)(allocated + overhead - freed - collected), (long)overhead, | |
1100 (long)times); | |
1101 fprintf (stderr, "%-48s %10s %10s %10s %10s %10s\n", | |
1102 "source location", "Garbage", "Freed", "Leak", "Overhead", "Times"); | |
1103 fprintf (stderr, "-------------------------------------------------------\n"); | |
1104 ggc_force_collect = false; | |
1105 #endif | |
1106 } |