Mercurial > hg > CbC > CbC_gcc
annotate gcc/tree-ssa-copyrename.c @ 67:f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
author | nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp> |
---|---|
date | Tue, 22 Mar 2011 17:18:12 +0900 |
parents | b7f97abdc517 |
children |
rev | line source |
---|---|
0 | 1 /* Rename SSA copies. |
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) 2004, 2006, 2007, 2008, 2009, 2010, 2011 |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
3 Free Software Foundation, Inc. |
0 | 4 Contributed by Andrew MacLeod <amacleod@redhat.com> |
5 | |
6 This file is part of GCC. | |
7 | |
8 GCC is free software; you can redistribute it and/or modify | |
9 it under the terms of the GNU General Public License as published by | |
10 the Free Software Foundation; either version 3, or (at your option) | |
11 any later version. | |
12 | |
13 GCC is distributed in the hope that it will be useful, | |
14 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 GNU General Public License for more details. | |
17 | |
18 You should have received a copy of the GNU General Public License | |
19 along with GCC; see the file COPYING3. If not see | |
20 <http://www.gnu.org/licenses/>. */ | |
21 | |
22 #include "config.h" | |
23 #include "system.h" | |
24 #include "coretypes.h" | |
25 #include "tm.h" | |
26 #include "tree.h" | |
27 #include "gimple.h" | |
28 #include "flags.h" | |
29 #include "basic-block.h" | |
30 #include "function.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
|
31 #include "tree-pretty-print.h" |
0 | 32 #include "bitmap.h" |
33 #include "tree-flow.h" | |
34 #include "gimple.h" | |
35 #include "tree-inline.h" | |
36 #include "timevar.h" | |
37 #include "hashtab.h" | |
38 #include "tree-dump.h" | |
39 #include "tree-ssa-live.h" | |
40 #include "tree-pass.h" | |
41 #include "langhooks.h" | |
42 | |
43 /* The following routines implement the SSA copy renaming phase. | |
44 | |
45 This optimization looks for copies between 2 SSA_NAMES, either through a | |
46 direct copy, or an implicit one via a PHI node result and its arguments. | |
47 | |
48 Each copy is examined to determine if it is possible to rename the base | |
49 variable of one of the operands to the same variable as the other operand. | |
50 i.e. | |
51 T.3_5 = <blah> | |
52 a_1 = T.3_5 | |
53 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
54 If this copy couldn't be copy propagated, it could possibly remain in the |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
55 program throughout the optimization phases. After SSA->normal, it would |
0 | 56 become: |
57 | |
58 T.3 = <blah> | |
59 a = T.3 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
60 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
61 Since T.3_5 is distinct from all other SSA versions of T.3, there is no |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
62 fundamental reason why the base variable needs to be T.3, subject to |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
63 certain restrictions. This optimization attempts to determine if we can |
0 | 64 change the base variable on copies like this, and result in code such as: |
65 | |
66 a_5 = <blah> | |
67 a_1 = a_5 | |
68 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
69 This gives the SSA->normal pass a shot at coalescing a_1 and a_5. If it is |
0 | 70 possible, the copy goes away completely. If it isn't possible, a new temp |
71 will be created for a_5, and you will end up with the exact same code: | |
72 | |
73 a.8 = <blah> | |
74 a = a.8 | |
75 | |
76 The other benefit of performing this optimization relates to what variables | |
77 are chosen in copies. Gimplification of the program uses temporaries for | |
78 a lot of things. expressions like | |
79 | |
80 a_1 = <blah> | |
81 <blah2> = a_1 | |
82 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
83 get turned into |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
84 |
0 | 85 T.3_5 = <blah> |
86 a_1 = T.3_5 | |
87 <blah2> = a_1 | |
88 | |
89 Copy propagation is done in a forward direction, and if we can propagate | |
90 through the copy, we end up with: | |
91 | |
92 T.3_5 = <blah> | |
93 <blah2> = T.3_5 | |
94 | |
95 The copy is gone, but so is all reference to the user variable 'a'. By | |
96 performing this optimization, we would see the sequence: | |
97 | |
98 a_5 = <blah> | |
99 a_1 = a_5 | |
100 <blah2> = a_1 | |
101 | |
102 which copy propagation would then turn into: | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
103 |
0 | 104 a_5 = <blah> |
105 <blah2> = a_5 | |
106 | |
107 and so we still retain the user variable whenever possible. */ | |
108 | |
109 | |
110 /* Coalesce the partitions in MAP representing VAR1 and VAR2 if it is valid. | |
111 Choose a representative for the partition, and send debug info to DEBUG. */ | |
112 | |
113 static bool | |
114 copy_rename_partition_coalesce (var_map map, tree var1, tree var2, FILE *debug) | |
115 { | |
116 int p1, p2, p3; | |
117 tree root1, root2; | |
118 tree rep1, rep2; | |
119 bool ign1, ign2, abnorm; | |
120 | |
121 gcc_assert (TREE_CODE (var1) == SSA_NAME); | |
122 gcc_assert (TREE_CODE (var2) == SSA_NAME); | |
123 | |
124 register_ssa_partition (map, var1); | |
125 register_ssa_partition (map, var2); | |
126 | |
127 p1 = partition_find (map->var_partition, SSA_NAME_VERSION (var1)); | |
128 p2 = partition_find (map->var_partition, SSA_NAME_VERSION (var2)); | |
129 | |
130 if (debug) | |
131 { | |
132 fprintf (debug, "Try : "); | |
133 print_generic_expr (debug, var1, TDF_SLIM); | |
134 fprintf (debug, "(P%d) & ", p1); | |
135 print_generic_expr (debug, var2, TDF_SLIM); | |
136 fprintf (debug, "(P%d)", p2); | |
137 } | |
138 | |
139 gcc_assert (p1 != NO_PARTITION); | |
140 gcc_assert (p2 != NO_PARTITION); | |
141 | |
142 rep1 = partition_to_var (map, p1); | |
143 rep2 = partition_to_var (map, p2); | |
144 root1 = SSA_NAME_VAR (rep1); | |
145 root2 = SSA_NAME_VAR (rep2); | |
146 | |
147 if (p1 == p2) | |
148 { | |
149 if (debug) | |
150 fprintf (debug, " : Already coalesced.\n"); | |
151 return false; | |
152 } | |
153 | |
154 /* Don't coalesce if one of the variables occurs in an abnormal PHI. */ | |
155 abnorm = (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rep1) | |
156 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rep2)); | |
157 if (abnorm) | |
158 { | |
159 if (debug) | |
160 fprintf (debug, " : Abnormal PHI barrier. No coalesce.\n"); | |
161 return false; | |
162 } | |
163 | |
164 /* Partitions already have the same root, simply merge them. */ | |
165 if (root1 == root2) | |
166 { | |
167 p1 = partition_union (map->var_partition, p1, p2); | |
168 if (debug) | |
169 fprintf (debug, " : Same root, coalesced --> P%d.\n", p1); | |
170 return false; | |
171 } | |
172 | |
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
|
173 /* Never attempt to coalesce 2 different parameters. */ |
0 | 174 if (TREE_CODE (root1) == PARM_DECL && TREE_CODE (root2) == PARM_DECL) |
175 { | |
176 if (debug) | |
177 fprintf (debug, " : 2 different PARM_DECLS. No coalesce.\n"); | |
178 return false; | |
179 } | |
180 | |
181 if ((TREE_CODE (root1) == RESULT_DECL) != (TREE_CODE (root2) == RESULT_DECL)) | |
182 { | |
183 if (debug) | |
184 fprintf (debug, " : One root a RESULT_DECL. No coalesce.\n"); | |
185 return false; | |
186 } | |
187 | |
188 ign1 = TREE_CODE (root1) == VAR_DECL && DECL_IGNORED_P (root1); | |
189 ign2 = TREE_CODE (root2) == VAR_DECL && DECL_IGNORED_P (root2); | |
190 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
191 /* Never attempt to coalesce 2 user variables unless one is an inline |
0 | 192 variable. */ |
193 if (!ign1 && !ign2) | |
194 { | |
195 if (DECL_FROM_INLINE (root2)) | |
196 ign2 = true; | |
197 else if (DECL_FROM_INLINE (root1)) | |
198 ign1 = true; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
199 else |
0 | 200 { |
201 if (debug) | |
202 fprintf (debug, " : 2 different USER vars. No coalesce.\n"); | |
203 return false; | |
204 } | |
205 } | |
206 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
207 /* If both values have default defs, we can't coalesce. If only one has a |
0 | 208 tag, make sure that variable is the new root partition. */ |
209 if (gimple_default_def (cfun, root1)) | |
210 { | |
211 if (gimple_default_def (cfun, root2)) | |
212 { | |
213 if (debug) | |
214 fprintf (debug, " : 2 default defs. No coalesce.\n"); | |
215 return false; | |
216 } | |
217 else | |
218 { | |
219 ign2 = true; | |
220 ign1 = false; | |
221 } | |
222 } | |
223 else if (gimple_default_def (cfun, root2)) | |
224 { | |
225 ign1 = true; | |
226 ign2 = false; | |
227 } | |
228 | |
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
|
229 /* Don't coalesce if the new chosen root variable would be read-only. |
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
|
230 If both ign1 && ign2, then the root var of the larger partition |
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
|
231 wins, so reject in that case if any of the root vars is TREE_READONLY. |
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
|
232 Otherwise reject only if the root var, on which replace_ssa_name_symbol |
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
|
233 will be called below, is readonly. */ |
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
|
234 if ((TREE_READONLY (root1) && ign2) || (TREE_READONLY (root2) && ign1)) |
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
|
235 { |
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
|
236 if (debug) |
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
|
237 fprintf (debug, " : Readonly variable. No coalesce.\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
|
238 return false; |
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
|
239 } |
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 |
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 /* Don't coalesce if the two variables aren't type compatible . */ |
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
|
242 if (!types_compatible_p (TREE_TYPE (root1), TREE_TYPE (root2)) |
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 /* There is a disconnect between the middle-end type-system and |
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 VRP, avoid coalescing enum types with different bounds. */ |
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 || ((TREE_CODE (TREE_TYPE (root1)) == ENUMERAL_TYPE |
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 || TREE_CODE (TREE_TYPE (root2)) == ENUMERAL_TYPE) |
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 && TREE_TYPE (root1) != TREE_TYPE (root2))) |
0 | 248 { |
249 if (debug) | |
250 fprintf (debug, " : Incompatible types. No coalesce.\n"); | |
251 return false; | |
252 } | |
253 | |
254 /* Merge the two partitions. */ | |
255 p3 = partition_union (map->var_partition, p1, p2); | |
256 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
257 /* Set the root variable of the partition to the better choice, if there is |
0 | 258 one. */ |
259 if (!ign2) | |
260 replace_ssa_name_symbol (partition_to_var (map, p3), root2); | |
261 else if (!ign1) | |
262 replace_ssa_name_symbol (partition_to_var (map, p3), root1); | |
263 | |
264 if (debug) | |
265 { | |
266 fprintf (debug, " --> P%d ", p3); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
267 print_generic_expr (debug, SSA_NAME_VAR (partition_to_var (map, p3)), |
0 | 268 TDF_SLIM); |
269 fprintf (debug, "\n"); | |
270 } | |
271 return true; | |
272 } | |
273 | |
274 | |
275 /* This function will make a pass through the IL, and attempt to coalesce any | |
276 SSA versions which occur in PHI's or copies. Coalescing is accomplished by | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
277 changing the underlying root variable of all coalesced version. This will |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
278 then cause the SSA->normal pass to attempt to coalesce them all to the same |
0 | 279 variable. */ |
280 | |
281 static unsigned int | |
282 rename_ssa_copies (void) | |
283 { | |
284 var_map map; | |
285 basic_block bb; | |
286 gimple_stmt_iterator gsi; | |
287 tree var, part_var; | |
288 gimple stmt, phi; | |
289 unsigned x; | |
290 FILE *debug; | |
291 bool updated = false; | |
292 | |
293 if (dump_file && (dump_flags & TDF_DETAILS)) | |
294 debug = dump_file; | |
295 else | |
296 debug = NULL; | |
297 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
298 map = init_var_map (num_ssa_names); |
0 | 299 |
300 FOR_EACH_BB (bb) | |
301 { | |
302 /* Scan for real copies. */ | |
303 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) | |
304 { | |
305 stmt = gsi_stmt (gsi); | |
306 if (gimple_assign_ssa_name_copy_p (stmt)) | |
307 { | |
308 tree lhs = gimple_assign_lhs (stmt); | |
309 tree rhs = gimple_assign_rhs1 (stmt); | |
310 | |
311 updated |= copy_rename_partition_coalesce (map, lhs, rhs, debug); | |
312 } | |
313 } | |
314 } | |
315 | |
316 FOR_EACH_BB (bb) | |
317 { | |
318 /* Treat PHI nodes as copies between the result and each argument. */ | |
319 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi)) | |
320 { | |
321 size_t i; | |
322 tree res; | |
323 | |
324 phi = gsi_stmt (gsi); | |
325 res = gimple_phi_result (phi); | |
326 | |
327 /* Do not process virtual SSA_NAMES. */ | |
328 if (!is_gimple_reg (SSA_NAME_VAR (res))) | |
329 continue; | |
330 | |
331 for (i = 0; i < gimple_phi_num_args (phi); i++) | |
332 { | |
333 tree arg = gimple_phi_arg (phi, i)->def; | |
334 if (TREE_CODE (arg) == SSA_NAME) | |
335 updated |= copy_rename_partition_coalesce (map, res, arg, debug); | |
336 } | |
337 } | |
338 } | |
339 | |
340 if (debug) | |
341 dump_var_map (debug, map); | |
342 | |
343 /* Now one more pass to make all elements of a partition share the same | |
344 root variable. */ | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
345 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
346 for (x = 1; x < num_ssa_names; x++) |
0 | 347 { |
348 part_var = partition_to_var (map, x); | |
349 if (!part_var) | |
350 continue; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
351 var = ssa_name (x); |
0 | 352 if (debug) |
353 { | |
354 if (SSA_NAME_VAR (var) != SSA_NAME_VAR (part_var)) | |
355 { | |
356 fprintf (debug, "Coalesced "); | |
357 print_generic_expr (debug, var, TDF_SLIM); | |
358 fprintf (debug, " to "); | |
359 print_generic_expr (debug, part_var, TDF_SLIM); | |
360 fprintf (debug, "\n"); | |
361 } | |
362 } | |
363 replace_ssa_name_symbol (var, SSA_NAME_VAR (part_var)); | |
364 } | |
365 | |
366 delete_var_map (map); | |
367 return updated ? TODO_remove_unused_locals : 0; | |
368 } | |
369 | |
370 /* Return true if copy rename is to be performed. */ | |
371 | |
372 static bool | |
373 gate_copyrename (void) | |
374 { | |
375 return flag_tree_copyrename != 0; | |
376 } | |
377 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
378 struct gimple_opt_pass pass_rename_ssa_copies = |
0 | 379 { |
380 { | |
381 GIMPLE_PASS, | |
382 "copyrename", /* name */ | |
383 gate_copyrename, /* gate */ | |
384 rename_ssa_copies, /* execute */ | |
385 NULL, /* sub */ | |
386 NULL, /* next */ | |
387 0, /* static_pass_number */ | |
388 TV_TREE_COPY_RENAME, /* tv_id */ | |
389 PROP_cfg | PROP_ssa, /* properties_required */ | |
390 0, /* properties_provided */ | |
391 0, /* properties_destroyed */ | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
392 0, /* todo_flags_start */ |
0 | 393 TODO_dump_func | TODO_verify_ssa /* todo_flags_finish */ |
394 } | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
395 }; |