1 # |
|
2 # Backport xmallocarray, an overflow checking version of xmalloc (CVE-2014-5044) |
|
3 # |
|
4 # 2014-07-31 Janne Blomqvist <[email protected]> |
|
5 # |
|
6 # Backport from mainline |
|
7 # CVE-2014-5044 |
|
8 # * libgfortran.h (xmallocarray): New prototype. |
|
9 # * runtime/memory.c (xmallocarray): New function. |
|
10 # (xcalloc): Check for nonzero separately instead of multiplying. |
|
11 # * generated/*.c: Regenerated. |
|
12 # * intrinsics/cshift0.c (cshift0): Call xmallocarray instead of |
|
13 # xmalloc. |
|
14 # * intrinsics/eoshift0.c (eoshift0): Likewise. |
|
15 # * intrinsics/eoshift2.c (eoshift2): Likewise. |
|
16 # * intrinsics/pack_generic.c (pack_internal): Likewise. |
|
17 # (pack_s_internal): Likewise. |
|
18 # * intrinsics/reshape_generic.c (reshape_internal): Likewise. |
|
19 # * intrinsics/spread_generic.c (spread_internal): Likewise. |
|
20 # (spread_internal_scalar): Likewise. |
|
21 # * intrinsics/string_intrinsics_inc.c (string_trim): Likewise. |
|
22 # (string_minmax): Likewise. |
|
23 # * intrinsics/transpose_generic.c (transpose_internal): Likewise. |
|
24 # * intrinsics/unpack_generic.c (unpack_internal): Likewise. |
|
25 # * io/list_read.c (nml_touch_nodes): Don't cast xmalloc return value. |
|
26 # * io/transfer.c (st_set_nml_var): Call xmallocarray instead of |
|
27 # xmalloc. |
|
28 # * io/unit.c (get_internal_unit): Likewise. |
|
29 # (filename_from_unit): Don't cast xmalloc return value. |
|
30 # * io/write.c (nml_write_obj): Likewise, formatting. |
|
31 # * m4/bessel.m4 (bessel_jn_r'rtype_kind`): Call xmallocarray |
|
32 # instead of xmalloc. |
|
33 # (besse_yn_r'rtype_kind`): Likewise. |
|
34 # * m4/cshift1.m4 (cshift1): Likewise. |
|
35 # * m4/eoshift1.m4 (eoshift1): Likewise. |
|
36 # * m4/eoshift3.m4 (eoshift3): Likewise. |
|
37 # * m4/iforeach.m4: Likewise. |
|
38 # * m4/ifunction.m4: Likewise. |
|
39 # * m4/ifunction_logical.m4 (name`'rtype_qual`_'atype_code): |
|
40 # Likewise. |
|
41 # * m4/in_pack.m4 (internal_pack_'rtype_ccode`): Likewise. |
|
42 # * m4/matmul.m4 (matmul_'rtype_code`): Likewise. |
|
43 # * m4/matmull.m4 (matmul_'rtype_code`): Likewise. |
|
44 # * m4/pack.m4 (pack_'rtype_code`): Likewise. |
|
45 # * m4/reshape.m4 (reshape_'rtype_ccode`): Likewise. |
|
46 # * m4/shape.m4 (shape_'rtype_kind`): Likewise. |
|
47 # * m4/spread.m4 (spread_'rtype_code`): Likewise. |
|
48 # (spread_scalar_'rtype_code`): Likewise. |
|
49 # * m4/transpose.m4 (transpose_'rtype_code`): Likewise. |
|
50 # * m4/unpack.m4 (unpack0_'rtype_code`): Likewise. |
|
51 # (unpack1_'rtype_code`): Likewise. |
|
52 # * runtime/convert_char.c (convert_char1_to_char4): Likewise. |
|
53 # (convert_char4_to_char1): Simplify. |
|
54 # * runtime/environ.c (init_unformatted): Call xmallocarray instead |
|
55 # of xmalloc. |
|
56 # * runtime/in_pack_generic.c (internal_pack): Likewise. |
|
57 # |
|
58 |
|
59 Index: gcc-4.8_branch/libgfortran/m4/in_pack.m4 |
|
60 =================================================================== |
|
61 --- gcc-4.8_branch/libgfortran/m4/in_pack.m4 (revision 213312) |
|
62 +++ gcc-4.8_branch/libgfortran/m4/in_pack.m4 (revision 213313) |
|
63 @@ -79,7 +79,7 @@ |
|
64 return source->base_addr; |
|
65 |
|
66 /* Allocate storage for the destination. */ |
|
67 - destptr = ('rtype_name` *)xmalloc (ssize * sizeof ('rtype_name`)); |
|
68 + destptr = xmallocarray (ssize, sizeof ('rtype_name`)); |
|
69 dest = destptr; |
|
70 src = source->base_addr; |
|
71 stride0 = stride[0]; |
|
72 Index: gcc-4.8_branch/libgfortran/m4/pack.m4 |
|
73 =================================================================== |
|
74 --- gcc-4.8_branch/libgfortran/m4/pack.m4 (revision 213312) |
|
75 +++ gcc-4.8_branch/libgfortran/m4/pack.m4 (revision 213313) |
|
76 @@ -168,8 +168,8 @@ |
|
77 |
|
78 ret->offset = 0; |
|
79 |
|
80 - /* xmalloc allocates a single byte for zero size. */ |
|
81 - ret->base_addr = xmalloc (sizeof ('rtype_name`) * total); |
|
82 + /* xmallocarray allocates a single byte for zero size. */ |
|
83 + ret->base_addr = xmallocarray (total, sizeof ('rtype_name`)); |
|
84 |
|
85 if (total == 0) |
|
86 return; |
|
87 Index: gcc-4.8_branch/libgfortran/m4/spread.m4 |
|
88 =================================================================== |
|
89 --- gcc-4.8_branch/libgfortran/m4/spread.m4 (revision 213312) |
|
90 +++ gcc-4.8_branch/libgfortran/m4/spread.m4 (revision 213313) |
|
91 @@ -102,8 +102,8 @@ |
|
92 } |
|
93 ret->offset = 0; |
|
94 |
|
95 - /* xmalloc allocates a single byte for zero size. */ |
|
96 - ret->base_addr = xmalloc (rs * sizeof('rtype_name`)); |
|
97 + /* xmallocarray allocates a single byte for zero size. */ |
|
98 + ret->base_addr = xmallocarray (rs, sizeof('rtype_name`)); |
|
99 if (rs <= 0) |
|
100 return; |
|
101 } |
|
102 @@ -245,7 +245,7 @@ |
|
103 |
|
104 if (ret->base_addr == NULL) |
|
105 { |
|
106 - ret->base_addr = xmalloc (ncopies * sizeof ('rtype_name`)); |
|
107 + ret->base_addr = xmallocarray (ncopies, sizeof ('rtype_name`)); |
|
108 ret->offset = 0; |
|
109 GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1); |
|
110 } |
|
111 Index: gcc-4.8_branch/libgfortran/m4/transpose.m4 |
|
112 =================================================================== |
|
113 --- gcc-4.8_branch/libgfortran/m4/transpose.m4 (revision 213312) |
|
114 +++ gcc-4.8_branch/libgfortran/m4/transpose.m4 (revision 213313) |
|
115 @@ -61,7 +61,8 @@ |
|
116 GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0) - 1, |
|
117 GFC_DESCRIPTOR_EXTENT(source, 1)); |
|
118 |
|
119 - ret->base_addr = xmalloc (sizeof ('rtype_name`) * size0 ((array_t *) ret)); |
|
120 + ret->base_addr = xmallocarray (size0 ((array_t *) ret), |
|
121 + sizeof ('rtype_name`)); |
|
122 ret->offset = 0; |
|
123 } else if (unlikely (compile_options.bounds_check)) |
|
124 { |
|
125 Index: gcc-4.8_branch/libgfortran/m4/iforeach.m4 |
|
126 =================================================================== |
|
127 --- gcc-4.8_branch/libgfortran/m4/iforeach.m4 (revision 213312) |
|
128 +++ gcc-4.8_branch/libgfortran/m4/iforeach.m4 (revision 213313) |
|
129 @@ -30,7 +30,7 @@ |
|
130 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
131 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
132 retarray->offset = 0; |
|
133 - retarray->base_addr = xmalloc (sizeof (rtype_name) * rank); |
|
134 + retarray->base_addr = xmallocarray (rank, sizeof (rtype_name)); |
|
135 } |
|
136 else |
|
137 { |
|
138 @@ -133,7 +133,7 @@ |
|
139 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
140 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
141 retarray->offset = 0; |
|
142 - retarray->base_addr = xmalloc (sizeof (rtype_name) * rank); |
|
143 + retarray->base_addr = xmallocarray (rank, sizeof (rtype_name)); |
|
144 } |
|
145 else |
|
146 { |
|
147 @@ -264,7 +264,7 @@ |
|
148 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
149 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
150 retarray->offset = 0; |
|
151 - retarray->base_addr = xmalloc (sizeof (rtype_name) * rank); |
|
152 + retarray->base_addr = xmallocarray (rank, sizeof (rtype_name)); |
|
153 } |
|
154 else if (unlikely (compile_options.bounds_check)) |
|
155 { |
|
156 Index: gcc-4.8_branch/libgfortran/m4/eoshift1.m4 |
|
157 =================================================================== |
|
158 --- gcc-4.8_branch/libgfortran/m4/eoshift1.m4 (revision 213312) |
|
159 +++ gcc-4.8_branch/libgfortran/m4/eoshift1.m4 (revision 213313) |
|
160 @@ -106,8 +106,8 @@ |
|
161 GFC_DIMENSION_SET(ret->dim[i], 0, ub, str); |
|
162 |
|
163 } |
|
164 - /* xmalloc allocates a single byte for zero size. */ |
|
165 - ret->base_addr = xmalloc (size * arraysize); |
|
166 + /* xmallocarray allocates a single byte for zero size. */ |
|
167 + ret->base_addr = xmallocarray (arraysize, size); |
|
168 |
|
169 } |
|
170 else if (unlikely (compile_options.bounds_check)) |
|
171 Index: gcc-4.8_branch/libgfortran/m4/eoshift3.m4 |
|
172 =================================================================== |
|
173 --- gcc-4.8_branch/libgfortran/m4/eoshift3.m4 (revision 213312) |
|
174 +++ gcc-4.8_branch/libgfortran/m4/eoshift3.m4 (revision 213313) |
|
175 @@ -90,7 +90,7 @@ |
|
176 { |
|
177 int i; |
|
178 |
|
179 - ret->base_addr = xmalloc (size * arraysize); |
|
180 + ret->base_addr = xmallocarray (arraysize, size); |
|
181 ret->offset = 0; |
|
182 ret->dtype = array->dtype; |
|
183 for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++) |
|
184 @@ -108,8 +108,8 @@ |
|
185 GFC_DIMENSION_SET(ret->dim[i], 0, ub, str); |
|
186 |
|
187 } |
|
188 - /* xmalloc allocates a single byte for zero size. */ |
|
189 - ret->base_addr = xmalloc (size * arraysize); |
|
190 + /* xmallocarray allocates a single byte for zero size. */ |
|
191 + ret->base_addr = xmallocarray (arraysize, size); |
|
192 |
|
193 } |
|
194 else if (unlikely (compile_options.bounds_check)) |
|
195 Index: gcc-4.8_branch/libgfortran/m4/shape.m4 |
|
196 =================================================================== |
|
197 --- gcc-4.8_branch/libgfortran/m4/shape.m4 (revision 213312) |
|
198 +++ gcc-4.8_branch/libgfortran/m4/shape.m4 (revision 213313) |
|
199 @@ -50,7 +50,7 @@ |
|
200 { |
|
201 GFC_DIMENSION_SET(ret->dim[0], 0, rank - 1, 1); |
|
202 ret->offset = 0; |
|
203 - ret->base_addr = xmalloc (sizeof ('rtype_name`) * rank); |
|
204 + ret->base_addr = xmallocarray (rank, sizeof ('rtype_name`)); |
|
205 } |
|
206 |
|
207 stride = GFC_DESCRIPTOR_STRIDE(ret,0); |
|
208 Index: gcc-4.8_branch/libgfortran/m4/cshift1.m4 |
|
209 =================================================================== |
|
210 --- gcc-4.8_branch/libgfortran/m4/cshift1.m4 (revision 213312) |
|
211 +++ gcc-4.8_branch/libgfortran/m4/cshift1.m4 (revision 213313) |
|
212 @@ -81,7 +81,7 @@ |
|
213 { |
|
214 int i; |
|
215 |
|
216 - ret->base_addr = xmalloc (size * arraysize); |
|
217 + ret->base_addr = xmallocarray (arraysize, size); |
|
218 ret->offset = 0; |
|
219 ret->dtype = array->dtype; |
|
220 for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++) |
|
221 Index: gcc-4.8_branch/libgfortran/m4/matmull.m4 |
|
222 =================================================================== |
|
223 --- gcc-4.8_branch/libgfortran/m4/matmull.m4 (revision 213312) |
|
224 +++ gcc-4.8_branch/libgfortran/m4/matmull.m4 (revision 213313) |
|
225 @@ -89,7 +89,7 @@ |
|
226 } |
|
227 |
|
228 retarray->base_addr |
|
229 - = xmalloc (sizeof ('rtype_name`) * size0 ((array_t *) retarray)); |
|
230 + = xmallocarray (size0 ((array_t *) retarray), sizeof ('rtype_name`)); |
|
231 retarray->offset = 0; |
|
232 } |
|
233 else if (unlikely (compile_options.bounds_check)) |
|
234 Index: gcc-4.8_branch/libgfortran/m4/bessel.m4 |
|
235 =================================================================== |
|
236 --- gcc-4.8_branch/libgfortran/m4/bessel.m4 (revision 213312) |
|
237 +++ gcc-4.8_branch/libgfortran/m4/bessel.m4 (revision 213313) |
|
238 @@ -56,7 +56,7 @@ |
|
239 { |
|
240 size_t size = n2 < n1 ? 0 : n2-n1+1; |
|
241 GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1); |
|
242 - ret->base_addr = xmalloc (sizeof ('rtype_name`) * size); |
|
243 + ret->base_addr = xmallocarray (size, sizeof ('rtype_name`)); |
|
244 ret->offset = 0; |
|
245 } |
|
246 |
|
247 @@ -123,7 +123,7 @@ |
|
248 { |
|
249 size_t size = n2 < n1 ? 0 : n2-n1+1; |
|
250 GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1); |
|
251 - ret->base_addr = xmalloc (sizeof ('rtype_name`) * size); |
|
252 + ret->base_addr = xmallocarray (size, sizeof ('rtype_name`)); |
|
253 ret->offset = 0; |
|
254 } |
|
255 |
|
256 Index: gcc-4.8_branch/libgfortran/m4/unpack.m4 |
|
257 =================================================================== |
|
258 --- gcc-4.8_branch/libgfortran/m4/unpack.m4 (revision 213312) |
|
259 +++ gcc-4.8_branch/libgfortran/m4/unpack.m4 (revision 213313) |
|
260 @@ -100,7 +100,7 @@ |
|
261 rs *= extent[n]; |
|
262 } |
|
263 ret->offset = 0; |
|
264 - ret->base_addr = xmalloc (rs * sizeof ('rtype_name`)); |
|
265 + ret->base_addr = xmallocarray (rs, sizeof ('rtype_name`)); |
|
266 } |
|
267 else |
|
268 { |
|
269 @@ -245,7 +245,7 @@ |
|
270 rs *= extent[n]; |
|
271 } |
|
272 ret->offset = 0; |
|
273 - ret->base_addr = xmalloc (rs * sizeof ('rtype_name`)); |
|
274 + ret->base_addr = xmallocarray (rs, sizeof ('rtype_name`)); |
|
275 } |
|
276 else |
|
277 { |
|
278 Index: gcc-4.8_branch/libgfortran/m4/reshape.m4 |
|
279 =================================================================== |
|
280 --- gcc-4.8_branch/libgfortran/m4/reshape.m4 (revision 213312) |
|
281 +++ gcc-4.8_branch/libgfortran/m4/reshape.m4 (revision 213313) |
|
282 @@ -115,11 +115,11 @@ |
|
283 ret->offset = 0; |
|
284 |
|
285 if (unlikely (rs < 1)) |
|
286 - alloc_size = 1; |
|
287 + alloc_size = 0; |
|
288 else |
|
289 - alloc_size = rs * sizeof ('rtype_name`); |
|
290 + alloc_size = rs; |
|
291 |
|
292 - ret->base_addr = xmalloc (alloc_size); |
|
293 + ret->base_addr = xmallocarray (alloc_size, sizeof ('rtype_name`)); |
|
294 ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim; |
|
295 } |
|
296 |
|
297 Index: gcc-4.8_branch/libgfortran/m4/ifunction_logical.m4 |
|
298 =================================================================== |
|
299 --- gcc-4.8_branch/libgfortran/m4/ifunction_logical.m4 (revision 213312) |
|
300 +++ gcc-4.8_branch/libgfortran/m4/ifunction_logical.m4 (revision 213313) |
|
301 @@ -89,8 +89,7 @@ |
|
302 retarray->offset = 0; |
|
303 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
304 |
|
305 - alloc_size = sizeof (rtype_name) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
306 - * extent[rank-1]; |
|
307 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
308 |
|
309 if (alloc_size == 0) |
|
310 { |
|
311 @@ -99,7 +98,7 @@ |
|
312 return; |
|
313 } |
|
314 else |
|
315 - retarray->base_addr = xmalloc (alloc_size); |
|
316 + retarray->base_addr = xmallocarray (alloc_size, sizeof (rtype_name)); |
|
317 } |
|
318 else |
|
319 { |
|
320 Index: gcc-4.8_branch/libgfortran/m4/ifunction.m4 |
|
321 =================================================================== |
|
322 --- gcc-4.8_branch/libgfortran/m4/ifunction.m4 (revision 213312) |
|
323 +++ gcc-4.8_branch/libgfortran/m4/ifunction.m4 (revision 213313) |
|
324 @@ -85,10 +85,9 @@ |
|
325 retarray->offset = 0; |
|
326 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
327 |
|
328 - alloc_size = sizeof (rtype_name) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
329 - * extent[rank-1]; |
|
330 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
331 |
|
332 - retarray->base_addr = xmalloc (alloc_size); |
|
333 + retarray->base_addr = xmallocarray (alloc_size, sizeof (rtype_name)); |
|
334 if (alloc_size == 0) |
|
335 { |
|
336 /* Make sure we have a zero-sized array. */ |
|
337 @@ -260,8 +259,7 @@ |
|
338 |
|
339 } |
|
340 |
|
341 - alloc_size = sizeof (rtype_name) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
342 - * extent[rank-1]; |
|
343 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
344 |
|
345 retarray->offset = 0; |
|
346 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
347 @@ -273,7 +271,7 @@ |
|
348 return; |
|
349 } |
|
350 else |
|
351 - retarray->base_addr = xmalloc (alloc_size); |
|
352 + retarray->base_addr = xmallocarray (alloc_size, sizeof (rtype_name)); |
|
353 |
|
354 } |
|
355 else |
|
356 @@ -417,8 +415,7 @@ |
|
357 retarray->offset = 0; |
|
358 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
359 |
|
360 - alloc_size = sizeof (rtype_name) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
361 - * extent[rank-1]; |
|
362 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
363 |
|
364 if (alloc_size == 0) |
|
365 { |
|
366 @@ -427,7 +424,7 @@ |
|
367 return; |
|
368 } |
|
369 else |
|
370 - retarray->base_addr = xmalloc (alloc_size); |
|
371 + retarray->base_addr = xmallocarray (alloc_size, sizeof (rtype_name)); |
|
372 } |
|
373 else |
|
374 { |
|
375 Index: gcc-4.8_branch/libgfortran/m4/matmul.m4 |
|
376 =================================================================== |
|
377 --- gcc-4.8_branch/libgfortran/m4/matmul.m4 (revision 213312) |
|
378 +++ gcc-4.8_branch/libgfortran/m4/matmul.m4 (revision 213313) |
|
379 @@ -125,7 +125,7 @@ |
|
380 } |
|
381 |
|
382 retarray->base_addr |
|
383 - = xmalloc (sizeof ('rtype_name`) * size0 ((array_t *) retarray)); |
|
384 + = xmallocarray (size0 ((array_t *) retarray), sizeof ('rtype_name`)); |
|
385 retarray->offset = 0; |
|
386 } |
|
387 else if (unlikely (compile_options.bounds_check)) |
|
388 Index: gcc-4.8_branch/libgfortran/runtime/in_pack_generic.c |
|
389 =================================================================== |
|
390 --- gcc-4.8_branch/libgfortran/runtime/in_pack_generic.c (revision 213312) |
|
391 +++ gcc-4.8_branch/libgfortran/runtime/in_pack_generic.c (revision 213313) |
|
392 @@ -180,7 +180,7 @@ |
|
393 return source->base_addr; |
|
394 |
|
395 /* Allocate storage for the destination. */ |
|
396 - destptr = xmalloc (ssize * size); |
|
397 + destptr = xmallocarray (ssize, size); |
|
398 dest = (char *)destptr; |
|
399 src = source->base_addr; |
|
400 stride0 = stride[0] * size; |
|
401 Index: gcc-4.8_branch/libgfortran/runtime/memory.c |
|
402 =================================================================== |
|
403 --- gcc-4.8_branch/libgfortran/runtime/memory.c (revision 213312) |
|
404 +++ gcc-4.8_branch/libgfortran/runtime/memory.c (revision 213313) |
|
405 @@ -25,8 +25,13 @@ |
|
406 |
|
407 #include "libgfortran.h" |
|
408 #include <stdlib.h> |
|
409 +#include <errno.h> |
|
410 |
|
411 +#ifndef SIZE_MAX |
|
412 +#define SIZE_MAX ((size_t)-1) |
|
413 +#endif |
|
414 |
|
415 + |
|
416 void * |
|
417 xmalloc (size_t n) |
|
418 { |
|
419 @@ -44,12 +49,34 @@ |
|
420 } |
|
421 |
|
422 |
|
423 +void * |
|
424 +xmallocarray (size_t nmemb, size_t size) |
|
425 +{ |
|
426 + void *p; |
|
427 + |
|
428 + if (!nmemb || !size) |
|
429 + size = nmemb = 1; |
|
430 + else if (nmemb > SIZE_MAX / size) |
|
431 + { |
|
432 + errno = ENOMEM; |
|
433 + os_error ("Integer overflow in xmallocarray"); |
|
434 + } |
|
435 + |
|
436 + p = malloc (nmemb * size); |
|
437 + |
|
438 + if (!p) |
|
439 + os_error ("Memory allocation failed in xmallocarray"); |
|
440 + |
|
441 + return p; |
|
442 +} |
|
443 + |
|
444 + |
|
445 /* calloc wrapper that aborts on error. */ |
|
446 |
|
447 void * |
|
448 xcalloc (size_t nmemb, size_t size) |
|
449 { |
|
450 - if (nmemb * size == 0) |
|
451 + if (!nmemb || !size) |
|
452 nmemb = size = 1; |
|
453 |
|
454 void *p = calloc (nmemb, size); |
|
455 Index: gcc-4.8_branch/libgfortran/runtime/convert_char.c |
|
456 =================================================================== |
|
457 --- gcc-4.8_branch/libgfortran/runtime/convert_char.c (revision 213312) |
|
458 +++ gcc-4.8_branch/libgfortran/runtime/convert_char.c (revision 213313) |
|
459 @@ -44,7 +44,7 @@ |
|
460 gfc_charlen_type i, l; |
|
461 |
|
462 l = len > 0 ? len : 0; |
|
463 - *dst = xmalloc ((l + 1) * sizeof (gfc_char4_t)); |
|
464 + *dst = xmallocarray ((l + 1), sizeof (gfc_char4_t)); |
|
465 |
|
466 for (i = 0; i < l; i++) |
|
467 (*dst)[i] = src[i]; |
|
468 @@ -60,7 +60,7 @@ |
|
469 gfc_charlen_type i, l; |
|
470 |
|
471 l = len > 0 ? len : 0; |
|
472 - *dst = xmalloc ((l + 1) * sizeof (unsigned char)); |
|
473 + *dst = xmalloc (l + 1); |
|
474 |
|
475 for (i = 0; i < l; i++) |
|
476 (*dst)[i] = src[i]; |
|
477 Index: gcc-4.8_branch/libgfortran/runtime/environ.c |
|
478 =================================================================== |
|
479 --- gcc-4.8_branch/libgfortran/runtime/environ.c (revision 213312) |
|
480 +++ gcc-4.8_branch/libgfortran/runtime/environ.c (revision 213313) |
|
481 @@ -833,7 +833,7 @@ |
|
482 } |
|
483 else |
|
484 { |
|
485 - elist = xmalloc (unit_count * sizeof (exception_t)); |
|
486 + elist = xmallocarray (unit_count, sizeof (exception_t)); |
|
487 do_count = 0; |
|
488 p = val; |
|
489 do_parse (); |
|
490 Index: gcc-4.8_branch/libgfortran/intrinsics/string_intrinsics_inc.c |
|
491 =================================================================== |
|
492 --- gcc-4.8_branch/libgfortran/intrinsics/string_intrinsics_inc.c (revision 213312) |
|
493 +++ gcc-4.8_branch/libgfortran/intrinsics/string_intrinsics_inc.c (revision 213313) |
|
494 @@ -164,7 +164,7 @@ |
|
495 else |
|
496 { |
|
497 /* Allocate space for result string. */ |
|
498 - *dest = xmalloc (*len * sizeof (CHARTYPE)); |
|
499 + *dest = xmallocarray (*len, sizeof (CHARTYPE)); |
|
500 |
|
501 /* Copy string if necessary. */ |
|
502 memcpy (*dest, src, *len * sizeof (CHARTYPE)); |
|
503 @@ -442,7 +442,7 @@ |
|
504 *dest = &zero_length_string; |
|
505 else |
|
506 { |
|
507 - CHARTYPE *tmp = xmalloc (*rlen * sizeof (CHARTYPE)); |
|
508 + CHARTYPE *tmp = xmallocarray (*rlen, sizeof (CHARTYPE)); |
|
509 memcpy (tmp, res, reslen * sizeof (CHARTYPE)); |
|
510 MEMSET (&tmp[reslen], ' ', *rlen - reslen); |
|
511 *dest = tmp; |
|
512 Index: gcc-4.8_branch/libgfortran/intrinsics/pack_generic.c |
|
513 =================================================================== |
|
514 --- gcc-4.8_branch/libgfortran/intrinsics/pack_generic.c (revision 213312) |
|
515 +++ gcc-4.8_branch/libgfortran/intrinsics/pack_generic.c (revision 213313) |
|
516 @@ -152,8 +152,8 @@ |
|
517 GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1); |
|
518 |
|
519 ret->offset = 0; |
|
520 - /* xmalloc allocates a single byte for zero size. */ |
|
521 - ret->base_addr = xmalloc (size * total); |
|
522 + /* xmallocarray allocates a single byte for zero size. */ |
|
523 + ret->base_addr = xmallocarray (total, size); |
|
524 |
|
525 if (total == 0) |
|
526 return; /* In this case, nothing remains to be done. */ |
|
527 @@ -519,7 +519,7 @@ |
|
528 |
|
529 ret->offset = 0; |
|
530 |
|
531 - ret->base_addr = xmalloc (size * total); |
|
532 + ret->base_addr = xmallocarray (total, size); |
|
533 |
|
534 if (total == 0) |
|
535 return; |
|
536 Index: gcc-4.8_branch/libgfortran/intrinsics/transpose_generic.c |
|
537 =================================================================== |
|
538 --- gcc-4.8_branch/libgfortran/intrinsics/transpose_generic.c (revision 213312) |
|
539 +++ gcc-4.8_branch/libgfortran/intrinsics/transpose_generic.c (revision 213313) |
|
540 @@ -60,7 +60,7 @@ |
|
541 GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0) - 1, |
|
542 GFC_DESCRIPTOR_EXTENT(source, 1)); |
|
543 |
|
544 - ret->base_addr = xmalloc (size * size0 ((array_t*)ret)); |
|
545 + ret->base_addr = xmallocarray (size0 ((array_t*)ret), size); |
|
546 ret->offset = 0; |
|
547 } |
|
548 else if (unlikely (compile_options.bounds_check)) |
|
549 Index: gcc-4.8_branch/libgfortran/intrinsics/cshift0.c |
|
550 =================================================================== |
|
551 --- gcc-4.8_branch/libgfortran/intrinsics/cshift0.c (revision 213312) |
|
552 +++ gcc-4.8_branch/libgfortran/intrinsics/cshift0.c (revision 213313) |
|
553 @@ -79,8 +79,8 @@ |
|
554 GFC_DIMENSION_SET(ret->dim[i], 0, ub, str); |
|
555 } |
|
556 |
|
557 - /* xmalloc allocates a single byte for zero size. */ |
|
558 - ret->base_addr = xmalloc (size * arraysize); |
|
559 + /* xmallocarray allocates a single byte for zero size. */ |
|
560 + ret->base_addr = xmallocarray (arraysize, size); |
|
561 } |
|
562 else if (unlikely (compile_options.bounds_check)) |
|
563 { |
|
564 Index: gcc-4.8_branch/libgfortran/intrinsics/spread_generic.c |
|
565 =================================================================== |
|
566 --- gcc-4.8_branch/libgfortran/intrinsics/spread_generic.c (revision 213312) |
|
567 +++ gcc-4.8_branch/libgfortran/intrinsics/spread_generic.c (revision 213313) |
|
568 @@ -100,7 +100,7 @@ |
|
569 GFC_DIMENSION_SET(ret->dim[n], 0, ub, stride); |
|
570 } |
|
571 ret->offset = 0; |
|
572 - ret->base_addr = xmalloc (rs * size); |
|
573 + ret->base_addr = xmallocarray (rs, size); |
|
574 |
|
575 if (rs <= 0) |
|
576 return; |
|
577 @@ -245,7 +245,7 @@ |
|
578 |
|
579 if (ret->base_addr == NULL) |
|
580 { |
|
581 - ret->base_addr = xmalloc (ncopies * size); |
|
582 + ret->base_addr = xmallocarray (ncopies, size); |
|
583 ret->offset = 0; |
|
584 GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1); |
|
585 } |
|
586 Index: gcc-4.8_branch/libgfortran/intrinsics/unpack_generic.c |
|
587 =================================================================== |
|
588 --- gcc-4.8_branch/libgfortran/intrinsics/unpack_generic.c (revision 213312) |
|
589 +++ gcc-4.8_branch/libgfortran/intrinsics/unpack_generic.c (revision 213313) |
|
590 @@ -125,7 +125,7 @@ |
|
591 rs *= extent[n]; |
|
592 } |
|
593 ret->offset = 0; |
|
594 - ret->base_addr = xmalloc (rs * size); |
|
595 + ret->base_addr = xmallocarray (rs, size); |
|
596 } |
|
597 else |
|
598 { |
|
599 Index: gcc-4.8_branch/libgfortran/intrinsics/eoshift0.c |
|
600 =================================================================== |
|
601 --- gcc-4.8_branch/libgfortran/intrinsics/eoshift0.c (revision 213312) |
|
602 +++ gcc-4.8_branch/libgfortran/intrinsics/eoshift0.c (revision 213313) |
|
603 @@ -86,8 +86,8 @@ |
|
604 |
|
605 } |
|
606 |
|
607 - /* xmalloc allocates a single byte for zero size. */ |
|
608 - ret->base_addr = xmalloc (size * arraysize); |
|
609 + /* xmallocarray allocates a single byte for zero size. */ |
|
610 + ret->base_addr = xmallocarray (arraysize, size); |
|
611 } |
|
612 else if (unlikely (compile_options.bounds_check)) |
|
613 { |
|
614 Index: gcc-4.8_branch/libgfortran/intrinsics/eoshift2.c |
|
615 =================================================================== |
|
616 --- gcc-4.8_branch/libgfortran/intrinsics/eoshift2.c (revision 213312) |
|
617 +++ gcc-4.8_branch/libgfortran/intrinsics/eoshift2.c (revision 213313) |
|
618 @@ -78,8 +78,8 @@ |
|
619 ret->offset = 0; |
|
620 ret->dtype = array->dtype; |
|
621 |
|
622 - /* xmalloc allocates a single byte for zero size. */ |
|
623 - ret->base_addr = xmalloc (size * arraysize); |
|
624 + /* xmallocarray allocates a single byte for zero size. */ |
|
625 + ret->base_addr = xmallocarray (arraysize, size); |
|
626 |
|
627 for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++) |
|
628 { |
|
629 Index: gcc-4.8_branch/libgfortran/intrinsics/reshape_generic.c |
|
630 =================================================================== |
|
631 --- gcc-4.8_branch/libgfortran/intrinsics/reshape_generic.c (revision 213312) |
|
632 +++ gcc-4.8_branch/libgfortran/intrinsics/reshape_generic.c (revision 213313) |
|
633 @@ -99,11 +99,11 @@ |
|
634 ret->offset = 0; |
|
635 |
|
636 if (unlikely (rs < 1)) |
|
637 - alloc_size = 1; |
|
638 + alloc_size = 0; /* xmalloc will allocate 1 byte. */ |
|
639 else |
|
640 - alloc_size = rs * size; |
|
641 + alloc_size = rs; |
|
642 |
|
643 - ret->base_addr = xmalloc (alloc_size); |
|
644 + ret->base_addr = xmallocarray (alloc_size, size); |
|
645 |
|
646 ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim; |
|
647 } |
|
648 Index: gcc-4.8_branch/libgfortran/generated/spread_r10.c |
|
649 =================================================================== |
|
650 --- gcc-4.8_branch/libgfortran/generated/spread_r10.c (revision 213312) |
|
651 +++ gcc-4.8_branch/libgfortran/generated/spread_r10.c (revision 213313) |
|
652 @@ -101,8 +101,8 @@ |
|
653 } |
|
654 ret->offset = 0; |
|
655 |
|
656 - /* xmalloc allocates a single byte for zero size. */ |
|
657 - ret->base_addr = xmalloc (rs * sizeof(GFC_REAL_10)); |
|
658 + /* xmallocarray allocates a single byte for zero size. */ |
|
659 + ret->base_addr = xmallocarray (rs, sizeof(GFC_REAL_10)); |
|
660 if (rs <= 0) |
|
661 return; |
|
662 } |
|
663 @@ -244,7 +244,7 @@ |
|
664 |
|
665 if (ret->base_addr == NULL) |
|
666 { |
|
667 - ret->base_addr = xmalloc (ncopies * sizeof (GFC_REAL_10)); |
|
668 + ret->base_addr = xmallocarray (ncopies, sizeof (GFC_REAL_10)); |
|
669 ret->offset = 0; |
|
670 GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1); |
|
671 } |
|
672 Index: gcc-4.8_branch/libgfortran/generated/maxloc1_4_r8.c |
|
673 =================================================================== |
|
674 --- gcc-4.8_branch/libgfortran/generated/maxloc1_4_r8.c (revision 213312) |
|
675 +++ gcc-4.8_branch/libgfortran/generated/maxloc1_4_r8.c (revision 213313) |
|
676 @@ -98,10 +98,9 @@ |
|
677 retarray->offset = 0; |
|
678 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
679 |
|
680 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
681 - * extent[rank-1]; |
|
682 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
683 |
|
684 - retarray->base_addr = xmalloc (alloc_size); |
|
685 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
686 if (alloc_size == 0) |
|
687 { |
|
688 /* Make sure we have a zero-sized array. */ |
|
689 @@ -294,8 +293,7 @@ |
|
690 |
|
691 } |
|
692 |
|
693 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
694 - * extent[rank-1]; |
|
695 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
696 |
|
697 retarray->offset = 0; |
|
698 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
699 @@ -307,7 +305,7 @@ |
|
700 return; |
|
701 } |
|
702 else |
|
703 - retarray->base_addr = xmalloc (alloc_size); |
|
704 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
705 |
|
706 } |
|
707 else |
|
708 @@ -485,8 +483,7 @@ |
|
709 retarray->offset = 0; |
|
710 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
711 |
|
712 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
713 - * extent[rank-1]; |
|
714 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
715 |
|
716 if (alloc_size == 0) |
|
717 { |
|
718 @@ -495,7 +492,7 @@ |
|
719 return; |
|
720 } |
|
721 else |
|
722 - retarray->base_addr = xmalloc (alloc_size); |
|
723 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
724 } |
|
725 else |
|
726 { |
|
727 Index: gcc-4.8_branch/libgfortran/generated/norm2_r4.c |
|
728 =================================================================== |
|
729 --- gcc-4.8_branch/libgfortran/generated/norm2_r4.c (revision 213312) |
|
730 +++ gcc-4.8_branch/libgfortran/generated/norm2_r4.c (revision 213313) |
|
731 @@ -101,10 +101,9 @@ |
|
732 retarray->offset = 0; |
|
733 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
734 |
|
735 - alloc_size = sizeof (GFC_REAL_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
736 - * extent[rank-1]; |
|
737 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
738 |
|
739 - retarray->base_addr = xmalloc (alloc_size); |
|
740 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_4)); |
|
741 if (alloc_size == 0) |
|
742 { |
|
743 /* Make sure we have a zero-sized array. */ |
|
744 Index: gcc-4.8_branch/libgfortran/generated/parity_l2.c |
|
745 =================================================================== |
|
746 --- gcc-4.8_branch/libgfortran/generated/parity_l2.c (revision 213312) |
|
747 +++ gcc-4.8_branch/libgfortran/generated/parity_l2.c (revision 213313) |
|
748 @@ -98,10 +98,9 @@ |
|
749 retarray->offset = 0; |
|
750 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
751 |
|
752 - alloc_size = sizeof (GFC_LOGICAL_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
753 - * extent[rank-1]; |
|
754 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
755 |
|
756 - retarray->base_addr = xmalloc (alloc_size); |
|
757 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_LOGICAL_2)); |
|
758 if (alloc_size == 0) |
|
759 { |
|
760 /* Make sure we have a zero-sized array. */ |
|
761 Index: gcc-4.8_branch/libgfortran/generated/eoshift3_4.c |
|
762 =================================================================== |
|
763 --- gcc-4.8_branch/libgfortran/generated/eoshift3_4.c (revision 213312) |
|
764 +++ gcc-4.8_branch/libgfortran/generated/eoshift3_4.c (revision 213313) |
|
765 @@ -89,7 +89,7 @@ |
|
766 { |
|
767 int i; |
|
768 |
|
769 - ret->base_addr = xmalloc (size * arraysize); |
|
770 + ret->base_addr = xmallocarray (arraysize, size); |
|
771 ret->offset = 0; |
|
772 ret->dtype = array->dtype; |
|
773 for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++) |
|
774 @@ -107,8 +107,8 @@ |
|
775 GFC_DIMENSION_SET(ret->dim[i], 0, ub, str); |
|
776 |
|
777 } |
|
778 - /* xmalloc allocates a single byte for zero size. */ |
|
779 - ret->base_addr = xmalloc (size * arraysize); |
|
780 + /* xmallocarray allocates a single byte for zero size. */ |
|
781 + ret->base_addr = xmallocarray (arraysize, size); |
|
782 |
|
783 } |
|
784 else if (unlikely (compile_options.bounds_check)) |
|
785 Index: gcc-4.8_branch/libgfortran/generated/transpose_c8.c |
|
786 =================================================================== |
|
787 --- gcc-4.8_branch/libgfortran/generated/transpose_c8.c (revision 213312) |
|
788 +++ gcc-4.8_branch/libgfortran/generated/transpose_c8.c (revision 213313) |
|
789 @@ -60,7 +60,8 @@ |
|
790 GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0) - 1, |
|
791 GFC_DESCRIPTOR_EXTENT(source, 1)); |
|
792 |
|
793 - ret->base_addr = xmalloc (sizeof (GFC_COMPLEX_8) * size0 ((array_t *) ret)); |
|
794 + ret->base_addr = xmallocarray (size0 ((array_t *) ret), |
|
795 + sizeof (GFC_COMPLEX_8)); |
|
796 ret->offset = 0; |
|
797 } else if (unlikely (compile_options.bounds_check)) |
|
798 { |
|
799 Index: gcc-4.8_branch/libgfortran/generated/eoshift1_8.c |
|
800 =================================================================== |
|
801 --- gcc-4.8_branch/libgfortran/generated/eoshift1_8.c (revision 213312) |
|
802 +++ gcc-4.8_branch/libgfortran/generated/eoshift1_8.c (revision 213313) |
|
803 @@ -105,8 +105,8 @@ |
|
804 GFC_DIMENSION_SET(ret->dim[i], 0, ub, str); |
|
805 |
|
806 } |
|
807 - /* xmalloc allocates a single byte for zero size. */ |
|
808 - ret->base_addr = xmalloc (size * arraysize); |
|
809 + /* xmallocarray allocates a single byte for zero size. */ |
|
810 + ret->base_addr = xmallocarray (arraysize, size); |
|
811 |
|
812 } |
|
813 else if (unlikely (compile_options.bounds_check)) |
|
814 Index: gcc-4.8_branch/libgfortran/generated/reshape_r16.c |
|
815 =================================================================== |
|
816 --- gcc-4.8_branch/libgfortran/generated/reshape_r16.c (revision 213312) |
|
817 +++ gcc-4.8_branch/libgfortran/generated/reshape_r16.c (revision 213313) |
|
818 @@ -111,11 +111,11 @@ |
|
819 ret->offset = 0; |
|
820 |
|
821 if (unlikely (rs < 1)) |
|
822 - alloc_size = 1; |
|
823 + alloc_size = 0; |
|
824 else |
|
825 - alloc_size = rs * sizeof (GFC_REAL_16); |
|
826 + alloc_size = rs; |
|
827 |
|
828 - ret->base_addr = xmalloc (alloc_size); |
|
829 + ret->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_16)); |
|
830 ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim; |
|
831 } |
|
832 |
|
833 Index: gcc-4.8_branch/libgfortran/generated/bessel_r4.c |
|
834 =================================================================== |
|
835 --- gcc-4.8_branch/libgfortran/generated/bessel_r4.c (revision 213312) |
|
836 +++ gcc-4.8_branch/libgfortran/generated/bessel_r4.c (revision 213313) |
|
837 @@ -55,7 +55,7 @@ |
|
838 { |
|
839 size_t size = n2 < n1 ? 0 : n2-n1+1; |
|
840 GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1); |
|
841 - ret->base_addr = xmalloc (sizeof (GFC_REAL_4) * size); |
|
842 + ret->base_addr = xmallocarray (size, sizeof (GFC_REAL_4)); |
|
843 ret->offset = 0; |
|
844 } |
|
845 |
|
846 @@ -122,7 +122,7 @@ |
|
847 { |
|
848 size_t size = n2 < n1 ? 0 : n2-n1+1; |
|
849 GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1); |
|
850 - ret->base_addr = xmalloc (sizeof (GFC_REAL_4) * size); |
|
851 + ret->base_addr = xmallocarray (size, sizeof (GFC_REAL_4)); |
|
852 ret->offset = 0; |
|
853 } |
|
854 |
|
855 Index: gcc-4.8_branch/libgfortran/generated/any_l2.c |
|
856 =================================================================== |
|
857 --- gcc-4.8_branch/libgfortran/generated/any_l2.c (revision 213312) |
|
858 +++ gcc-4.8_branch/libgfortran/generated/any_l2.c (revision 213313) |
|
859 @@ -101,8 +101,7 @@ |
|
860 retarray->offset = 0; |
|
861 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
862 |
|
863 - alloc_size = sizeof (GFC_LOGICAL_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
864 - * extent[rank-1]; |
|
865 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
866 |
|
867 if (alloc_size == 0) |
|
868 { |
|
869 @@ -111,7 +110,7 @@ |
|
870 return; |
|
871 } |
|
872 else |
|
873 - retarray->base_addr = xmalloc (alloc_size); |
|
874 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_LOGICAL_2)); |
|
875 } |
|
876 else |
|
877 { |
|
878 Index: gcc-4.8_branch/libgfortran/generated/product_r4.c |
|
879 =================================================================== |
|
880 --- gcc-4.8_branch/libgfortran/generated/product_r4.c (revision 213312) |
|
881 +++ gcc-4.8_branch/libgfortran/generated/product_r4.c (revision 213313) |
|
882 @@ -97,10 +97,9 @@ |
|
883 retarray->offset = 0; |
|
884 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
885 |
|
886 - alloc_size = sizeof (GFC_REAL_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
887 - * extent[rank-1]; |
|
888 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
889 |
|
890 - retarray->base_addr = xmalloc (alloc_size); |
|
891 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_4)); |
|
892 if (alloc_size == 0) |
|
893 { |
|
894 /* Make sure we have a zero-sized array. */ |
|
895 @@ -272,8 +271,7 @@ |
|
896 |
|
897 } |
|
898 |
|
899 - alloc_size = sizeof (GFC_REAL_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
900 - * extent[rank-1]; |
|
901 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
902 |
|
903 retarray->offset = 0; |
|
904 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
905 @@ -285,7 +283,7 @@ |
|
906 return; |
|
907 } |
|
908 else |
|
909 - retarray->base_addr = xmalloc (alloc_size); |
|
910 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_4)); |
|
911 |
|
912 } |
|
913 else |
|
914 @@ -430,8 +428,7 @@ |
|
915 retarray->offset = 0; |
|
916 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
917 |
|
918 - alloc_size = sizeof (GFC_REAL_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
919 - * extent[rank-1]; |
|
920 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
921 |
|
922 if (alloc_size == 0) |
|
923 { |
|
924 @@ -440,7 +437,7 @@ |
|
925 return; |
|
926 } |
|
927 else |
|
928 - retarray->base_addr = xmalloc (alloc_size); |
|
929 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_4)); |
|
930 } |
|
931 else |
|
932 { |
|
933 Index: gcc-4.8_branch/libgfortran/generated/iany_i1.c |
|
934 =================================================================== |
|
935 --- gcc-4.8_branch/libgfortran/generated/iany_i1.c (revision 213312) |
|
936 +++ gcc-4.8_branch/libgfortran/generated/iany_i1.c (revision 213313) |
|
937 @@ -97,10 +97,9 @@ |
|
938 retarray->offset = 0; |
|
939 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
940 |
|
941 - alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
942 - * extent[rank-1]; |
|
943 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
944 |
|
945 - retarray->base_addr = xmalloc (alloc_size); |
|
946 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); |
|
947 if (alloc_size == 0) |
|
948 { |
|
949 /* Make sure we have a zero-sized array. */ |
|
950 @@ -272,8 +271,7 @@ |
|
951 |
|
952 } |
|
953 |
|
954 - alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
955 - * extent[rank-1]; |
|
956 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
957 |
|
958 retarray->offset = 0; |
|
959 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
960 @@ -285,7 +283,7 @@ |
|
961 return; |
|
962 } |
|
963 else |
|
964 - retarray->base_addr = xmalloc (alloc_size); |
|
965 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); |
|
966 |
|
967 } |
|
968 else |
|
969 @@ -430,8 +428,7 @@ |
|
970 retarray->offset = 0; |
|
971 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
972 |
|
973 - alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
974 - * extent[rank-1]; |
|
975 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
976 |
|
977 if (alloc_size == 0) |
|
978 { |
|
979 @@ -440,7 +437,7 @@ |
|
980 return; |
|
981 } |
|
982 else |
|
983 - retarray->base_addr = xmalloc (alloc_size); |
|
984 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); |
|
985 } |
|
986 else |
|
987 { |
|
988 Index: gcc-4.8_branch/libgfortran/generated/parity_l16.c |
|
989 =================================================================== |
|
990 --- gcc-4.8_branch/libgfortran/generated/parity_l16.c (revision 213312) |
|
991 +++ gcc-4.8_branch/libgfortran/generated/parity_l16.c (revision 213313) |
|
992 @@ -98,10 +98,9 @@ |
|
993 retarray->offset = 0; |
|
994 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
995 |
|
996 - alloc_size = sizeof (GFC_LOGICAL_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
997 - * extent[rank-1]; |
|
998 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
999 |
|
1000 - retarray->base_addr = xmalloc (alloc_size); |
|
1001 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_LOGICAL_16)); |
|
1002 if (alloc_size == 0) |
|
1003 { |
|
1004 /* Make sure we have a zero-sized array. */ |
|
1005 Index: gcc-4.8_branch/libgfortran/generated/in_pack_r4.c |
|
1006 =================================================================== |
|
1007 --- gcc-4.8_branch/libgfortran/generated/in_pack_r4.c (revision 213312) |
|
1008 +++ gcc-4.8_branch/libgfortran/generated/in_pack_r4.c (revision 213313) |
|
1009 @@ -76,7 +76,7 @@ |
|
1010 return source->base_addr; |
|
1011 |
|
1012 /* Allocate storage for the destination. */ |
|
1013 - destptr = (GFC_REAL_4 *)xmalloc (ssize * sizeof (GFC_REAL_4)); |
|
1014 + destptr = xmallocarray (ssize, sizeof (GFC_REAL_4)); |
|
1015 dest = destptr; |
|
1016 src = source->base_addr; |
|
1017 stride0 = stride[0]; |
|
1018 Index: gcc-4.8_branch/libgfortran/generated/product_i2.c |
|
1019 =================================================================== |
|
1020 --- gcc-4.8_branch/libgfortran/generated/product_i2.c (revision 213312) |
|
1021 +++ gcc-4.8_branch/libgfortran/generated/product_i2.c (revision 213313) |
|
1022 @@ -97,10 +97,9 @@ |
|
1023 retarray->offset = 0; |
|
1024 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1025 |
|
1026 - alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1027 - * extent[rank-1]; |
|
1028 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1029 |
|
1030 - retarray->base_addr = xmalloc (alloc_size); |
|
1031 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); |
|
1032 if (alloc_size == 0) |
|
1033 { |
|
1034 /* Make sure we have a zero-sized array. */ |
|
1035 @@ -272,8 +271,7 @@ |
|
1036 |
|
1037 } |
|
1038 |
|
1039 - alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1040 - * extent[rank-1]; |
|
1041 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1042 |
|
1043 retarray->offset = 0; |
|
1044 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1045 @@ -285,7 +283,7 @@ |
|
1046 return; |
|
1047 } |
|
1048 else |
|
1049 - retarray->base_addr = xmalloc (alloc_size); |
|
1050 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); |
|
1051 |
|
1052 } |
|
1053 else |
|
1054 @@ -430,8 +428,7 @@ |
|
1055 retarray->offset = 0; |
|
1056 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1057 |
|
1058 - alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1059 - * extent[rank-1]; |
|
1060 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1061 |
|
1062 if (alloc_size == 0) |
|
1063 { |
|
1064 @@ -440,7 +437,7 @@ |
|
1065 return; |
|
1066 } |
|
1067 else |
|
1068 - retarray->base_addr = xmalloc (alloc_size); |
|
1069 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); |
|
1070 } |
|
1071 else |
|
1072 { |
|
1073 Index: gcc-4.8_branch/libgfortran/generated/iparity_i4.c |
|
1074 =================================================================== |
|
1075 --- gcc-4.8_branch/libgfortran/generated/iparity_i4.c (revision 213312) |
|
1076 +++ gcc-4.8_branch/libgfortran/generated/iparity_i4.c (revision 213313) |
|
1077 @@ -97,10 +97,9 @@ |
|
1078 retarray->offset = 0; |
|
1079 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1080 |
|
1081 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1082 - * extent[rank-1]; |
|
1083 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1084 |
|
1085 - retarray->base_addr = xmalloc (alloc_size); |
|
1086 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
1087 if (alloc_size == 0) |
|
1088 { |
|
1089 /* Make sure we have a zero-sized array. */ |
|
1090 @@ -272,8 +271,7 @@ |
|
1091 |
|
1092 } |
|
1093 |
|
1094 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1095 - * extent[rank-1]; |
|
1096 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1097 |
|
1098 retarray->offset = 0; |
|
1099 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1100 @@ -285,7 +283,7 @@ |
|
1101 return; |
|
1102 } |
|
1103 else |
|
1104 - retarray->base_addr = xmalloc (alloc_size); |
|
1105 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
1106 |
|
1107 } |
|
1108 else |
|
1109 @@ -430,8 +428,7 @@ |
|
1110 retarray->offset = 0; |
|
1111 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1112 |
|
1113 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1114 - * extent[rank-1]; |
|
1115 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1116 |
|
1117 if (alloc_size == 0) |
|
1118 { |
|
1119 @@ -440,7 +437,7 @@ |
|
1120 return; |
|
1121 } |
|
1122 else |
|
1123 - retarray->base_addr = xmalloc (alloc_size); |
|
1124 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
1125 } |
|
1126 else |
|
1127 { |
|
1128 Index: gcc-4.8_branch/libgfortran/generated/minloc0_4_i1.c |
|
1129 =================================================================== |
|
1130 --- gcc-4.8_branch/libgfortran/generated/minloc0_4_i1.c (revision 213312) |
|
1131 +++ gcc-4.8_branch/libgfortran/generated/minloc0_4_i1.c (revision 213313) |
|
1132 @@ -58,7 +58,7 @@ |
|
1133 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
1134 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
1135 retarray->offset = 0; |
|
1136 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
1137 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
1138 } |
|
1139 else |
|
1140 { |
|
1141 @@ -199,7 +199,7 @@ |
|
1142 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
1143 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
1144 retarray->offset = 0; |
|
1145 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
1146 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
1147 } |
|
1148 else |
|
1149 { |
|
1150 @@ -367,7 +367,7 @@ |
|
1151 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
1152 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
1153 retarray->offset = 0; |
|
1154 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
1155 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
1156 } |
|
1157 else if (unlikely (compile_options.bounds_check)) |
|
1158 { |
|
1159 Index: gcc-4.8_branch/libgfortran/generated/reshape_c4.c |
|
1160 =================================================================== |
|
1161 --- gcc-4.8_branch/libgfortran/generated/reshape_c4.c (revision 213312) |
|
1162 +++ gcc-4.8_branch/libgfortran/generated/reshape_c4.c (revision 213313) |
|
1163 @@ -111,11 +111,11 @@ |
|
1164 ret->offset = 0; |
|
1165 |
|
1166 if (unlikely (rs < 1)) |
|
1167 - alloc_size = 1; |
|
1168 + alloc_size = 0; |
|
1169 else |
|
1170 - alloc_size = rs * sizeof (GFC_COMPLEX_4); |
|
1171 + alloc_size = rs; |
|
1172 |
|
1173 - ret->base_addr = xmalloc (alloc_size); |
|
1174 + ret->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_4)); |
|
1175 ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim; |
|
1176 } |
|
1177 |
|
1178 Index: gcc-4.8_branch/libgfortran/generated/maxloc0_4_r16.c |
|
1179 =================================================================== |
|
1180 --- gcc-4.8_branch/libgfortran/generated/maxloc0_4_r16.c (revision 213312) |
|
1181 +++ gcc-4.8_branch/libgfortran/generated/maxloc0_4_r16.c (revision 213313) |
|
1182 @@ -58,7 +58,7 @@ |
|
1183 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
1184 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
1185 retarray->offset = 0; |
|
1186 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
1187 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
1188 } |
|
1189 else |
|
1190 { |
|
1191 @@ -199,7 +199,7 @@ |
|
1192 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
1193 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
1194 retarray->offset = 0; |
|
1195 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
1196 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
1197 } |
|
1198 else |
|
1199 { |
|
1200 @@ -367,7 +367,7 @@ |
|
1201 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
1202 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
1203 retarray->offset = 0; |
|
1204 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
1205 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
1206 } |
|
1207 else if (unlikely (compile_options.bounds_check)) |
|
1208 { |
|
1209 Index: gcc-4.8_branch/libgfortran/generated/iall_i8.c |
|
1210 =================================================================== |
|
1211 --- gcc-4.8_branch/libgfortran/generated/iall_i8.c (revision 213312) |
|
1212 +++ gcc-4.8_branch/libgfortran/generated/iall_i8.c (revision 213313) |
|
1213 @@ -97,10 +97,9 @@ |
|
1214 retarray->offset = 0; |
|
1215 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1216 |
|
1217 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1218 - * extent[rank-1]; |
|
1219 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1220 |
|
1221 - retarray->base_addr = xmalloc (alloc_size); |
|
1222 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
1223 if (alloc_size == 0) |
|
1224 { |
|
1225 /* Make sure we have a zero-sized array. */ |
|
1226 @@ -272,8 +271,7 @@ |
|
1227 |
|
1228 } |
|
1229 |
|
1230 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1231 - * extent[rank-1]; |
|
1232 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1233 |
|
1234 retarray->offset = 0; |
|
1235 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1236 @@ -285,7 +283,7 @@ |
|
1237 return; |
|
1238 } |
|
1239 else |
|
1240 - retarray->base_addr = xmalloc (alloc_size); |
|
1241 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
1242 |
|
1243 } |
|
1244 else |
|
1245 @@ -430,8 +428,7 @@ |
|
1246 retarray->offset = 0; |
|
1247 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1248 |
|
1249 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1250 - * extent[rank-1]; |
|
1251 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1252 |
|
1253 if (alloc_size == 0) |
|
1254 { |
|
1255 @@ -440,7 +437,7 @@ |
|
1256 return; |
|
1257 } |
|
1258 else |
|
1259 - retarray->base_addr = xmalloc (alloc_size); |
|
1260 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
1261 } |
|
1262 else |
|
1263 { |
|
1264 Index: gcc-4.8_branch/libgfortran/generated/maxloc1_8_r16.c |
|
1265 =================================================================== |
|
1266 --- gcc-4.8_branch/libgfortran/generated/maxloc1_8_r16.c (revision 213312) |
|
1267 +++ gcc-4.8_branch/libgfortran/generated/maxloc1_8_r16.c (revision 213313) |
|
1268 @@ -98,10 +98,9 @@ |
|
1269 retarray->offset = 0; |
|
1270 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1271 |
|
1272 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1273 - * extent[rank-1]; |
|
1274 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1275 |
|
1276 - retarray->base_addr = xmalloc (alloc_size); |
|
1277 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
1278 if (alloc_size == 0) |
|
1279 { |
|
1280 /* Make sure we have a zero-sized array. */ |
|
1281 @@ -294,8 +293,7 @@ |
|
1282 |
|
1283 } |
|
1284 |
|
1285 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1286 - * extent[rank-1]; |
|
1287 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1288 |
|
1289 retarray->offset = 0; |
|
1290 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1291 @@ -307,7 +305,7 @@ |
|
1292 return; |
|
1293 } |
|
1294 else |
|
1295 - retarray->base_addr = xmalloc (alloc_size); |
|
1296 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
1297 |
|
1298 } |
|
1299 else |
|
1300 @@ -485,8 +483,7 @@ |
|
1301 retarray->offset = 0; |
|
1302 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1303 |
|
1304 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1305 - * extent[rank-1]; |
|
1306 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1307 |
|
1308 if (alloc_size == 0) |
|
1309 { |
|
1310 @@ -495,7 +492,7 @@ |
|
1311 return; |
|
1312 } |
|
1313 else |
|
1314 - retarray->base_addr = xmalloc (alloc_size); |
|
1315 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
1316 } |
|
1317 else |
|
1318 { |
|
1319 Index: gcc-4.8_branch/libgfortran/generated/sum_r16.c |
|
1320 =================================================================== |
|
1321 --- gcc-4.8_branch/libgfortran/generated/sum_r16.c (revision 213312) |
|
1322 +++ gcc-4.8_branch/libgfortran/generated/sum_r16.c (revision 213313) |
|
1323 @@ -97,10 +97,9 @@ |
|
1324 retarray->offset = 0; |
|
1325 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1326 |
|
1327 - alloc_size = sizeof (GFC_REAL_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1328 - * extent[rank-1]; |
|
1329 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1330 |
|
1331 - retarray->base_addr = xmalloc (alloc_size); |
|
1332 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_16)); |
|
1333 if (alloc_size == 0) |
|
1334 { |
|
1335 /* Make sure we have a zero-sized array. */ |
|
1336 @@ -272,8 +271,7 @@ |
|
1337 |
|
1338 } |
|
1339 |
|
1340 - alloc_size = sizeof (GFC_REAL_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1341 - * extent[rank-1]; |
|
1342 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1343 |
|
1344 retarray->offset = 0; |
|
1345 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1346 @@ -285,7 +283,7 @@ |
|
1347 return; |
|
1348 } |
|
1349 else |
|
1350 - retarray->base_addr = xmalloc (alloc_size); |
|
1351 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_16)); |
|
1352 |
|
1353 } |
|
1354 else |
|
1355 @@ -430,8 +428,7 @@ |
|
1356 retarray->offset = 0; |
|
1357 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1358 |
|
1359 - alloc_size = sizeof (GFC_REAL_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1360 - * extent[rank-1]; |
|
1361 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1362 |
|
1363 if (alloc_size == 0) |
|
1364 { |
|
1365 @@ -440,7 +437,7 @@ |
|
1366 return; |
|
1367 } |
|
1368 else |
|
1369 - retarray->base_addr = xmalloc (alloc_size); |
|
1370 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_16)); |
|
1371 } |
|
1372 else |
|
1373 { |
|
1374 Index: gcc-4.8_branch/libgfortran/generated/sum_i1.c |
|
1375 =================================================================== |
|
1376 --- gcc-4.8_branch/libgfortran/generated/sum_i1.c (revision 213312) |
|
1377 +++ gcc-4.8_branch/libgfortran/generated/sum_i1.c (revision 213313) |
|
1378 @@ -97,10 +97,9 @@ |
|
1379 retarray->offset = 0; |
|
1380 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1381 |
|
1382 - alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1383 - * extent[rank-1]; |
|
1384 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1385 |
|
1386 - retarray->base_addr = xmalloc (alloc_size); |
|
1387 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); |
|
1388 if (alloc_size == 0) |
|
1389 { |
|
1390 /* Make sure we have a zero-sized array. */ |
|
1391 @@ -272,8 +271,7 @@ |
|
1392 |
|
1393 } |
|
1394 |
|
1395 - alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1396 - * extent[rank-1]; |
|
1397 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1398 |
|
1399 retarray->offset = 0; |
|
1400 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1401 @@ -285,7 +283,7 @@ |
|
1402 return; |
|
1403 } |
|
1404 else |
|
1405 - retarray->base_addr = xmalloc (alloc_size); |
|
1406 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); |
|
1407 |
|
1408 } |
|
1409 else |
|
1410 @@ -430,8 +428,7 @@ |
|
1411 retarray->offset = 0; |
|
1412 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1413 |
|
1414 - alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1415 - * extent[rank-1]; |
|
1416 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1417 |
|
1418 if (alloc_size == 0) |
|
1419 { |
|
1420 @@ -440,7 +437,7 @@ |
|
1421 return; |
|
1422 } |
|
1423 else |
|
1424 - retarray->base_addr = xmalloc (alloc_size); |
|
1425 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); |
|
1426 } |
|
1427 else |
|
1428 { |
|
1429 Index: gcc-4.8_branch/libgfortran/generated/in_pack_i2.c |
|
1430 =================================================================== |
|
1431 --- gcc-4.8_branch/libgfortran/generated/in_pack_i2.c (revision 213312) |
|
1432 +++ gcc-4.8_branch/libgfortran/generated/in_pack_i2.c (revision 213313) |
|
1433 @@ -76,7 +76,7 @@ |
|
1434 return source->base_addr; |
|
1435 |
|
1436 /* Allocate storage for the destination. */ |
|
1437 - destptr = (GFC_INTEGER_2 *)xmalloc (ssize * sizeof (GFC_INTEGER_2)); |
|
1438 + destptr = xmallocarray (ssize, sizeof (GFC_INTEGER_2)); |
|
1439 dest = destptr; |
|
1440 src = source->base_addr; |
|
1441 stride0 = stride[0]; |
|
1442 Index: gcc-4.8_branch/libgfortran/generated/transpose_r10.c |
|
1443 =================================================================== |
|
1444 --- gcc-4.8_branch/libgfortran/generated/transpose_r10.c (revision 213312) |
|
1445 +++ gcc-4.8_branch/libgfortran/generated/transpose_r10.c (revision 213313) |
|
1446 @@ -60,7 +60,8 @@ |
|
1447 GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0) - 1, |
|
1448 GFC_DESCRIPTOR_EXTENT(source, 1)); |
|
1449 |
|
1450 - ret->base_addr = xmalloc (sizeof (GFC_REAL_10) * size0 ((array_t *) ret)); |
|
1451 + ret->base_addr = xmallocarray (size0 ((array_t *) ret), |
|
1452 + sizeof (GFC_REAL_10)); |
|
1453 ret->offset = 0; |
|
1454 } else if (unlikely (compile_options.bounds_check)) |
|
1455 { |
|
1456 Index: gcc-4.8_branch/libgfortran/generated/maxloc1_16_r16.c |
|
1457 =================================================================== |
|
1458 --- gcc-4.8_branch/libgfortran/generated/maxloc1_16_r16.c (revision 213312) |
|
1459 +++ gcc-4.8_branch/libgfortran/generated/maxloc1_16_r16.c (revision 213313) |
|
1460 @@ -98,10 +98,9 @@ |
|
1461 retarray->offset = 0; |
|
1462 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1463 |
|
1464 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1465 - * extent[rank-1]; |
|
1466 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1467 |
|
1468 - retarray->base_addr = xmalloc (alloc_size); |
|
1469 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
1470 if (alloc_size == 0) |
|
1471 { |
|
1472 /* Make sure we have a zero-sized array. */ |
|
1473 @@ -294,8 +293,7 @@ |
|
1474 |
|
1475 } |
|
1476 |
|
1477 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1478 - * extent[rank-1]; |
|
1479 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1480 |
|
1481 retarray->offset = 0; |
|
1482 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1483 @@ -307,7 +305,7 @@ |
|
1484 return; |
|
1485 } |
|
1486 else |
|
1487 - retarray->base_addr = xmalloc (alloc_size); |
|
1488 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
1489 |
|
1490 } |
|
1491 else |
|
1492 @@ -485,8 +483,7 @@ |
|
1493 retarray->offset = 0; |
|
1494 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1495 |
|
1496 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1497 - * extent[rank-1]; |
|
1498 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1499 |
|
1500 if (alloc_size == 0) |
|
1501 { |
|
1502 @@ -495,7 +492,7 @@ |
|
1503 return; |
|
1504 } |
|
1505 else |
|
1506 - retarray->base_addr = xmalloc (alloc_size); |
|
1507 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
1508 } |
|
1509 else |
|
1510 { |
|
1511 Index: gcc-4.8_branch/libgfortran/generated/maxloc1_16_i4.c |
|
1512 =================================================================== |
|
1513 --- gcc-4.8_branch/libgfortran/generated/maxloc1_16_i4.c (revision 213312) |
|
1514 +++ gcc-4.8_branch/libgfortran/generated/maxloc1_16_i4.c (revision 213313) |
|
1515 @@ -98,10 +98,9 @@ |
|
1516 retarray->offset = 0; |
|
1517 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1518 |
|
1519 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1520 - * extent[rank-1]; |
|
1521 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1522 |
|
1523 - retarray->base_addr = xmalloc (alloc_size); |
|
1524 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
1525 if (alloc_size == 0) |
|
1526 { |
|
1527 /* Make sure we have a zero-sized array. */ |
|
1528 @@ -294,8 +293,7 @@ |
|
1529 |
|
1530 } |
|
1531 |
|
1532 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1533 - * extent[rank-1]; |
|
1534 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1535 |
|
1536 retarray->offset = 0; |
|
1537 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1538 @@ -307,7 +305,7 @@ |
|
1539 return; |
|
1540 } |
|
1541 else |
|
1542 - retarray->base_addr = xmalloc (alloc_size); |
|
1543 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
1544 |
|
1545 } |
|
1546 else |
|
1547 @@ -485,8 +483,7 @@ |
|
1548 retarray->offset = 0; |
|
1549 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1550 |
|
1551 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1552 - * extent[rank-1]; |
|
1553 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1554 |
|
1555 if (alloc_size == 0) |
|
1556 { |
|
1557 @@ -495,7 +492,7 @@ |
|
1558 return; |
|
1559 } |
|
1560 else |
|
1561 - retarray->base_addr = xmalloc (alloc_size); |
|
1562 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
1563 } |
|
1564 else |
|
1565 { |
|
1566 Index: gcc-4.8_branch/libgfortran/generated/spread_i1.c |
|
1567 =================================================================== |
|
1568 --- gcc-4.8_branch/libgfortran/generated/spread_i1.c (revision 213312) |
|
1569 +++ gcc-4.8_branch/libgfortran/generated/spread_i1.c (revision 213313) |
|
1570 @@ -101,8 +101,8 @@ |
|
1571 } |
|
1572 ret->offset = 0; |
|
1573 |
|
1574 - /* xmalloc allocates a single byte for zero size. */ |
|
1575 - ret->base_addr = xmalloc (rs * sizeof(GFC_INTEGER_1)); |
|
1576 + /* xmallocarray allocates a single byte for zero size. */ |
|
1577 + ret->base_addr = xmallocarray (rs, sizeof(GFC_INTEGER_1)); |
|
1578 if (rs <= 0) |
|
1579 return; |
|
1580 } |
|
1581 @@ -244,7 +244,7 @@ |
|
1582 |
|
1583 if (ret->base_addr == NULL) |
|
1584 { |
|
1585 - ret->base_addr = xmalloc (ncopies * sizeof (GFC_INTEGER_1)); |
|
1586 + ret->base_addr = xmallocarray (ncopies, sizeof (GFC_INTEGER_1)); |
|
1587 ret->offset = 0; |
|
1588 GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1); |
|
1589 } |
|
1590 Index: gcc-4.8_branch/libgfortran/generated/maxloc0_16_i8.c |
|
1591 =================================================================== |
|
1592 --- gcc-4.8_branch/libgfortran/generated/maxloc0_16_i8.c (revision 213312) |
|
1593 +++ gcc-4.8_branch/libgfortran/generated/maxloc0_16_i8.c (revision 213313) |
|
1594 @@ -58,7 +58,7 @@ |
|
1595 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
1596 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
1597 retarray->offset = 0; |
|
1598 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
1599 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
1600 } |
|
1601 else |
|
1602 { |
|
1603 @@ -199,7 +199,7 @@ |
|
1604 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
1605 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
1606 retarray->offset = 0; |
|
1607 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
1608 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
1609 } |
|
1610 else |
|
1611 { |
|
1612 @@ -367,7 +367,7 @@ |
|
1613 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
1614 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
1615 retarray->offset = 0; |
|
1616 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
1617 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
1618 } |
|
1619 else if (unlikely (compile_options.bounds_check)) |
|
1620 { |
|
1621 Index: gcc-4.8_branch/libgfortran/generated/maxval_r16.c |
|
1622 =================================================================== |
|
1623 --- gcc-4.8_branch/libgfortran/generated/maxval_r16.c (revision 213312) |
|
1624 +++ gcc-4.8_branch/libgfortran/generated/maxval_r16.c (revision 213313) |
|
1625 @@ -97,10 +97,9 @@ |
|
1626 retarray->offset = 0; |
|
1627 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1628 |
|
1629 - alloc_size = sizeof (GFC_REAL_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1630 - * extent[rank-1]; |
|
1631 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1632 |
|
1633 - retarray->base_addr = xmalloc (alloc_size); |
|
1634 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_16)); |
|
1635 if (alloc_size == 0) |
|
1636 { |
|
1637 /* Make sure we have a zero-sized array. */ |
|
1638 @@ -286,8 +285,7 @@ |
|
1639 |
|
1640 } |
|
1641 |
|
1642 - alloc_size = sizeof (GFC_REAL_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1643 - * extent[rank-1]; |
|
1644 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1645 |
|
1646 retarray->offset = 0; |
|
1647 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1648 @@ -299,7 +297,7 @@ |
|
1649 return; |
|
1650 } |
|
1651 else |
|
1652 - retarray->base_addr = xmalloc (alloc_size); |
|
1653 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_16)); |
|
1654 |
|
1655 } |
|
1656 else |
|
1657 @@ -472,8 +470,7 @@ |
|
1658 retarray->offset = 0; |
|
1659 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1660 |
|
1661 - alloc_size = sizeof (GFC_REAL_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1662 - * extent[rank-1]; |
|
1663 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1664 |
|
1665 if (alloc_size == 0) |
|
1666 { |
|
1667 @@ -482,7 +479,7 @@ |
|
1668 return; |
|
1669 } |
|
1670 else |
|
1671 - retarray->base_addr = xmalloc (alloc_size); |
|
1672 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_16)); |
|
1673 } |
|
1674 else |
|
1675 { |
|
1676 Index: gcc-4.8_branch/libgfortran/generated/product_c10.c |
|
1677 =================================================================== |
|
1678 --- gcc-4.8_branch/libgfortran/generated/product_c10.c (revision 213312) |
|
1679 +++ gcc-4.8_branch/libgfortran/generated/product_c10.c (revision 213313) |
|
1680 @@ -97,10 +97,9 @@ |
|
1681 retarray->offset = 0; |
|
1682 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1683 |
|
1684 - alloc_size = sizeof (GFC_COMPLEX_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1685 - * extent[rank-1]; |
|
1686 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1687 |
|
1688 - retarray->base_addr = xmalloc (alloc_size); |
|
1689 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_10)); |
|
1690 if (alloc_size == 0) |
|
1691 { |
|
1692 /* Make sure we have a zero-sized array. */ |
|
1693 @@ -272,8 +271,7 @@ |
|
1694 |
|
1695 } |
|
1696 |
|
1697 - alloc_size = sizeof (GFC_COMPLEX_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1698 - * extent[rank-1]; |
|
1699 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1700 |
|
1701 retarray->offset = 0; |
|
1702 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1703 @@ -285,7 +283,7 @@ |
|
1704 return; |
|
1705 } |
|
1706 else |
|
1707 - retarray->base_addr = xmalloc (alloc_size); |
|
1708 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_10)); |
|
1709 |
|
1710 } |
|
1711 else |
|
1712 @@ -430,8 +428,7 @@ |
|
1713 retarray->offset = 0; |
|
1714 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1715 |
|
1716 - alloc_size = sizeof (GFC_COMPLEX_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1717 - * extent[rank-1]; |
|
1718 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1719 |
|
1720 if (alloc_size == 0) |
|
1721 { |
|
1722 @@ -440,7 +437,7 @@ |
|
1723 return; |
|
1724 } |
|
1725 else |
|
1726 - retarray->base_addr = xmalloc (alloc_size); |
|
1727 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_10)); |
|
1728 } |
|
1729 else |
|
1730 { |
|
1731 Index: gcc-4.8_branch/libgfortran/generated/minloc1_8_i4.c |
|
1732 =================================================================== |
|
1733 --- gcc-4.8_branch/libgfortran/generated/minloc1_8_i4.c (revision 213312) |
|
1734 +++ gcc-4.8_branch/libgfortran/generated/minloc1_8_i4.c (revision 213313) |
|
1735 @@ -98,10 +98,9 @@ |
|
1736 retarray->offset = 0; |
|
1737 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1738 |
|
1739 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1740 - * extent[rank-1]; |
|
1741 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1742 |
|
1743 - retarray->base_addr = xmalloc (alloc_size); |
|
1744 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
1745 if (alloc_size == 0) |
|
1746 { |
|
1747 /* Make sure we have a zero-sized array. */ |
|
1748 @@ -294,8 +293,7 @@ |
|
1749 |
|
1750 } |
|
1751 |
|
1752 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1753 - * extent[rank-1]; |
|
1754 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1755 |
|
1756 retarray->offset = 0; |
|
1757 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1758 @@ -307,7 +305,7 @@ |
|
1759 return; |
|
1760 } |
|
1761 else |
|
1762 - retarray->base_addr = xmalloc (alloc_size); |
|
1763 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
1764 |
|
1765 } |
|
1766 else |
|
1767 @@ -485,8 +483,7 @@ |
|
1768 retarray->offset = 0; |
|
1769 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1770 |
|
1771 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1772 - * extent[rank-1]; |
|
1773 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1774 |
|
1775 if (alloc_size == 0) |
|
1776 { |
|
1777 @@ -495,7 +492,7 @@ |
|
1778 return; |
|
1779 } |
|
1780 else |
|
1781 - retarray->base_addr = xmalloc (alloc_size); |
|
1782 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
1783 } |
|
1784 else |
|
1785 { |
|
1786 Index: gcc-4.8_branch/libgfortran/generated/minloc0_16_i16.c |
|
1787 =================================================================== |
|
1788 --- gcc-4.8_branch/libgfortran/generated/minloc0_16_i16.c (revision 213312) |
|
1789 +++ gcc-4.8_branch/libgfortran/generated/minloc0_16_i16.c (revision 213313) |
|
1790 @@ -58,7 +58,7 @@ |
|
1791 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
1792 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
1793 retarray->offset = 0; |
|
1794 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
1795 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
1796 } |
|
1797 else |
|
1798 { |
|
1799 @@ -199,7 +199,7 @@ |
|
1800 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
1801 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
1802 retarray->offset = 0; |
|
1803 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
1804 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
1805 } |
|
1806 else |
|
1807 { |
|
1808 @@ -367,7 +367,7 @@ |
|
1809 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
1810 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
1811 retarray->offset = 0; |
|
1812 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
1813 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
1814 } |
|
1815 else if (unlikely (compile_options.bounds_check)) |
|
1816 { |
|
1817 Index: gcc-4.8_branch/libgfortran/generated/matmul_r16.c |
|
1818 =================================================================== |
|
1819 --- gcc-4.8_branch/libgfortran/generated/matmul_r16.c (revision 213312) |
|
1820 +++ gcc-4.8_branch/libgfortran/generated/matmul_r16.c (revision 213313) |
|
1821 @@ -124,7 +124,7 @@ |
|
1822 } |
|
1823 |
|
1824 retarray->base_addr |
|
1825 - = xmalloc (sizeof (GFC_REAL_16) * size0 ((array_t *) retarray)); |
|
1826 + = xmallocarray (size0 ((array_t *) retarray), sizeof (GFC_REAL_16)); |
|
1827 retarray->offset = 0; |
|
1828 } |
|
1829 else if (unlikely (compile_options.bounds_check)) |
|
1830 Index: gcc-4.8_branch/libgfortran/generated/minloc0_4_r4.c |
|
1831 =================================================================== |
|
1832 --- gcc-4.8_branch/libgfortran/generated/minloc0_4_r4.c (revision 213312) |
|
1833 +++ gcc-4.8_branch/libgfortran/generated/minloc0_4_r4.c (revision 213313) |
|
1834 @@ -58,7 +58,7 @@ |
|
1835 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
1836 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
1837 retarray->offset = 0; |
|
1838 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
1839 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
1840 } |
|
1841 else |
|
1842 { |
|
1843 @@ -199,7 +199,7 @@ |
|
1844 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
1845 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
1846 retarray->offset = 0; |
|
1847 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
1848 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
1849 } |
|
1850 else |
|
1851 { |
|
1852 @@ -367,7 +367,7 @@ |
|
1853 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
1854 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
1855 retarray->offset = 0; |
|
1856 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
1857 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
1858 } |
|
1859 else if (unlikely (compile_options.bounds_check)) |
|
1860 { |
|
1861 Index: gcc-4.8_branch/libgfortran/generated/iany_i2.c |
|
1862 =================================================================== |
|
1863 --- gcc-4.8_branch/libgfortran/generated/iany_i2.c (revision 213312) |
|
1864 +++ gcc-4.8_branch/libgfortran/generated/iany_i2.c (revision 213313) |
|
1865 @@ -97,10 +97,9 @@ |
|
1866 retarray->offset = 0; |
|
1867 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1868 |
|
1869 - alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1870 - * extent[rank-1]; |
|
1871 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1872 |
|
1873 - retarray->base_addr = xmalloc (alloc_size); |
|
1874 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); |
|
1875 if (alloc_size == 0) |
|
1876 { |
|
1877 /* Make sure we have a zero-sized array. */ |
|
1878 @@ -272,8 +271,7 @@ |
|
1879 |
|
1880 } |
|
1881 |
|
1882 - alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1883 - * extent[rank-1]; |
|
1884 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1885 |
|
1886 retarray->offset = 0; |
|
1887 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1888 @@ -285,7 +283,7 @@ |
|
1889 return; |
|
1890 } |
|
1891 else |
|
1892 - retarray->base_addr = xmalloc (alloc_size); |
|
1893 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); |
|
1894 |
|
1895 } |
|
1896 else |
|
1897 @@ -430,8 +428,7 @@ |
|
1898 retarray->offset = 0; |
|
1899 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1900 |
|
1901 - alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1902 - * extent[rank-1]; |
|
1903 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1904 |
|
1905 if (alloc_size == 0) |
|
1906 { |
|
1907 @@ -440,7 +437,7 @@ |
|
1908 return; |
|
1909 } |
|
1910 else |
|
1911 - retarray->base_addr = xmalloc (alloc_size); |
|
1912 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); |
|
1913 } |
|
1914 else |
|
1915 { |
|
1916 Index: gcc-4.8_branch/libgfortran/generated/sum_r4.c |
|
1917 =================================================================== |
|
1918 --- gcc-4.8_branch/libgfortran/generated/sum_r4.c (revision 213312) |
|
1919 +++ gcc-4.8_branch/libgfortran/generated/sum_r4.c (revision 213313) |
|
1920 @@ -97,10 +97,9 @@ |
|
1921 retarray->offset = 0; |
|
1922 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1923 |
|
1924 - alloc_size = sizeof (GFC_REAL_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1925 - * extent[rank-1]; |
|
1926 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1927 |
|
1928 - retarray->base_addr = xmalloc (alloc_size); |
|
1929 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_4)); |
|
1930 if (alloc_size == 0) |
|
1931 { |
|
1932 /* Make sure we have a zero-sized array. */ |
|
1933 @@ -272,8 +271,7 @@ |
|
1934 |
|
1935 } |
|
1936 |
|
1937 - alloc_size = sizeof (GFC_REAL_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1938 - * extent[rank-1]; |
|
1939 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1940 |
|
1941 retarray->offset = 0; |
|
1942 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1943 @@ -285,7 +283,7 @@ |
|
1944 return; |
|
1945 } |
|
1946 else |
|
1947 - retarray->base_addr = xmalloc (alloc_size); |
|
1948 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_4)); |
|
1949 |
|
1950 } |
|
1951 else |
|
1952 @@ -430,8 +428,7 @@ |
|
1953 retarray->offset = 0; |
|
1954 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
1955 |
|
1956 - alloc_size = sizeof (GFC_REAL_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
1957 - * extent[rank-1]; |
|
1958 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
1959 |
|
1960 if (alloc_size == 0) |
|
1961 { |
|
1962 @@ -440,7 +437,7 @@ |
|
1963 return; |
|
1964 } |
|
1965 else |
|
1966 - retarray->base_addr = xmalloc (alloc_size); |
|
1967 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_4)); |
|
1968 } |
|
1969 else |
|
1970 { |
|
1971 Index: gcc-4.8_branch/libgfortran/generated/unpack_c8.c |
|
1972 =================================================================== |
|
1973 --- gcc-4.8_branch/libgfortran/generated/unpack_c8.c (revision 213312) |
|
1974 +++ gcc-4.8_branch/libgfortran/generated/unpack_c8.c (revision 213313) |
|
1975 @@ -99,7 +99,7 @@ |
|
1976 rs *= extent[n]; |
|
1977 } |
|
1978 ret->offset = 0; |
|
1979 - ret->base_addr = xmalloc (rs * sizeof (GFC_COMPLEX_8)); |
|
1980 + ret->base_addr = xmallocarray (rs, sizeof (GFC_COMPLEX_8)); |
|
1981 } |
|
1982 else |
|
1983 { |
|
1984 @@ -244,7 +244,7 @@ |
|
1985 rs *= extent[n]; |
|
1986 } |
|
1987 ret->offset = 0; |
|
1988 - ret->base_addr = xmalloc (rs * sizeof (GFC_COMPLEX_8)); |
|
1989 + ret->base_addr = xmallocarray (rs, sizeof (GFC_COMPLEX_8)); |
|
1990 } |
|
1991 else |
|
1992 { |
|
1993 Index: gcc-4.8_branch/libgfortran/generated/in_pack_c16.c |
|
1994 =================================================================== |
|
1995 --- gcc-4.8_branch/libgfortran/generated/in_pack_c16.c (revision 213312) |
|
1996 +++ gcc-4.8_branch/libgfortran/generated/in_pack_c16.c (revision 213313) |
|
1997 @@ -76,7 +76,7 @@ |
|
1998 return source->base_addr; |
|
1999 |
|
2000 /* Allocate storage for the destination. */ |
|
2001 - destptr = (GFC_COMPLEX_16 *)xmalloc (ssize * sizeof (GFC_COMPLEX_16)); |
|
2002 + destptr = xmallocarray (ssize, sizeof (GFC_COMPLEX_16)); |
|
2003 dest = destptr; |
|
2004 src = source->base_addr; |
|
2005 stride0 = stride[0]; |
|
2006 Index: gcc-4.8_branch/libgfortran/generated/minloc0_4_i2.c |
|
2007 =================================================================== |
|
2008 --- gcc-4.8_branch/libgfortran/generated/minloc0_4_i2.c (revision 213312) |
|
2009 +++ gcc-4.8_branch/libgfortran/generated/minloc0_4_i2.c (revision 213313) |
|
2010 @@ -58,7 +58,7 @@ |
|
2011 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
2012 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
2013 retarray->offset = 0; |
|
2014 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
2015 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
2016 } |
|
2017 else |
|
2018 { |
|
2019 @@ -199,7 +199,7 @@ |
|
2020 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
2021 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
2022 retarray->offset = 0; |
|
2023 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
2024 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
2025 } |
|
2026 else |
|
2027 { |
|
2028 @@ -367,7 +367,7 @@ |
|
2029 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
2030 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
2031 retarray->offset = 0; |
|
2032 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
2033 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
2034 } |
|
2035 else if (unlikely (compile_options.bounds_check)) |
|
2036 { |
|
2037 Index: gcc-4.8_branch/libgfortran/generated/spread_c10.c |
|
2038 =================================================================== |
|
2039 --- gcc-4.8_branch/libgfortran/generated/spread_c10.c (revision 213312) |
|
2040 +++ gcc-4.8_branch/libgfortran/generated/spread_c10.c (revision 213313) |
|
2041 @@ -101,8 +101,8 @@ |
|
2042 } |
|
2043 ret->offset = 0; |
|
2044 |
|
2045 - /* xmalloc allocates a single byte for zero size. */ |
|
2046 - ret->base_addr = xmalloc (rs * sizeof(GFC_COMPLEX_10)); |
|
2047 + /* xmallocarray allocates a single byte for zero size. */ |
|
2048 + ret->base_addr = xmallocarray (rs, sizeof(GFC_COMPLEX_10)); |
|
2049 if (rs <= 0) |
|
2050 return; |
|
2051 } |
|
2052 @@ -244,7 +244,7 @@ |
|
2053 |
|
2054 if (ret->base_addr == NULL) |
|
2055 { |
|
2056 - ret->base_addr = xmalloc (ncopies * sizeof (GFC_COMPLEX_10)); |
|
2057 + ret->base_addr = xmallocarray (ncopies, sizeof (GFC_COMPLEX_10)); |
|
2058 ret->offset = 0; |
|
2059 GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1); |
|
2060 } |
|
2061 Index: gcc-4.8_branch/libgfortran/generated/maxloc0_8_i1.c |
|
2062 =================================================================== |
|
2063 --- gcc-4.8_branch/libgfortran/generated/maxloc0_8_i1.c (revision 213312) |
|
2064 +++ gcc-4.8_branch/libgfortran/generated/maxloc0_8_i1.c (revision 213313) |
|
2065 @@ -58,7 +58,7 @@ |
|
2066 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
2067 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
2068 retarray->offset = 0; |
|
2069 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
2070 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
2071 } |
|
2072 else |
|
2073 { |
|
2074 @@ -199,7 +199,7 @@ |
|
2075 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
2076 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
2077 retarray->offset = 0; |
|
2078 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
2079 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
2080 } |
|
2081 else |
|
2082 { |
|
2083 @@ -367,7 +367,7 @@ |
|
2084 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
2085 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
2086 retarray->offset = 0; |
|
2087 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
2088 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
2089 } |
|
2090 else if (unlikely (compile_options.bounds_check)) |
|
2091 { |
|
2092 Index: gcc-4.8_branch/libgfortran/generated/spread_r4.c |
|
2093 =================================================================== |
|
2094 --- gcc-4.8_branch/libgfortran/generated/spread_r4.c (revision 213312) |
|
2095 +++ gcc-4.8_branch/libgfortran/generated/spread_r4.c (revision 213313) |
|
2096 @@ -101,8 +101,8 @@ |
|
2097 } |
|
2098 ret->offset = 0; |
|
2099 |
|
2100 - /* xmalloc allocates a single byte for zero size. */ |
|
2101 - ret->base_addr = xmalloc (rs * sizeof(GFC_REAL_4)); |
|
2102 + /* xmallocarray allocates a single byte for zero size. */ |
|
2103 + ret->base_addr = xmallocarray (rs, sizeof(GFC_REAL_4)); |
|
2104 if (rs <= 0) |
|
2105 return; |
|
2106 } |
|
2107 @@ -244,7 +244,7 @@ |
|
2108 |
|
2109 if (ret->base_addr == NULL) |
|
2110 { |
|
2111 - ret->base_addr = xmalloc (ncopies * sizeof (GFC_REAL_4)); |
|
2112 + ret->base_addr = xmallocarray (ncopies, sizeof (GFC_REAL_4)); |
|
2113 ret->offset = 0; |
|
2114 GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1); |
|
2115 } |
|
2116 Index: gcc-4.8_branch/libgfortran/generated/minloc0_8_i8.c |
|
2117 =================================================================== |
|
2118 --- gcc-4.8_branch/libgfortran/generated/minloc0_8_i8.c (revision 213312) |
|
2119 +++ gcc-4.8_branch/libgfortran/generated/minloc0_8_i8.c (revision 213313) |
|
2120 @@ -58,7 +58,7 @@ |
|
2121 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
2122 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
2123 retarray->offset = 0; |
|
2124 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
2125 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
2126 } |
|
2127 else |
|
2128 { |
|
2129 @@ -199,7 +199,7 @@ |
|
2130 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
2131 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
2132 retarray->offset = 0; |
|
2133 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
2134 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
2135 } |
|
2136 else |
|
2137 { |
|
2138 @@ -367,7 +367,7 @@ |
|
2139 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
2140 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
2141 retarray->offset = 0; |
|
2142 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
2143 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
2144 } |
|
2145 else if (unlikely (compile_options.bounds_check)) |
|
2146 { |
|
2147 Index: gcc-4.8_branch/libgfortran/generated/matmul_c8.c |
|
2148 =================================================================== |
|
2149 --- gcc-4.8_branch/libgfortran/generated/matmul_c8.c (revision 213312) |
|
2150 +++ gcc-4.8_branch/libgfortran/generated/matmul_c8.c (revision 213313) |
|
2151 @@ -124,7 +124,7 @@ |
|
2152 } |
|
2153 |
|
2154 retarray->base_addr |
|
2155 - = xmalloc (sizeof (GFC_COMPLEX_8) * size0 ((array_t *) retarray)); |
|
2156 + = xmallocarray (size0 ((array_t *) retarray), sizeof (GFC_COMPLEX_8)); |
|
2157 retarray->offset = 0; |
|
2158 } |
|
2159 else if (unlikely (compile_options.bounds_check)) |
|
2160 Index: gcc-4.8_branch/libgfortran/generated/minloc1_16_r10.c |
|
2161 =================================================================== |
|
2162 --- gcc-4.8_branch/libgfortran/generated/minloc1_16_r10.c (revision 213312) |
|
2163 +++ gcc-4.8_branch/libgfortran/generated/minloc1_16_r10.c (revision 213313) |
|
2164 @@ -98,10 +98,9 @@ |
|
2165 retarray->offset = 0; |
|
2166 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2167 |
|
2168 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2169 - * extent[rank-1]; |
|
2170 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2171 |
|
2172 - retarray->base_addr = xmalloc (alloc_size); |
|
2173 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
2174 if (alloc_size == 0) |
|
2175 { |
|
2176 /* Make sure we have a zero-sized array. */ |
|
2177 @@ -294,8 +293,7 @@ |
|
2178 |
|
2179 } |
|
2180 |
|
2181 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2182 - * extent[rank-1]; |
|
2183 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2184 |
|
2185 retarray->offset = 0; |
|
2186 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2187 @@ -307,7 +305,7 @@ |
|
2188 return; |
|
2189 } |
|
2190 else |
|
2191 - retarray->base_addr = xmalloc (alloc_size); |
|
2192 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
2193 |
|
2194 } |
|
2195 else |
|
2196 @@ -485,8 +483,7 @@ |
|
2197 retarray->offset = 0; |
|
2198 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2199 |
|
2200 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2201 - * extent[rank-1]; |
|
2202 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2203 |
|
2204 if (alloc_size == 0) |
|
2205 { |
|
2206 @@ -495,7 +492,7 @@ |
|
2207 return; |
|
2208 } |
|
2209 else |
|
2210 - retarray->base_addr = xmalloc (alloc_size); |
|
2211 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
2212 } |
|
2213 else |
|
2214 { |
|
2215 Index: gcc-4.8_branch/libgfortran/generated/sum_i2.c |
|
2216 =================================================================== |
|
2217 --- gcc-4.8_branch/libgfortran/generated/sum_i2.c (revision 213312) |
|
2218 +++ gcc-4.8_branch/libgfortran/generated/sum_i2.c (revision 213313) |
|
2219 @@ -97,10 +97,9 @@ |
|
2220 retarray->offset = 0; |
|
2221 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2222 |
|
2223 - alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2224 - * extent[rank-1]; |
|
2225 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2226 |
|
2227 - retarray->base_addr = xmalloc (alloc_size); |
|
2228 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); |
|
2229 if (alloc_size == 0) |
|
2230 { |
|
2231 /* Make sure we have a zero-sized array. */ |
|
2232 @@ -272,8 +271,7 @@ |
|
2233 |
|
2234 } |
|
2235 |
|
2236 - alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2237 - * extent[rank-1]; |
|
2238 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2239 |
|
2240 retarray->offset = 0; |
|
2241 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2242 @@ -285,7 +283,7 @@ |
|
2243 return; |
|
2244 } |
|
2245 else |
|
2246 - retarray->base_addr = xmalloc (alloc_size); |
|
2247 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); |
|
2248 |
|
2249 } |
|
2250 else |
|
2251 @@ -430,8 +428,7 @@ |
|
2252 retarray->offset = 0; |
|
2253 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2254 |
|
2255 - alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2256 - * extent[rank-1]; |
|
2257 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2258 |
|
2259 if (alloc_size == 0) |
|
2260 { |
|
2261 @@ -440,7 +437,7 @@ |
|
2262 return; |
|
2263 } |
|
2264 else |
|
2265 - retarray->base_addr = xmalloc (alloc_size); |
|
2266 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); |
|
2267 } |
|
2268 else |
|
2269 { |
|
2270 Index: gcc-4.8_branch/libgfortran/generated/iparity_i16.c |
|
2271 =================================================================== |
|
2272 --- gcc-4.8_branch/libgfortran/generated/iparity_i16.c (revision 213312) |
|
2273 +++ gcc-4.8_branch/libgfortran/generated/iparity_i16.c (revision 213313) |
|
2274 @@ -97,10 +97,9 @@ |
|
2275 retarray->offset = 0; |
|
2276 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2277 |
|
2278 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2279 - * extent[rank-1]; |
|
2280 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2281 |
|
2282 - retarray->base_addr = xmalloc (alloc_size); |
|
2283 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
2284 if (alloc_size == 0) |
|
2285 { |
|
2286 /* Make sure we have a zero-sized array. */ |
|
2287 @@ -272,8 +271,7 @@ |
|
2288 |
|
2289 } |
|
2290 |
|
2291 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2292 - * extent[rank-1]; |
|
2293 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2294 |
|
2295 retarray->offset = 0; |
|
2296 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2297 @@ -285,7 +283,7 @@ |
|
2298 return; |
|
2299 } |
|
2300 else |
|
2301 - retarray->base_addr = xmalloc (alloc_size); |
|
2302 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
2303 |
|
2304 } |
|
2305 else |
|
2306 @@ -430,8 +428,7 @@ |
|
2307 retarray->offset = 0; |
|
2308 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2309 |
|
2310 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2311 - * extent[rank-1]; |
|
2312 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2313 |
|
2314 if (alloc_size == 0) |
|
2315 { |
|
2316 @@ -440,7 +437,7 @@ |
|
2317 return; |
|
2318 } |
|
2319 else |
|
2320 - retarray->base_addr = xmalloc (alloc_size); |
|
2321 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
2322 } |
|
2323 else |
|
2324 { |
|
2325 Index: gcc-4.8_branch/libgfortran/generated/minloc0_16_i1.c |
|
2326 =================================================================== |
|
2327 --- gcc-4.8_branch/libgfortran/generated/minloc0_16_i1.c (revision 213312) |
|
2328 +++ gcc-4.8_branch/libgfortran/generated/minloc0_16_i1.c (revision 213313) |
|
2329 @@ -58,7 +58,7 @@ |
|
2330 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
2331 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
2332 retarray->offset = 0; |
|
2333 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
2334 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
2335 } |
|
2336 else |
|
2337 { |
|
2338 @@ -199,7 +199,7 @@ |
|
2339 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
2340 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
2341 retarray->offset = 0; |
|
2342 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
2343 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
2344 } |
|
2345 else |
|
2346 { |
|
2347 @@ -367,7 +367,7 @@ |
|
2348 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
2349 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
2350 retarray->offset = 0; |
|
2351 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
2352 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
2353 } |
|
2354 else if (unlikely (compile_options.bounds_check)) |
|
2355 { |
|
2356 Index: gcc-4.8_branch/libgfortran/generated/reshape_c16.c |
|
2357 =================================================================== |
|
2358 --- gcc-4.8_branch/libgfortran/generated/reshape_c16.c (revision 213312) |
|
2359 +++ gcc-4.8_branch/libgfortran/generated/reshape_c16.c (revision 213313) |
|
2360 @@ -111,11 +111,11 @@ |
|
2361 ret->offset = 0; |
|
2362 |
|
2363 if (unlikely (rs < 1)) |
|
2364 - alloc_size = 1; |
|
2365 + alloc_size = 0; |
|
2366 else |
|
2367 - alloc_size = rs * sizeof (GFC_COMPLEX_16); |
|
2368 + alloc_size = rs; |
|
2369 |
|
2370 - ret->base_addr = xmalloc (alloc_size); |
|
2371 + ret->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_16)); |
|
2372 ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim; |
|
2373 } |
|
2374 |
|
2375 Index: gcc-4.8_branch/libgfortran/generated/pack_c4.c |
|
2376 =================================================================== |
|
2377 --- gcc-4.8_branch/libgfortran/generated/pack_c4.c (revision 213312) |
|
2378 +++ gcc-4.8_branch/libgfortran/generated/pack_c4.c (revision 213313) |
|
2379 @@ -167,8 +167,8 @@ |
|
2380 |
|
2381 ret->offset = 0; |
|
2382 |
|
2383 - /* xmalloc allocates a single byte for zero size. */ |
|
2384 - ret->base_addr = xmalloc (sizeof (GFC_COMPLEX_4) * total); |
|
2385 + /* xmallocarray allocates a single byte for zero size. */ |
|
2386 + ret->base_addr = xmallocarray (total, sizeof (GFC_COMPLEX_4)); |
|
2387 |
|
2388 if (total == 0) |
|
2389 return; |
|
2390 Index: gcc-4.8_branch/libgfortran/generated/parity_l4.c |
|
2391 =================================================================== |
|
2392 --- gcc-4.8_branch/libgfortran/generated/parity_l4.c (revision 213312) |
|
2393 +++ gcc-4.8_branch/libgfortran/generated/parity_l4.c (revision 213313) |
|
2394 @@ -98,10 +98,9 @@ |
|
2395 retarray->offset = 0; |
|
2396 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2397 |
|
2398 - alloc_size = sizeof (GFC_LOGICAL_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2399 - * extent[rank-1]; |
|
2400 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2401 |
|
2402 - retarray->base_addr = xmalloc (alloc_size); |
|
2403 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_LOGICAL_4)); |
|
2404 if (alloc_size == 0) |
|
2405 { |
|
2406 /* Make sure we have a zero-sized array. */ |
|
2407 Index: gcc-4.8_branch/libgfortran/generated/spread_i2.c |
|
2408 =================================================================== |
|
2409 --- gcc-4.8_branch/libgfortran/generated/spread_i2.c (revision 213312) |
|
2410 +++ gcc-4.8_branch/libgfortran/generated/spread_i2.c (revision 213313) |
|
2411 @@ -101,8 +101,8 @@ |
|
2412 } |
|
2413 ret->offset = 0; |
|
2414 |
|
2415 - /* xmalloc allocates a single byte for zero size. */ |
|
2416 - ret->base_addr = xmalloc (rs * sizeof(GFC_INTEGER_2)); |
|
2417 + /* xmallocarray allocates a single byte for zero size. */ |
|
2418 + ret->base_addr = xmallocarray (rs, sizeof(GFC_INTEGER_2)); |
|
2419 if (rs <= 0) |
|
2420 return; |
|
2421 } |
|
2422 @@ -244,7 +244,7 @@ |
|
2423 |
|
2424 if (ret->base_addr == NULL) |
|
2425 { |
|
2426 - ret->base_addr = xmalloc (ncopies * sizeof (GFC_INTEGER_2)); |
|
2427 + ret->base_addr = xmallocarray (ncopies, sizeof (GFC_INTEGER_2)); |
|
2428 ret->offset = 0; |
|
2429 GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1); |
|
2430 } |
|
2431 Index: gcc-4.8_branch/libgfortran/generated/any_l4.c |
|
2432 =================================================================== |
|
2433 --- gcc-4.8_branch/libgfortran/generated/any_l4.c (revision 213312) |
|
2434 +++ gcc-4.8_branch/libgfortran/generated/any_l4.c (revision 213313) |
|
2435 @@ -101,8 +101,7 @@ |
|
2436 retarray->offset = 0; |
|
2437 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2438 |
|
2439 - alloc_size = sizeof (GFC_LOGICAL_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2440 - * extent[rank-1]; |
|
2441 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2442 |
|
2443 if (alloc_size == 0) |
|
2444 { |
|
2445 @@ -111,7 +110,7 @@ |
|
2446 return; |
|
2447 } |
|
2448 else |
|
2449 - retarray->base_addr = xmalloc (alloc_size); |
|
2450 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_LOGICAL_4)); |
|
2451 } |
|
2452 else |
|
2453 { |
|
2454 Index: gcc-4.8_branch/libgfortran/generated/maxloc1_4_i8.c |
|
2455 =================================================================== |
|
2456 --- gcc-4.8_branch/libgfortran/generated/maxloc1_4_i8.c (revision 213312) |
|
2457 +++ gcc-4.8_branch/libgfortran/generated/maxloc1_4_i8.c (revision 213313) |
|
2458 @@ -98,10 +98,9 @@ |
|
2459 retarray->offset = 0; |
|
2460 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2461 |
|
2462 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2463 - * extent[rank-1]; |
|
2464 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2465 |
|
2466 - retarray->base_addr = xmalloc (alloc_size); |
|
2467 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
2468 if (alloc_size == 0) |
|
2469 { |
|
2470 /* Make sure we have a zero-sized array. */ |
|
2471 @@ -294,8 +293,7 @@ |
|
2472 |
|
2473 } |
|
2474 |
|
2475 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2476 - * extent[rank-1]; |
|
2477 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2478 |
|
2479 retarray->offset = 0; |
|
2480 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2481 @@ -307,7 +305,7 @@ |
|
2482 return; |
|
2483 } |
|
2484 else |
|
2485 - retarray->base_addr = xmalloc (alloc_size); |
|
2486 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
2487 |
|
2488 } |
|
2489 else |
|
2490 @@ -485,8 +483,7 @@ |
|
2491 retarray->offset = 0; |
|
2492 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2493 |
|
2494 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2495 - * extent[rank-1]; |
|
2496 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2497 |
|
2498 if (alloc_size == 0) |
|
2499 { |
|
2500 @@ -495,7 +492,7 @@ |
|
2501 return; |
|
2502 } |
|
2503 else |
|
2504 - retarray->base_addr = xmalloc (alloc_size); |
|
2505 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
2506 } |
|
2507 else |
|
2508 { |
|
2509 Index: gcc-4.8_branch/libgfortran/generated/maxloc0_8_r4.c |
|
2510 =================================================================== |
|
2511 --- gcc-4.8_branch/libgfortran/generated/maxloc0_8_r4.c (revision 213312) |
|
2512 +++ gcc-4.8_branch/libgfortran/generated/maxloc0_8_r4.c (revision 213313) |
|
2513 @@ -58,7 +58,7 @@ |
|
2514 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
2515 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
2516 retarray->offset = 0; |
|
2517 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
2518 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
2519 } |
|
2520 else |
|
2521 { |
|
2522 @@ -199,7 +199,7 @@ |
|
2523 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
2524 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
2525 retarray->offset = 0; |
|
2526 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
2527 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
2528 } |
|
2529 else |
|
2530 { |
|
2531 @@ -367,7 +367,7 @@ |
|
2532 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
2533 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
2534 retarray->offset = 0; |
|
2535 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
2536 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
2537 } |
|
2538 else if (unlikely (compile_options.bounds_check)) |
|
2539 { |
|
2540 Index: gcc-4.8_branch/libgfortran/generated/maxloc1_4_i16.c |
|
2541 =================================================================== |
|
2542 --- gcc-4.8_branch/libgfortran/generated/maxloc1_4_i16.c (revision 213312) |
|
2543 +++ gcc-4.8_branch/libgfortran/generated/maxloc1_4_i16.c (revision 213313) |
|
2544 @@ -98,10 +98,9 @@ |
|
2545 retarray->offset = 0; |
|
2546 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2547 |
|
2548 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2549 - * extent[rank-1]; |
|
2550 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2551 |
|
2552 - retarray->base_addr = xmalloc (alloc_size); |
|
2553 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
2554 if (alloc_size == 0) |
|
2555 { |
|
2556 /* Make sure we have a zero-sized array. */ |
|
2557 @@ -294,8 +293,7 @@ |
|
2558 |
|
2559 } |
|
2560 |
|
2561 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2562 - * extent[rank-1]; |
|
2563 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2564 |
|
2565 retarray->offset = 0; |
|
2566 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2567 @@ -307,7 +305,7 @@ |
|
2568 return; |
|
2569 } |
|
2570 else |
|
2571 - retarray->base_addr = xmalloc (alloc_size); |
|
2572 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
2573 |
|
2574 } |
|
2575 else |
|
2576 @@ -485,8 +483,7 @@ |
|
2577 retarray->offset = 0; |
|
2578 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2579 |
|
2580 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2581 - * extent[rank-1]; |
|
2582 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2583 |
|
2584 if (alloc_size == 0) |
|
2585 { |
|
2586 @@ -495,7 +492,7 @@ |
|
2587 return; |
|
2588 } |
|
2589 else |
|
2590 - retarray->base_addr = xmalloc (alloc_size); |
|
2591 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
2592 } |
|
2593 else |
|
2594 { |
|
2595 Index: gcc-4.8_branch/libgfortran/generated/minloc0_4_r10.c |
|
2596 =================================================================== |
|
2597 --- gcc-4.8_branch/libgfortran/generated/minloc0_4_r10.c (revision 213312) |
|
2598 +++ gcc-4.8_branch/libgfortran/generated/minloc0_4_r10.c (revision 213313) |
|
2599 @@ -58,7 +58,7 @@ |
|
2600 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
2601 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
2602 retarray->offset = 0; |
|
2603 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
2604 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
2605 } |
|
2606 else |
|
2607 { |
|
2608 @@ -199,7 +199,7 @@ |
|
2609 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
2610 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
2611 retarray->offset = 0; |
|
2612 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
2613 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
2614 } |
|
2615 else |
|
2616 { |
|
2617 @@ -367,7 +367,7 @@ |
|
2618 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
2619 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
2620 retarray->offset = 0; |
|
2621 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
2622 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
2623 } |
|
2624 else if (unlikely (compile_options.bounds_check)) |
|
2625 { |
|
2626 Index: gcc-4.8_branch/libgfortran/generated/minloc0_8_i16.c |
|
2627 =================================================================== |
|
2628 --- gcc-4.8_branch/libgfortran/generated/minloc0_8_i16.c (revision 213312) |
|
2629 +++ gcc-4.8_branch/libgfortran/generated/minloc0_8_i16.c (revision 213313) |
|
2630 @@ -58,7 +58,7 @@ |
|
2631 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
2632 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
2633 retarray->offset = 0; |
|
2634 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
2635 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
2636 } |
|
2637 else |
|
2638 { |
|
2639 @@ -199,7 +199,7 @@ |
|
2640 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
2641 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
2642 retarray->offset = 0; |
|
2643 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
2644 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
2645 } |
|
2646 else |
|
2647 { |
|
2648 @@ -367,7 +367,7 @@ |
|
2649 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
2650 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
2651 retarray->offset = 0; |
|
2652 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
2653 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
2654 } |
|
2655 else if (unlikely (compile_options.bounds_check)) |
|
2656 { |
|
2657 Index: gcc-4.8_branch/libgfortran/generated/minloc1_8_r10.c |
|
2658 =================================================================== |
|
2659 --- gcc-4.8_branch/libgfortran/generated/minloc1_8_r10.c (revision 213312) |
|
2660 +++ gcc-4.8_branch/libgfortran/generated/minloc1_8_r10.c (revision 213313) |
|
2661 @@ -98,10 +98,9 @@ |
|
2662 retarray->offset = 0; |
|
2663 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2664 |
|
2665 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2666 - * extent[rank-1]; |
|
2667 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2668 |
|
2669 - retarray->base_addr = xmalloc (alloc_size); |
|
2670 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
2671 if (alloc_size == 0) |
|
2672 { |
|
2673 /* Make sure we have a zero-sized array. */ |
|
2674 @@ -294,8 +293,7 @@ |
|
2675 |
|
2676 } |
|
2677 |
|
2678 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2679 - * extent[rank-1]; |
|
2680 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2681 |
|
2682 retarray->offset = 0; |
|
2683 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2684 @@ -307,7 +305,7 @@ |
|
2685 return; |
|
2686 } |
|
2687 else |
|
2688 - retarray->base_addr = xmalloc (alloc_size); |
|
2689 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
2690 |
|
2691 } |
|
2692 else |
|
2693 @@ -485,8 +483,7 @@ |
|
2694 retarray->offset = 0; |
|
2695 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2696 |
|
2697 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2698 - * extent[rank-1]; |
|
2699 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2700 |
|
2701 if (alloc_size == 0) |
|
2702 { |
|
2703 @@ -495,7 +492,7 @@ |
|
2704 return; |
|
2705 } |
|
2706 else |
|
2707 - retarray->base_addr = xmalloc (alloc_size); |
|
2708 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
2709 } |
|
2710 else |
|
2711 { |
|
2712 Index: gcc-4.8_branch/libgfortran/generated/minloc0_16_r4.c |
|
2713 =================================================================== |
|
2714 --- gcc-4.8_branch/libgfortran/generated/minloc0_16_r4.c (revision 213312) |
|
2715 +++ gcc-4.8_branch/libgfortran/generated/minloc0_16_r4.c (revision 213313) |
|
2716 @@ -58,7 +58,7 @@ |
|
2717 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
2718 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
2719 retarray->offset = 0; |
|
2720 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
2721 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
2722 } |
|
2723 else |
|
2724 { |
|
2725 @@ -199,7 +199,7 @@ |
|
2726 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
2727 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
2728 retarray->offset = 0; |
|
2729 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
2730 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
2731 } |
|
2732 else |
|
2733 { |
|
2734 @@ -367,7 +367,7 @@ |
|
2735 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
2736 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
2737 retarray->offset = 0; |
|
2738 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
2739 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
2740 } |
|
2741 else if (unlikely (compile_options.bounds_check)) |
|
2742 { |
|
2743 Index: gcc-4.8_branch/libgfortran/generated/product_i4.c |
|
2744 =================================================================== |
|
2745 --- gcc-4.8_branch/libgfortran/generated/product_i4.c (revision 213312) |
|
2746 +++ gcc-4.8_branch/libgfortran/generated/product_i4.c (revision 213313) |
|
2747 @@ -97,10 +97,9 @@ |
|
2748 retarray->offset = 0; |
|
2749 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2750 |
|
2751 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2752 - * extent[rank-1]; |
|
2753 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2754 |
|
2755 - retarray->base_addr = xmalloc (alloc_size); |
|
2756 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
2757 if (alloc_size == 0) |
|
2758 { |
|
2759 /* Make sure we have a zero-sized array. */ |
|
2760 @@ -272,8 +271,7 @@ |
|
2761 |
|
2762 } |
|
2763 |
|
2764 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2765 - * extent[rank-1]; |
|
2766 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2767 |
|
2768 retarray->offset = 0; |
|
2769 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2770 @@ -285,7 +283,7 @@ |
|
2771 return; |
|
2772 } |
|
2773 else |
|
2774 - retarray->base_addr = xmalloc (alloc_size); |
|
2775 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
2776 |
|
2777 } |
|
2778 else |
|
2779 @@ -430,8 +428,7 @@ |
|
2780 retarray->offset = 0; |
|
2781 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2782 |
|
2783 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2784 - * extent[rank-1]; |
|
2785 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2786 |
|
2787 if (alloc_size == 0) |
|
2788 { |
|
2789 @@ -440,7 +437,7 @@ |
|
2790 return; |
|
2791 } |
|
2792 else |
|
2793 - retarray->base_addr = xmalloc (alloc_size); |
|
2794 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
2795 } |
|
2796 else |
|
2797 { |
|
2798 Index: gcc-4.8_branch/libgfortran/generated/sum_c16.c |
|
2799 =================================================================== |
|
2800 --- gcc-4.8_branch/libgfortran/generated/sum_c16.c (revision 213312) |
|
2801 +++ gcc-4.8_branch/libgfortran/generated/sum_c16.c (revision 213313) |
|
2802 @@ -97,10 +97,9 @@ |
|
2803 retarray->offset = 0; |
|
2804 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2805 |
|
2806 - alloc_size = sizeof (GFC_COMPLEX_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2807 - * extent[rank-1]; |
|
2808 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2809 |
|
2810 - retarray->base_addr = xmalloc (alloc_size); |
|
2811 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_16)); |
|
2812 if (alloc_size == 0) |
|
2813 { |
|
2814 /* Make sure we have a zero-sized array. */ |
|
2815 @@ -272,8 +271,7 @@ |
|
2816 |
|
2817 } |
|
2818 |
|
2819 - alloc_size = sizeof (GFC_COMPLEX_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2820 - * extent[rank-1]; |
|
2821 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2822 |
|
2823 retarray->offset = 0; |
|
2824 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2825 @@ -285,7 +283,7 @@ |
|
2826 return; |
|
2827 } |
|
2828 else |
|
2829 - retarray->base_addr = xmalloc (alloc_size); |
|
2830 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_16)); |
|
2831 |
|
2832 } |
|
2833 else |
|
2834 @@ -430,8 +428,7 @@ |
|
2835 retarray->offset = 0; |
|
2836 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2837 |
|
2838 - alloc_size = sizeof (GFC_COMPLEX_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2839 - * extent[rank-1]; |
|
2840 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2841 |
|
2842 if (alloc_size == 0) |
|
2843 { |
|
2844 @@ -440,7 +437,7 @@ |
|
2845 return; |
|
2846 } |
|
2847 else |
|
2848 - retarray->base_addr = xmalloc (alloc_size); |
|
2849 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_16)); |
|
2850 } |
|
2851 else |
|
2852 { |
|
2853 Index: gcc-4.8_branch/libgfortran/generated/transpose_c10.c |
|
2854 =================================================================== |
|
2855 --- gcc-4.8_branch/libgfortran/generated/transpose_c10.c (revision 213312) |
|
2856 +++ gcc-4.8_branch/libgfortran/generated/transpose_c10.c (revision 213313) |
|
2857 @@ -60,7 +60,8 @@ |
|
2858 GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0) - 1, |
|
2859 GFC_DESCRIPTOR_EXTENT(source, 1)); |
|
2860 |
|
2861 - ret->base_addr = xmalloc (sizeof (GFC_COMPLEX_10) * size0 ((array_t *) ret)); |
|
2862 + ret->base_addr = xmallocarray (size0 ((array_t *) ret), |
|
2863 + sizeof (GFC_COMPLEX_10)); |
|
2864 ret->offset = 0; |
|
2865 } else if (unlikely (compile_options.bounds_check)) |
|
2866 { |
|
2867 Index: gcc-4.8_branch/libgfortran/generated/maxloc1_16_r8.c |
|
2868 =================================================================== |
|
2869 --- gcc-4.8_branch/libgfortran/generated/maxloc1_16_r8.c (revision 213312) |
|
2870 +++ gcc-4.8_branch/libgfortran/generated/maxloc1_16_r8.c (revision 213313) |
|
2871 @@ -98,10 +98,9 @@ |
|
2872 retarray->offset = 0; |
|
2873 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2874 |
|
2875 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2876 - * extent[rank-1]; |
|
2877 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2878 |
|
2879 - retarray->base_addr = xmalloc (alloc_size); |
|
2880 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
2881 if (alloc_size == 0) |
|
2882 { |
|
2883 /* Make sure we have a zero-sized array. */ |
|
2884 @@ -294,8 +293,7 @@ |
|
2885 |
|
2886 } |
|
2887 |
|
2888 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2889 - * extent[rank-1]; |
|
2890 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2891 |
|
2892 retarray->offset = 0; |
|
2893 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2894 @@ -307,7 +305,7 @@ |
|
2895 return; |
|
2896 } |
|
2897 else |
|
2898 - retarray->base_addr = xmalloc (alloc_size); |
|
2899 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
2900 |
|
2901 } |
|
2902 else |
|
2903 @@ -485,8 +483,7 @@ |
|
2904 retarray->offset = 0; |
|
2905 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2906 |
|
2907 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2908 - * extent[rank-1]; |
|
2909 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2910 |
|
2911 if (alloc_size == 0) |
|
2912 { |
|
2913 @@ -495,7 +492,7 @@ |
|
2914 return; |
|
2915 } |
|
2916 else |
|
2917 - retarray->base_addr = xmalloc (alloc_size); |
|
2918 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
2919 } |
|
2920 else |
|
2921 { |
|
2922 Index: gcc-4.8_branch/libgfortran/generated/transpose_r4.c |
|
2923 =================================================================== |
|
2924 --- gcc-4.8_branch/libgfortran/generated/transpose_r4.c (revision 213312) |
|
2925 +++ gcc-4.8_branch/libgfortran/generated/transpose_r4.c (revision 213313) |
|
2926 @@ -60,7 +60,8 @@ |
|
2927 GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0) - 1, |
|
2928 GFC_DESCRIPTOR_EXTENT(source, 1)); |
|
2929 |
|
2930 - ret->base_addr = xmalloc (sizeof (GFC_REAL_4) * size0 ((array_t *) ret)); |
|
2931 + ret->base_addr = xmallocarray (size0 ((array_t *) ret), |
|
2932 + sizeof (GFC_REAL_4)); |
|
2933 ret->offset = 0; |
|
2934 } else if (unlikely (compile_options.bounds_check)) |
|
2935 { |
|
2936 Index: gcc-4.8_branch/libgfortran/generated/cshift1_4.c |
|
2937 =================================================================== |
|
2938 --- gcc-4.8_branch/libgfortran/generated/cshift1_4.c (revision 213312) |
|
2939 +++ gcc-4.8_branch/libgfortran/generated/cshift1_4.c (revision 213313) |
|
2940 @@ -80,7 +80,7 @@ |
|
2941 { |
|
2942 int i; |
|
2943 |
|
2944 - ret->base_addr = xmalloc (size * arraysize); |
|
2945 + ret->base_addr = xmallocarray (arraysize, size); |
|
2946 ret->offset = 0; |
|
2947 ret->dtype = array->dtype; |
|
2948 for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++) |
|
2949 Index: gcc-4.8_branch/libgfortran/generated/maxloc0_8_i2.c |
|
2950 =================================================================== |
|
2951 --- gcc-4.8_branch/libgfortran/generated/maxloc0_8_i2.c (revision 213312) |
|
2952 +++ gcc-4.8_branch/libgfortran/generated/maxloc0_8_i2.c (revision 213313) |
|
2953 @@ -58,7 +58,7 @@ |
|
2954 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
2955 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
2956 retarray->offset = 0; |
|
2957 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
2958 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
2959 } |
|
2960 else |
|
2961 { |
|
2962 @@ -199,7 +199,7 @@ |
|
2963 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
2964 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
2965 retarray->offset = 0; |
|
2966 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
2967 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
2968 } |
|
2969 else |
|
2970 { |
|
2971 @@ -367,7 +367,7 @@ |
|
2972 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
2973 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
2974 retarray->offset = 0; |
|
2975 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
2976 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
2977 } |
|
2978 else if (unlikely (compile_options.bounds_check)) |
|
2979 { |
|
2980 Index: gcc-4.8_branch/libgfortran/generated/count_8_l.c |
|
2981 =================================================================== |
|
2982 --- gcc-4.8_branch/libgfortran/generated/count_8_l.c (revision 213312) |
|
2983 +++ gcc-4.8_branch/libgfortran/generated/count_8_l.c (revision 213313) |
|
2984 @@ -101,8 +101,7 @@ |
|
2985 retarray->offset = 0; |
|
2986 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
2987 |
|
2988 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
2989 - * extent[rank-1]; |
|
2990 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
2991 |
|
2992 if (alloc_size == 0) |
|
2993 { |
|
2994 @@ -111,7 +110,7 @@ |
|
2995 return; |
|
2996 } |
|
2997 else |
|
2998 - retarray->base_addr = xmalloc (alloc_size); |
|
2999 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
3000 } |
|
3001 else |
|
3002 { |
|
3003 Index: gcc-4.8_branch/libgfortran/generated/in_pack_i4.c |
|
3004 =================================================================== |
|
3005 --- gcc-4.8_branch/libgfortran/generated/in_pack_i4.c (revision 213312) |
|
3006 +++ gcc-4.8_branch/libgfortran/generated/in_pack_i4.c (revision 213313) |
|
3007 @@ -76,7 +76,7 @@ |
|
3008 return source->base_addr; |
|
3009 |
|
3010 /* Allocate storage for the destination. */ |
|
3011 - destptr = (GFC_INTEGER_4 *)xmalloc (ssize * sizeof (GFC_INTEGER_4)); |
|
3012 + destptr = xmallocarray (ssize, sizeof (GFC_INTEGER_4)); |
|
3013 dest = destptr; |
|
3014 src = source->base_addr; |
|
3015 stride0 = stride[0]; |
|
3016 Index: gcc-4.8_branch/libgfortran/generated/minloc0_16_i2.c |
|
3017 =================================================================== |
|
3018 --- gcc-4.8_branch/libgfortran/generated/minloc0_16_i2.c (revision 213312) |
|
3019 +++ gcc-4.8_branch/libgfortran/generated/minloc0_16_i2.c (revision 213313) |
|
3020 @@ -58,7 +58,7 @@ |
|
3021 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
3022 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
3023 retarray->offset = 0; |
|
3024 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
3025 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
3026 } |
|
3027 else |
|
3028 { |
|
3029 @@ -199,7 +199,7 @@ |
|
3030 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
3031 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
3032 retarray->offset = 0; |
|
3033 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
3034 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
3035 } |
|
3036 else |
|
3037 { |
|
3038 @@ -367,7 +367,7 @@ |
|
3039 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
3040 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
3041 retarray->offset = 0; |
|
3042 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
3043 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
3044 } |
|
3045 else if (unlikely (compile_options.bounds_check)) |
|
3046 { |
|
3047 Index: gcc-4.8_branch/libgfortran/generated/minloc1_8_r8.c |
|
3048 =================================================================== |
|
3049 --- gcc-4.8_branch/libgfortran/generated/minloc1_8_r8.c (revision 213312) |
|
3050 +++ gcc-4.8_branch/libgfortran/generated/minloc1_8_r8.c (revision 213313) |
|
3051 @@ -98,10 +98,9 @@ |
|
3052 retarray->offset = 0; |
|
3053 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3054 |
|
3055 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3056 - * extent[rank-1]; |
|
3057 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3058 |
|
3059 - retarray->base_addr = xmalloc (alloc_size); |
|
3060 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
3061 if (alloc_size == 0) |
|
3062 { |
|
3063 /* Make sure we have a zero-sized array. */ |
|
3064 @@ -294,8 +293,7 @@ |
|
3065 |
|
3066 } |
|
3067 |
|
3068 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3069 - * extent[rank-1]; |
|
3070 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3071 |
|
3072 retarray->offset = 0; |
|
3073 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3074 @@ -307,7 +305,7 @@ |
|
3075 return; |
|
3076 } |
|
3077 else |
|
3078 - retarray->base_addr = xmalloc (alloc_size); |
|
3079 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
3080 |
|
3081 } |
|
3082 else |
|
3083 @@ -485,8 +483,7 @@ |
|
3084 retarray->offset = 0; |
|
3085 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3086 |
|
3087 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3088 - * extent[rank-1]; |
|
3089 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3090 |
|
3091 if (alloc_size == 0) |
|
3092 { |
|
3093 @@ -495,7 +492,7 @@ |
|
3094 return; |
|
3095 } |
|
3096 else |
|
3097 - retarray->base_addr = xmalloc (alloc_size); |
|
3098 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
3099 } |
|
3100 else |
|
3101 { |
|
3102 Index: gcc-4.8_branch/libgfortran/generated/matmul_c16.c |
|
3103 =================================================================== |
|
3104 --- gcc-4.8_branch/libgfortran/generated/matmul_c16.c (revision 213312) |
|
3105 +++ gcc-4.8_branch/libgfortran/generated/matmul_c16.c (revision 213313) |
|
3106 @@ -124,7 +124,7 @@ |
|
3107 } |
|
3108 |
|
3109 retarray->base_addr |
|
3110 - = xmalloc (sizeof (GFC_COMPLEX_16) * size0 ((array_t *) retarray)); |
|
3111 + = xmallocarray (size0 ((array_t *) retarray), sizeof (GFC_COMPLEX_16)); |
|
3112 retarray->offset = 0; |
|
3113 } |
|
3114 else if (unlikely (compile_options.bounds_check)) |
|
3115 Index: gcc-4.8_branch/libgfortran/generated/minval_i1.c |
|
3116 =================================================================== |
|
3117 --- gcc-4.8_branch/libgfortran/generated/minval_i1.c (revision 213312) |
|
3118 +++ gcc-4.8_branch/libgfortran/generated/minval_i1.c (revision 213313) |
|
3119 @@ -97,10 +97,9 @@ |
|
3120 retarray->offset = 0; |
|
3121 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3122 |
|
3123 - alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3124 - * extent[rank-1]; |
|
3125 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3126 |
|
3127 - retarray->base_addr = xmalloc (alloc_size); |
|
3128 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); |
|
3129 if (alloc_size == 0) |
|
3130 { |
|
3131 /* Make sure we have a zero-sized array. */ |
|
3132 @@ -286,8 +285,7 @@ |
|
3133 |
|
3134 } |
|
3135 |
|
3136 - alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3137 - * extent[rank-1]; |
|
3138 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3139 |
|
3140 retarray->offset = 0; |
|
3141 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3142 @@ -299,7 +297,7 @@ |
|
3143 return; |
|
3144 } |
|
3145 else |
|
3146 - retarray->base_addr = xmalloc (alloc_size); |
|
3147 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); |
|
3148 |
|
3149 } |
|
3150 else |
|
3151 @@ -472,8 +470,7 @@ |
|
3152 retarray->offset = 0; |
|
3153 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3154 |
|
3155 - alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3156 - * extent[rank-1]; |
|
3157 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3158 |
|
3159 if (alloc_size == 0) |
|
3160 { |
|
3161 @@ -482,7 +479,7 @@ |
|
3162 return; |
|
3163 } |
|
3164 else |
|
3165 - retarray->base_addr = xmalloc (alloc_size); |
|
3166 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); |
|
3167 } |
|
3168 else |
|
3169 { |
|
3170 Index: gcc-4.8_branch/libgfortran/generated/shape_i16.c |
|
3171 =================================================================== |
|
3172 --- gcc-4.8_branch/libgfortran/generated/shape_i16.c (revision 213312) |
|
3173 +++ gcc-4.8_branch/libgfortran/generated/shape_i16.c (revision 213313) |
|
3174 @@ -49,7 +49,7 @@ |
|
3175 { |
|
3176 GFC_DIMENSION_SET(ret->dim[0], 0, rank - 1, 1); |
|
3177 ret->offset = 0; |
|
3178 - ret->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
3179 + ret->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
3180 } |
|
3181 |
|
3182 stride = GFC_DESCRIPTOR_STRIDE(ret,0); |
|
3183 Index: gcc-4.8_branch/libgfortran/generated/iany_i4.c |
|
3184 =================================================================== |
|
3185 --- gcc-4.8_branch/libgfortran/generated/iany_i4.c (revision 213312) |
|
3186 +++ gcc-4.8_branch/libgfortran/generated/iany_i4.c (revision 213313) |
|
3187 @@ -97,10 +97,9 @@ |
|
3188 retarray->offset = 0; |
|
3189 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3190 |
|
3191 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3192 - * extent[rank-1]; |
|
3193 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3194 |
|
3195 - retarray->base_addr = xmalloc (alloc_size); |
|
3196 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
3197 if (alloc_size == 0) |
|
3198 { |
|
3199 /* Make sure we have a zero-sized array. */ |
|
3200 @@ -272,8 +271,7 @@ |
|
3201 |
|
3202 } |
|
3203 |
|
3204 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3205 - * extent[rank-1]; |
|
3206 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3207 |
|
3208 retarray->offset = 0; |
|
3209 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3210 @@ -285,7 +283,7 @@ |
|
3211 return; |
|
3212 } |
|
3213 else |
|
3214 - retarray->base_addr = xmalloc (alloc_size); |
|
3215 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
3216 |
|
3217 } |
|
3218 else |
|
3219 @@ -430,8 +428,7 @@ |
|
3220 retarray->offset = 0; |
|
3221 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3222 |
|
3223 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3224 - * extent[rank-1]; |
|
3225 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3226 |
|
3227 if (alloc_size == 0) |
|
3228 { |
|
3229 @@ -440,7 +437,7 @@ |
|
3230 return; |
|
3231 } |
|
3232 else |
|
3233 - retarray->base_addr = xmalloc (alloc_size); |
|
3234 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
3235 } |
|
3236 else |
|
3237 { |
|
3238 Index: gcc-4.8_branch/libgfortran/generated/minloc0_16_r16.c |
|
3239 =================================================================== |
|
3240 --- gcc-4.8_branch/libgfortran/generated/minloc0_16_r16.c (revision 213312) |
|
3241 +++ gcc-4.8_branch/libgfortran/generated/minloc0_16_r16.c (revision 213313) |
|
3242 @@ -58,7 +58,7 @@ |
|
3243 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
3244 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
3245 retarray->offset = 0; |
|
3246 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
3247 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
3248 } |
|
3249 else |
|
3250 { |
|
3251 @@ -199,7 +199,7 @@ |
|
3252 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
3253 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
3254 retarray->offset = 0; |
|
3255 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
3256 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
3257 } |
|
3258 else |
|
3259 { |
|
3260 @@ -367,7 +367,7 @@ |
|
3261 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
3262 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
3263 retarray->offset = 0; |
|
3264 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
3265 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
3266 } |
|
3267 else if (unlikely (compile_options.bounds_check)) |
|
3268 { |
|
3269 Index: gcc-4.8_branch/libgfortran/generated/product_i16.c |
|
3270 =================================================================== |
|
3271 --- gcc-4.8_branch/libgfortran/generated/product_i16.c (revision 213312) |
|
3272 +++ gcc-4.8_branch/libgfortran/generated/product_i16.c (revision 213313) |
|
3273 @@ -97,10 +97,9 @@ |
|
3274 retarray->offset = 0; |
|
3275 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3276 |
|
3277 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3278 - * extent[rank-1]; |
|
3279 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3280 |
|
3281 - retarray->base_addr = xmalloc (alloc_size); |
|
3282 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
3283 if (alloc_size == 0) |
|
3284 { |
|
3285 /* Make sure we have a zero-sized array. */ |
|
3286 @@ -272,8 +271,7 @@ |
|
3287 |
|
3288 } |
|
3289 |
|
3290 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3291 - * extent[rank-1]; |
|
3292 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3293 |
|
3294 retarray->offset = 0; |
|
3295 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3296 @@ -285,7 +283,7 @@ |
|
3297 return; |
|
3298 } |
|
3299 else |
|
3300 - retarray->base_addr = xmalloc (alloc_size); |
|
3301 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
3302 |
|
3303 } |
|
3304 else |
|
3305 @@ -430,8 +428,7 @@ |
|
3306 retarray->offset = 0; |
|
3307 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3308 |
|
3309 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3310 - * extent[rank-1]; |
|
3311 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3312 |
|
3313 if (alloc_size == 0) |
|
3314 { |
|
3315 @@ -440,7 +437,7 @@ |
|
3316 return; |
|
3317 } |
|
3318 else |
|
3319 - retarray->base_addr = xmalloc (alloc_size); |
|
3320 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
3321 } |
|
3322 else |
|
3323 { |
|
3324 Index: gcc-4.8_branch/libgfortran/generated/unpack_i1.c |
|
3325 =================================================================== |
|
3326 --- gcc-4.8_branch/libgfortran/generated/unpack_i1.c (revision 213312) |
|
3327 +++ gcc-4.8_branch/libgfortran/generated/unpack_i1.c (revision 213313) |
|
3328 @@ -99,7 +99,7 @@ |
|
3329 rs *= extent[n]; |
|
3330 } |
|
3331 ret->offset = 0; |
|
3332 - ret->base_addr = xmalloc (rs * sizeof (GFC_INTEGER_1)); |
|
3333 + ret->base_addr = xmallocarray (rs, sizeof (GFC_INTEGER_1)); |
|
3334 } |
|
3335 else |
|
3336 { |
|
3337 @@ -244,7 +244,7 @@ |
|
3338 rs *= extent[n]; |
|
3339 } |
|
3340 ret->offset = 0; |
|
3341 - ret->base_addr = xmalloc (rs * sizeof (GFC_INTEGER_1)); |
|
3342 + ret->base_addr = xmallocarray (rs, sizeof (GFC_INTEGER_1)); |
|
3343 } |
|
3344 else |
|
3345 { |
|
3346 Index: gcc-4.8_branch/libgfortran/generated/minloc0_4_i4.c |
|
3347 =================================================================== |
|
3348 --- gcc-4.8_branch/libgfortran/generated/minloc0_4_i4.c (revision 213312) |
|
3349 +++ gcc-4.8_branch/libgfortran/generated/minloc0_4_i4.c (revision 213313) |
|
3350 @@ -58,7 +58,7 @@ |
|
3351 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
3352 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
3353 retarray->offset = 0; |
|
3354 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
3355 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
3356 } |
|
3357 else |
|
3358 { |
|
3359 @@ -199,7 +199,7 @@ |
|
3360 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
3361 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
3362 retarray->offset = 0; |
|
3363 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
3364 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
3365 } |
|
3366 else |
|
3367 { |
|
3368 @@ -367,7 +367,7 @@ |
|
3369 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
3370 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
3371 retarray->offset = 0; |
|
3372 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
3373 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
3374 } |
|
3375 else if (unlikely (compile_options.bounds_check)) |
|
3376 { |
|
3377 Index: gcc-4.8_branch/libgfortran/generated/matmul_i1.c |
|
3378 =================================================================== |
|
3379 --- gcc-4.8_branch/libgfortran/generated/matmul_i1.c (revision 213312) |
|
3380 +++ gcc-4.8_branch/libgfortran/generated/matmul_i1.c (revision 213313) |
|
3381 @@ -124,7 +124,7 @@ |
|
3382 } |
|
3383 |
|
3384 retarray->base_addr |
|
3385 - = xmalloc (sizeof (GFC_INTEGER_1) * size0 ((array_t *) retarray)); |
|
3386 + = xmallocarray (size0 ((array_t *) retarray), sizeof (GFC_INTEGER_1)); |
|
3387 retarray->offset = 0; |
|
3388 } |
|
3389 else if (unlikely (compile_options.bounds_check)) |
|
3390 Index: gcc-4.8_branch/libgfortran/generated/minval_r4.c |
|
3391 =================================================================== |
|
3392 --- gcc-4.8_branch/libgfortran/generated/minval_r4.c (revision 213312) |
|
3393 +++ gcc-4.8_branch/libgfortran/generated/minval_r4.c (revision 213313) |
|
3394 @@ -97,10 +97,9 @@ |
|
3395 retarray->offset = 0; |
|
3396 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3397 |
|
3398 - alloc_size = sizeof (GFC_REAL_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3399 - * extent[rank-1]; |
|
3400 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3401 |
|
3402 - retarray->base_addr = xmalloc (alloc_size); |
|
3403 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_4)); |
|
3404 if (alloc_size == 0) |
|
3405 { |
|
3406 /* Make sure we have a zero-sized array. */ |
|
3407 @@ -286,8 +285,7 @@ |
|
3408 |
|
3409 } |
|
3410 |
|
3411 - alloc_size = sizeof (GFC_REAL_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3412 - * extent[rank-1]; |
|
3413 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3414 |
|
3415 retarray->offset = 0; |
|
3416 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3417 @@ -299,7 +297,7 @@ |
|
3418 return; |
|
3419 } |
|
3420 else |
|
3421 - retarray->base_addr = xmalloc (alloc_size); |
|
3422 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_4)); |
|
3423 |
|
3424 } |
|
3425 else |
|
3426 @@ -472,8 +470,7 @@ |
|
3427 retarray->offset = 0; |
|
3428 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3429 |
|
3430 - alloc_size = sizeof (GFC_REAL_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3431 - * extent[rank-1]; |
|
3432 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3433 |
|
3434 if (alloc_size == 0) |
|
3435 { |
|
3436 @@ -482,7 +479,7 @@ |
|
3437 return; |
|
3438 } |
|
3439 else |
|
3440 - retarray->base_addr = xmalloc (alloc_size); |
|
3441 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_4)); |
|
3442 } |
|
3443 else |
|
3444 { |
|
3445 Index: gcc-4.8_branch/libgfortran/generated/spread_i16.c |
|
3446 =================================================================== |
|
3447 --- gcc-4.8_branch/libgfortran/generated/spread_i16.c (revision 213312) |
|
3448 +++ gcc-4.8_branch/libgfortran/generated/spread_i16.c (revision 213313) |
|
3449 @@ -101,8 +101,8 @@ |
|
3450 } |
|
3451 ret->offset = 0; |
|
3452 |
|
3453 - /* xmalloc allocates a single byte for zero size. */ |
|
3454 - ret->base_addr = xmalloc (rs * sizeof(GFC_INTEGER_16)); |
|
3455 + /* xmallocarray allocates a single byte for zero size. */ |
|
3456 + ret->base_addr = xmallocarray (rs, sizeof(GFC_INTEGER_16)); |
|
3457 if (rs <= 0) |
|
3458 return; |
|
3459 } |
|
3460 @@ -244,7 +244,7 @@ |
|
3461 |
|
3462 if (ret->base_addr == NULL) |
|
3463 { |
|
3464 - ret->base_addr = xmalloc (ncopies * sizeof (GFC_INTEGER_16)); |
|
3465 + ret->base_addr = xmallocarray (ncopies, sizeof (GFC_INTEGER_16)); |
|
3466 ret->offset = 0; |
|
3467 GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1); |
|
3468 } |
|
3469 Index: gcc-4.8_branch/libgfortran/generated/sum_i4.c |
|
3470 =================================================================== |
|
3471 --- gcc-4.8_branch/libgfortran/generated/sum_i4.c (revision 213312) |
|
3472 +++ gcc-4.8_branch/libgfortran/generated/sum_i4.c (revision 213313) |
|
3473 @@ -97,10 +97,9 @@ |
|
3474 retarray->offset = 0; |
|
3475 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3476 |
|
3477 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3478 - * extent[rank-1]; |
|
3479 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3480 |
|
3481 - retarray->base_addr = xmalloc (alloc_size); |
|
3482 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
3483 if (alloc_size == 0) |
|
3484 { |
|
3485 /* Make sure we have a zero-sized array. */ |
|
3486 @@ -272,8 +271,7 @@ |
|
3487 |
|
3488 } |
|
3489 |
|
3490 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3491 - * extent[rank-1]; |
|
3492 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3493 |
|
3494 retarray->offset = 0; |
|
3495 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3496 @@ -285,7 +283,7 @@ |
|
3497 return; |
|
3498 } |
|
3499 else |
|
3500 - retarray->base_addr = xmalloc (alloc_size); |
|
3501 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
3502 |
|
3503 } |
|
3504 else |
|
3505 @@ -430,8 +428,7 @@ |
|
3506 retarray->offset = 0; |
|
3507 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3508 |
|
3509 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3510 - * extent[rank-1]; |
|
3511 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3512 |
|
3513 if (alloc_size == 0) |
|
3514 { |
|
3515 @@ -440,7 +437,7 @@ |
|
3516 return; |
|
3517 } |
|
3518 else |
|
3519 - retarray->base_addr = xmalloc (alloc_size); |
|
3520 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
3521 } |
|
3522 else |
|
3523 { |
|
3524 Index: gcc-4.8_branch/libgfortran/generated/unpack_r10.c |
|
3525 =================================================================== |
|
3526 --- gcc-4.8_branch/libgfortran/generated/unpack_r10.c (revision 213312) |
|
3527 +++ gcc-4.8_branch/libgfortran/generated/unpack_r10.c (revision 213313) |
|
3528 @@ -99,7 +99,7 @@ |
|
3529 rs *= extent[n]; |
|
3530 } |
|
3531 ret->offset = 0; |
|
3532 - ret->base_addr = xmalloc (rs * sizeof (GFC_REAL_10)); |
|
3533 + ret->base_addr = xmallocarray (rs, sizeof (GFC_REAL_10)); |
|
3534 } |
|
3535 else |
|
3536 { |
|
3537 @@ -244,7 +244,7 @@ |
|
3538 rs *= extent[n]; |
|
3539 } |
|
3540 ret->offset = 0; |
|
3541 - ret->base_addr = xmalloc (rs * sizeof (GFC_REAL_10)); |
|
3542 + ret->base_addr = xmallocarray (rs, sizeof (GFC_REAL_10)); |
|
3543 } |
|
3544 else |
|
3545 { |
|
3546 Index: gcc-4.8_branch/libgfortran/generated/bessel_r16.c |
|
3547 =================================================================== |
|
3548 --- gcc-4.8_branch/libgfortran/generated/bessel_r16.c (revision 213312) |
|
3549 +++ gcc-4.8_branch/libgfortran/generated/bessel_r16.c (revision 213313) |
|
3550 @@ -59,7 +59,7 @@ |
|
3551 { |
|
3552 size_t size = n2 < n1 ? 0 : n2-n1+1; |
|
3553 GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1); |
|
3554 - ret->base_addr = xmalloc (sizeof (GFC_REAL_16) * size); |
|
3555 + ret->base_addr = xmallocarray (size, sizeof (GFC_REAL_16)); |
|
3556 ret->offset = 0; |
|
3557 } |
|
3558 |
|
3559 @@ -126,7 +126,7 @@ |
|
3560 { |
|
3561 size_t size = n2 < n1 ? 0 : n2-n1+1; |
|
3562 GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1); |
|
3563 - ret->base_addr = xmalloc (sizeof (GFC_REAL_16) * size); |
|
3564 + ret->base_addr = xmallocarray (size, sizeof (GFC_REAL_16)); |
|
3565 ret->offset = 0; |
|
3566 } |
|
3567 |
|
3568 Index: gcc-4.8_branch/libgfortran/generated/norm2_r8.c |
|
3569 =================================================================== |
|
3570 --- gcc-4.8_branch/libgfortran/generated/norm2_r8.c (revision 213312) |
|
3571 +++ gcc-4.8_branch/libgfortran/generated/norm2_r8.c (revision 213313) |
|
3572 @@ -101,10 +101,9 @@ |
|
3573 retarray->offset = 0; |
|
3574 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3575 |
|
3576 - alloc_size = sizeof (GFC_REAL_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3577 - * extent[rank-1]; |
|
3578 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3579 |
|
3580 - retarray->base_addr = xmalloc (alloc_size); |
|
3581 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_8)); |
|
3582 if (alloc_size == 0) |
|
3583 { |
|
3584 /* Make sure we have a zero-sized array. */ |
|
3585 Index: gcc-4.8_branch/libgfortran/generated/spread_i4.c |
|
3586 =================================================================== |
|
3587 --- gcc-4.8_branch/libgfortran/generated/spread_i4.c (revision 213312) |
|
3588 +++ gcc-4.8_branch/libgfortran/generated/spread_i4.c (revision 213313) |
|
3589 @@ -101,8 +101,8 @@ |
|
3590 } |
|
3591 ret->offset = 0; |
|
3592 |
|
3593 - /* xmalloc allocates a single byte for zero size. */ |
|
3594 - ret->base_addr = xmalloc (rs * sizeof(GFC_INTEGER_4)); |
|
3595 + /* xmallocarray allocates a single byte for zero size. */ |
|
3596 + ret->base_addr = xmallocarray (rs, sizeof(GFC_INTEGER_4)); |
|
3597 if (rs <= 0) |
|
3598 return; |
|
3599 } |
|
3600 @@ -244,7 +244,7 @@ |
|
3601 |
|
3602 if (ret->base_addr == NULL) |
|
3603 { |
|
3604 - ret->base_addr = xmalloc (ncopies * sizeof (GFC_INTEGER_4)); |
|
3605 + ret->base_addr = xmallocarray (ncopies, sizeof (GFC_INTEGER_4)); |
|
3606 ret->offset = 0; |
|
3607 GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1); |
|
3608 } |
|
3609 Index: gcc-4.8_branch/libgfortran/generated/eoshift3_8.c |
|
3610 =================================================================== |
|
3611 --- gcc-4.8_branch/libgfortran/generated/eoshift3_8.c (revision 213312) |
|
3612 +++ gcc-4.8_branch/libgfortran/generated/eoshift3_8.c (revision 213313) |
|
3613 @@ -89,7 +89,7 @@ |
|
3614 { |
|
3615 int i; |
|
3616 |
|
3617 - ret->base_addr = xmalloc (size * arraysize); |
|
3618 + ret->base_addr = xmallocarray (arraysize, size); |
|
3619 ret->offset = 0; |
|
3620 ret->dtype = array->dtype; |
|
3621 for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++) |
|
3622 @@ -107,8 +107,8 @@ |
|
3623 GFC_DIMENSION_SET(ret->dim[i], 0, ub, str); |
|
3624 |
|
3625 } |
|
3626 - /* xmalloc allocates a single byte for zero size. */ |
|
3627 - ret->base_addr = xmalloc (size * arraysize); |
|
3628 + /* xmallocarray allocates a single byte for zero size. */ |
|
3629 + ret->base_addr = xmallocarray (arraysize, size); |
|
3630 |
|
3631 } |
|
3632 else if (unlikely (compile_options.bounds_check)) |
|
3633 Index: gcc-4.8_branch/libgfortran/generated/minloc1_4_i1.c |
|
3634 =================================================================== |
|
3635 --- gcc-4.8_branch/libgfortran/generated/minloc1_4_i1.c (revision 213312) |
|
3636 +++ gcc-4.8_branch/libgfortran/generated/minloc1_4_i1.c (revision 213313) |
|
3637 @@ -98,10 +98,9 @@ |
|
3638 retarray->offset = 0; |
|
3639 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3640 |
|
3641 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3642 - * extent[rank-1]; |
|
3643 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3644 |
|
3645 - retarray->base_addr = xmalloc (alloc_size); |
|
3646 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
3647 if (alloc_size == 0) |
|
3648 { |
|
3649 /* Make sure we have a zero-sized array. */ |
|
3650 @@ -294,8 +293,7 @@ |
|
3651 |
|
3652 } |
|
3653 |
|
3654 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3655 - * extent[rank-1]; |
|
3656 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3657 |
|
3658 retarray->offset = 0; |
|
3659 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3660 @@ -307,7 +305,7 @@ |
|
3661 return; |
|
3662 } |
|
3663 else |
|
3664 - retarray->base_addr = xmalloc (alloc_size); |
|
3665 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
3666 |
|
3667 } |
|
3668 else |
|
3669 @@ -485,8 +483,7 @@ |
|
3670 retarray->offset = 0; |
|
3671 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3672 |
|
3673 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3674 - * extent[rank-1]; |
|
3675 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3676 |
|
3677 if (alloc_size == 0) |
|
3678 { |
|
3679 @@ -495,7 +492,7 @@ |
|
3680 return; |
|
3681 } |
|
3682 else |
|
3683 - retarray->base_addr = xmalloc (alloc_size); |
|
3684 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
3685 } |
|
3686 else |
|
3687 { |
|
3688 Index: gcc-4.8_branch/libgfortran/generated/minval_i2.c |
|
3689 =================================================================== |
|
3690 --- gcc-4.8_branch/libgfortran/generated/minval_i2.c (revision 213312) |
|
3691 +++ gcc-4.8_branch/libgfortran/generated/minval_i2.c (revision 213313) |
|
3692 @@ -97,10 +97,9 @@ |
|
3693 retarray->offset = 0; |
|
3694 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3695 |
|
3696 - alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3697 - * extent[rank-1]; |
|
3698 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3699 |
|
3700 - retarray->base_addr = xmalloc (alloc_size); |
|
3701 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); |
|
3702 if (alloc_size == 0) |
|
3703 { |
|
3704 /* Make sure we have a zero-sized array. */ |
|
3705 @@ -286,8 +285,7 @@ |
|
3706 |
|
3707 } |
|
3708 |
|
3709 - alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3710 - * extent[rank-1]; |
|
3711 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3712 |
|
3713 retarray->offset = 0; |
|
3714 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3715 @@ -299,7 +297,7 @@ |
|
3716 return; |
|
3717 } |
|
3718 else |
|
3719 - retarray->base_addr = xmalloc (alloc_size); |
|
3720 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); |
|
3721 |
|
3722 } |
|
3723 else |
|
3724 @@ -472,8 +470,7 @@ |
|
3725 retarray->offset = 0; |
|
3726 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3727 |
|
3728 - alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3729 - * extent[rank-1]; |
|
3730 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3731 |
|
3732 if (alloc_size == 0) |
|
3733 { |
|
3734 @@ -482,7 +479,7 @@ |
|
3735 return; |
|
3736 } |
|
3737 else |
|
3738 - retarray->base_addr = xmalloc (alloc_size); |
|
3739 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); |
|
3740 } |
|
3741 else |
|
3742 { |
|
3743 Index: gcc-4.8_branch/libgfortran/generated/bessel_r8.c |
|
3744 =================================================================== |
|
3745 --- gcc-4.8_branch/libgfortran/generated/bessel_r8.c (revision 213312) |
|
3746 +++ gcc-4.8_branch/libgfortran/generated/bessel_r8.c (revision 213313) |
|
3747 @@ -55,7 +55,7 @@ |
|
3748 { |
|
3749 size_t size = n2 < n1 ? 0 : n2-n1+1; |
|
3750 GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1); |
|
3751 - ret->base_addr = xmalloc (sizeof (GFC_REAL_8) * size); |
|
3752 + ret->base_addr = xmallocarray (size, sizeof (GFC_REAL_8)); |
|
3753 ret->offset = 0; |
|
3754 } |
|
3755 |
|
3756 @@ -122,7 +122,7 @@ |
|
3757 { |
|
3758 size_t size = n2 < n1 ? 0 : n2-n1+1; |
|
3759 GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1); |
|
3760 - ret->base_addr = xmalloc (sizeof (GFC_REAL_8) * size); |
|
3761 + ret->base_addr = xmallocarray (size, sizeof (GFC_REAL_8)); |
|
3762 ret->offset = 0; |
|
3763 } |
|
3764 |
|
3765 Index: gcc-4.8_branch/libgfortran/generated/unpack_r4.c |
|
3766 =================================================================== |
|
3767 --- gcc-4.8_branch/libgfortran/generated/unpack_r4.c (revision 213312) |
|
3768 +++ gcc-4.8_branch/libgfortran/generated/unpack_r4.c (revision 213313) |
|
3769 @@ -99,7 +99,7 @@ |
|
3770 rs *= extent[n]; |
|
3771 } |
|
3772 ret->offset = 0; |
|
3773 - ret->base_addr = xmalloc (rs * sizeof (GFC_REAL_4)); |
|
3774 + ret->base_addr = xmallocarray (rs, sizeof (GFC_REAL_4)); |
|
3775 } |
|
3776 else |
|
3777 { |
|
3778 @@ -244,7 +244,7 @@ |
|
3779 rs *= extent[n]; |
|
3780 } |
|
3781 ret->offset = 0; |
|
3782 - ret->base_addr = xmalloc (rs * sizeof (GFC_REAL_4)); |
|
3783 + ret->base_addr = xmallocarray (rs, sizeof (GFC_REAL_4)); |
|
3784 } |
|
3785 else |
|
3786 { |
|
3787 Index: gcc-4.8_branch/libgfortran/generated/product_r8.c |
|
3788 =================================================================== |
|
3789 --- gcc-4.8_branch/libgfortran/generated/product_r8.c (revision 213312) |
|
3790 +++ gcc-4.8_branch/libgfortran/generated/product_r8.c (revision 213313) |
|
3791 @@ -97,10 +97,9 @@ |
|
3792 retarray->offset = 0; |
|
3793 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3794 |
|
3795 - alloc_size = sizeof (GFC_REAL_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3796 - * extent[rank-1]; |
|
3797 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3798 |
|
3799 - retarray->base_addr = xmalloc (alloc_size); |
|
3800 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_8)); |
|
3801 if (alloc_size == 0) |
|
3802 { |
|
3803 /* Make sure we have a zero-sized array. */ |
|
3804 @@ -272,8 +271,7 @@ |
|
3805 |
|
3806 } |
|
3807 |
|
3808 - alloc_size = sizeof (GFC_REAL_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3809 - * extent[rank-1]; |
|
3810 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3811 |
|
3812 retarray->offset = 0; |
|
3813 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3814 @@ -285,7 +283,7 @@ |
|
3815 return; |
|
3816 } |
|
3817 else |
|
3818 - retarray->base_addr = xmalloc (alloc_size); |
|
3819 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_8)); |
|
3820 |
|
3821 } |
|
3822 else |
|
3823 @@ -430,8 +428,7 @@ |
|
3824 retarray->offset = 0; |
|
3825 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3826 |
|
3827 - alloc_size = sizeof (GFC_REAL_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3828 - * extent[rank-1]; |
|
3829 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3830 |
|
3831 if (alloc_size == 0) |
|
3832 { |
|
3833 @@ -440,7 +437,7 @@ |
|
3834 return; |
|
3835 } |
|
3836 else |
|
3837 - retarray->base_addr = xmalloc (alloc_size); |
|
3838 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_8)); |
|
3839 } |
|
3840 else |
|
3841 { |
|
3842 Index: gcc-4.8_branch/libgfortran/generated/matmul_r4.c |
|
3843 =================================================================== |
|
3844 --- gcc-4.8_branch/libgfortran/generated/matmul_r4.c (revision 213312) |
|
3845 +++ gcc-4.8_branch/libgfortran/generated/matmul_r4.c (revision 213313) |
|
3846 @@ -124,7 +124,7 @@ |
|
3847 } |
|
3848 |
|
3849 retarray->base_addr |
|
3850 - = xmalloc (sizeof (GFC_REAL_4) * size0 ((array_t *) retarray)); |
|
3851 + = xmallocarray (size0 ((array_t *) retarray), sizeof (GFC_REAL_4)); |
|
3852 retarray->offset = 0; |
|
3853 } |
|
3854 else if (unlikely (compile_options.bounds_check)) |
|
3855 Index: gcc-4.8_branch/libgfortran/generated/unpack_i2.c |
|
3856 =================================================================== |
|
3857 --- gcc-4.8_branch/libgfortran/generated/unpack_i2.c (revision 213312) |
|
3858 +++ gcc-4.8_branch/libgfortran/generated/unpack_i2.c (revision 213313) |
|
3859 @@ -99,7 +99,7 @@ |
|
3860 rs *= extent[n]; |
|
3861 } |
|
3862 ret->offset = 0; |
|
3863 - ret->base_addr = xmalloc (rs * sizeof (GFC_INTEGER_2)); |
|
3864 + ret->base_addr = xmallocarray (rs, sizeof (GFC_INTEGER_2)); |
|
3865 } |
|
3866 else |
|
3867 { |
|
3868 @@ -244,7 +244,7 @@ |
|
3869 rs *= extent[n]; |
|
3870 } |
|
3871 ret->offset = 0; |
|
3872 - ret->base_addr = xmalloc (rs * sizeof (GFC_INTEGER_2)); |
|
3873 + ret->base_addr = xmallocarray (rs, sizeof (GFC_INTEGER_2)); |
|
3874 } |
|
3875 else |
|
3876 { |
|
3877 Index: gcc-4.8_branch/libgfortran/generated/in_pack_r8.c |
|
3878 =================================================================== |
|
3879 --- gcc-4.8_branch/libgfortran/generated/in_pack_r8.c (revision 213312) |
|
3880 +++ gcc-4.8_branch/libgfortran/generated/in_pack_r8.c (revision 213313) |
|
3881 @@ -76,7 +76,7 @@ |
|
3882 return source->base_addr; |
|
3883 |
|
3884 /* Allocate storage for the destination. */ |
|
3885 - destptr = (GFC_REAL_8 *)xmalloc (ssize * sizeof (GFC_REAL_8)); |
|
3886 + destptr = xmallocarray (ssize, sizeof (GFC_REAL_8)); |
|
3887 dest = destptr; |
|
3888 src = source->base_addr; |
|
3889 stride0 = stride[0]; |
|
3890 Index: gcc-4.8_branch/libgfortran/generated/maxloc1_4_r16.c |
|
3891 =================================================================== |
|
3892 --- gcc-4.8_branch/libgfortran/generated/maxloc1_4_r16.c (revision 213312) |
|
3893 +++ gcc-4.8_branch/libgfortran/generated/maxloc1_4_r16.c (revision 213313) |
|
3894 @@ -98,10 +98,9 @@ |
|
3895 retarray->offset = 0; |
|
3896 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3897 |
|
3898 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3899 - * extent[rank-1]; |
|
3900 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3901 |
|
3902 - retarray->base_addr = xmalloc (alloc_size); |
|
3903 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
3904 if (alloc_size == 0) |
|
3905 { |
|
3906 /* Make sure we have a zero-sized array. */ |
|
3907 @@ -294,8 +293,7 @@ |
|
3908 |
|
3909 } |
|
3910 |
|
3911 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3912 - * extent[rank-1]; |
|
3913 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3914 |
|
3915 retarray->offset = 0; |
|
3916 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3917 @@ -307,7 +305,7 @@ |
|
3918 return; |
|
3919 } |
|
3920 else |
|
3921 - retarray->base_addr = xmalloc (alloc_size); |
|
3922 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
3923 |
|
3924 } |
|
3925 else |
|
3926 @@ -485,8 +483,7 @@ |
|
3927 retarray->offset = 0; |
|
3928 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
3929 |
|
3930 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
3931 - * extent[rank-1]; |
|
3932 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
3933 |
|
3934 if (alloc_size == 0) |
|
3935 { |
|
3936 @@ -495,7 +492,7 @@ |
|
3937 return; |
|
3938 } |
|
3939 else |
|
3940 - retarray->base_addr = xmalloc (alloc_size); |
|
3941 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
3942 } |
|
3943 else |
|
3944 { |
|
3945 Index: gcc-4.8_branch/libgfortran/generated/minloc0_8_r16.c |
|
3946 =================================================================== |
|
3947 --- gcc-4.8_branch/libgfortran/generated/minloc0_8_r16.c (revision 213312) |
|
3948 +++ gcc-4.8_branch/libgfortran/generated/minloc0_8_r16.c (revision 213313) |
|
3949 @@ -58,7 +58,7 @@ |
|
3950 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
3951 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
3952 retarray->offset = 0; |
|
3953 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
3954 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
3955 } |
|
3956 else |
|
3957 { |
|
3958 @@ -199,7 +199,7 @@ |
|
3959 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
3960 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
3961 retarray->offset = 0; |
|
3962 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
3963 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
3964 } |
|
3965 else |
|
3966 { |
|
3967 @@ -367,7 +367,7 @@ |
|
3968 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
3969 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
3970 retarray->offset = 0; |
|
3971 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
3972 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
3973 } |
|
3974 else if (unlikely (compile_options.bounds_check)) |
|
3975 { |
|
3976 Index: gcc-4.8_branch/libgfortran/generated/reshape_c8.c |
|
3977 =================================================================== |
|
3978 --- gcc-4.8_branch/libgfortran/generated/reshape_c8.c (revision 213312) |
|
3979 +++ gcc-4.8_branch/libgfortran/generated/reshape_c8.c (revision 213313) |
|
3980 @@ -111,11 +111,11 @@ |
|
3981 ret->offset = 0; |
|
3982 |
|
3983 if (unlikely (rs < 1)) |
|
3984 - alloc_size = 1; |
|
3985 + alloc_size = 0; |
|
3986 else |
|
3987 - alloc_size = rs * sizeof (GFC_COMPLEX_8); |
|
3988 + alloc_size = rs; |
|
3989 |
|
3990 - ret->base_addr = xmalloc (alloc_size); |
|
3991 + ret->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_8)); |
|
3992 ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim; |
|
3993 } |
|
3994 |
|
3995 Index: gcc-4.8_branch/libgfortran/generated/iparity_i8.c |
|
3996 =================================================================== |
|
3997 --- gcc-4.8_branch/libgfortran/generated/iparity_i8.c (revision 213312) |
|
3998 +++ gcc-4.8_branch/libgfortran/generated/iparity_i8.c (revision 213313) |
|
3999 @@ -97,10 +97,9 @@ |
|
4000 retarray->offset = 0; |
|
4001 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4002 |
|
4003 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4004 - * extent[rank-1]; |
|
4005 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4006 |
|
4007 - retarray->base_addr = xmalloc (alloc_size); |
|
4008 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
4009 if (alloc_size == 0) |
|
4010 { |
|
4011 /* Make sure we have a zero-sized array. */ |
|
4012 @@ -272,8 +271,7 @@ |
|
4013 |
|
4014 } |
|
4015 |
|
4016 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4017 - * extent[rank-1]; |
|
4018 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4019 |
|
4020 retarray->offset = 0; |
|
4021 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4022 @@ -285,7 +283,7 @@ |
|
4023 return; |
|
4024 } |
|
4025 else |
|
4026 - retarray->base_addr = xmalloc (alloc_size); |
|
4027 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
4028 |
|
4029 } |
|
4030 else |
|
4031 @@ -430,8 +428,7 @@ |
|
4032 retarray->offset = 0; |
|
4033 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4034 |
|
4035 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4036 - * extent[rank-1]; |
|
4037 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4038 |
|
4039 if (alloc_size == 0) |
|
4040 { |
|
4041 @@ -440,7 +437,7 @@ |
|
4042 return; |
|
4043 } |
|
4044 else |
|
4045 - retarray->base_addr = xmalloc (alloc_size); |
|
4046 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
4047 } |
|
4048 else |
|
4049 { |
|
4050 Index: gcc-4.8_branch/libgfortran/generated/count_1_l.c |
|
4051 =================================================================== |
|
4052 --- gcc-4.8_branch/libgfortran/generated/count_1_l.c (revision 213312) |
|
4053 +++ gcc-4.8_branch/libgfortran/generated/count_1_l.c (revision 213313) |
|
4054 @@ -101,8 +101,7 @@ |
|
4055 retarray->offset = 0; |
|
4056 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4057 |
|
4058 - alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4059 - * extent[rank-1]; |
|
4060 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4061 |
|
4062 if (alloc_size == 0) |
|
4063 { |
|
4064 @@ -111,7 +110,7 @@ |
|
4065 return; |
|
4066 } |
|
4067 else |
|
4068 - retarray->base_addr = xmalloc (alloc_size); |
|
4069 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); |
|
4070 } |
|
4071 else |
|
4072 { |
|
4073 Index: gcc-4.8_branch/libgfortran/generated/maxloc0_8_i4.c |
|
4074 =================================================================== |
|
4075 --- gcc-4.8_branch/libgfortran/generated/maxloc0_8_i4.c (revision 213312) |
|
4076 +++ gcc-4.8_branch/libgfortran/generated/maxloc0_8_i4.c (revision 213313) |
|
4077 @@ -58,7 +58,7 @@ |
|
4078 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
4079 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
4080 retarray->offset = 0; |
|
4081 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
4082 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
4083 } |
|
4084 else |
|
4085 { |
|
4086 @@ -199,7 +199,7 @@ |
|
4087 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
4088 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
4089 retarray->offset = 0; |
|
4090 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
4091 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
4092 } |
|
4093 else |
|
4094 { |
|
4095 @@ -367,7 +367,7 @@ |
|
4096 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
4097 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
4098 retarray->offset = 0; |
|
4099 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
4100 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
4101 } |
|
4102 else if (unlikely (compile_options.bounds_check)) |
|
4103 { |
|
4104 Index: gcc-4.8_branch/libgfortran/generated/matmul_i2.c |
|
4105 =================================================================== |
|
4106 --- gcc-4.8_branch/libgfortran/generated/matmul_i2.c (revision 213312) |
|
4107 +++ gcc-4.8_branch/libgfortran/generated/matmul_i2.c (revision 213313) |
|
4108 @@ -124,7 +124,7 @@ |
|
4109 } |
|
4110 |
|
4111 retarray->base_addr |
|
4112 - = xmalloc (sizeof (GFC_INTEGER_2) * size0 ((array_t *) retarray)); |
|
4113 + = xmallocarray (size0 ((array_t *) retarray), sizeof (GFC_INTEGER_2)); |
|
4114 retarray->offset = 0; |
|
4115 } |
|
4116 else if (unlikely (compile_options.bounds_check)) |
|
4117 Index: gcc-4.8_branch/libgfortran/generated/minloc1_4_r4.c |
|
4118 =================================================================== |
|
4119 --- gcc-4.8_branch/libgfortran/generated/minloc1_4_r4.c (revision 213312) |
|
4120 +++ gcc-4.8_branch/libgfortran/generated/minloc1_4_r4.c (revision 213313) |
|
4121 @@ -98,10 +98,9 @@ |
|
4122 retarray->offset = 0; |
|
4123 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4124 |
|
4125 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4126 - * extent[rank-1]; |
|
4127 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4128 |
|
4129 - retarray->base_addr = xmalloc (alloc_size); |
|
4130 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
4131 if (alloc_size == 0) |
|
4132 { |
|
4133 /* Make sure we have a zero-sized array. */ |
|
4134 @@ -294,8 +293,7 @@ |
|
4135 |
|
4136 } |
|
4137 |
|
4138 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4139 - * extent[rank-1]; |
|
4140 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4141 |
|
4142 retarray->offset = 0; |
|
4143 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4144 @@ -307,7 +305,7 @@ |
|
4145 return; |
|
4146 } |
|
4147 else |
|
4148 - retarray->base_addr = xmalloc (alloc_size); |
|
4149 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
4150 |
|
4151 } |
|
4152 else |
|
4153 @@ -485,8 +483,7 @@ |
|
4154 retarray->offset = 0; |
|
4155 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4156 |
|
4157 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4158 - * extent[rank-1]; |
|
4159 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4160 |
|
4161 if (alloc_size == 0) |
|
4162 { |
|
4163 @@ -495,7 +492,7 @@ |
|
4164 return; |
|
4165 } |
|
4166 else |
|
4167 - retarray->base_addr = xmalloc (alloc_size); |
|
4168 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
4169 } |
|
4170 else |
|
4171 { |
|
4172 Index: gcc-4.8_branch/libgfortran/generated/transpose_i16.c |
|
4173 =================================================================== |
|
4174 --- gcc-4.8_branch/libgfortran/generated/transpose_i16.c (revision 213312) |
|
4175 +++ gcc-4.8_branch/libgfortran/generated/transpose_i16.c (revision 213313) |
|
4176 @@ -60,7 +60,8 @@ |
|
4177 GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0) - 1, |
|
4178 GFC_DESCRIPTOR_EXTENT(source, 1)); |
|
4179 |
|
4180 - ret->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * size0 ((array_t *) ret)); |
|
4181 + ret->base_addr = xmallocarray (size0 ((array_t *) ret), |
|
4182 + sizeof (GFC_INTEGER_16)); |
|
4183 ret->offset = 0; |
|
4184 } else if (unlikely (compile_options.bounds_check)) |
|
4185 { |
|
4186 Index: gcc-4.8_branch/libgfortran/generated/minloc0_16_i4.c |
|
4187 =================================================================== |
|
4188 --- gcc-4.8_branch/libgfortran/generated/minloc0_16_i4.c (revision 213312) |
|
4189 +++ gcc-4.8_branch/libgfortran/generated/minloc0_16_i4.c (revision 213313) |
|
4190 @@ -58,7 +58,7 @@ |
|
4191 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
4192 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
4193 retarray->offset = 0; |
|
4194 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
4195 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
4196 } |
|
4197 else |
|
4198 { |
|
4199 @@ -199,7 +199,7 @@ |
|
4200 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
4201 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
4202 retarray->offset = 0; |
|
4203 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
4204 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
4205 } |
|
4206 else |
|
4207 { |
|
4208 @@ -367,7 +367,7 @@ |
|
4209 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
4210 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
4211 retarray->offset = 0; |
|
4212 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
4213 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
4214 } |
|
4215 else if (unlikely (compile_options.bounds_check)) |
|
4216 { |
|
4217 Index: gcc-4.8_branch/libgfortran/generated/transpose_i4.c |
|
4218 =================================================================== |
|
4219 --- gcc-4.8_branch/libgfortran/generated/transpose_i4.c (revision 213312) |
|
4220 +++ gcc-4.8_branch/libgfortran/generated/transpose_i4.c (revision 213313) |
|
4221 @@ -60,7 +60,8 @@ |
|
4222 GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0) - 1, |
|
4223 GFC_DESCRIPTOR_EXTENT(source, 1)); |
|
4224 |
|
4225 - ret->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * size0 ((array_t *) ret)); |
|
4226 + ret->base_addr = xmallocarray (size0 ((array_t *) ret), |
|
4227 + sizeof (GFC_INTEGER_4)); |
|
4228 ret->offset = 0; |
|
4229 } else if (unlikely (compile_options.bounds_check)) |
|
4230 { |
|
4231 Index: gcc-4.8_branch/libgfortran/generated/maxloc1_16_i8.c |
|
4232 =================================================================== |
|
4233 --- gcc-4.8_branch/libgfortran/generated/maxloc1_16_i8.c (revision 213312) |
|
4234 +++ gcc-4.8_branch/libgfortran/generated/maxloc1_16_i8.c (revision 213313) |
|
4235 @@ -98,10 +98,9 @@ |
|
4236 retarray->offset = 0; |
|
4237 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4238 |
|
4239 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4240 - * extent[rank-1]; |
|
4241 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4242 |
|
4243 - retarray->base_addr = xmalloc (alloc_size); |
|
4244 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
4245 if (alloc_size == 0) |
|
4246 { |
|
4247 /* Make sure we have a zero-sized array. */ |
|
4248 @@ -294,8 +293,7 @@ |
|
4249 |
|
4250 } |
|
4251 |
|
4252 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4253 - * extent[rank-1]; |
|
4254 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4255 |
|
4256 retarray->offset = 0; |
|
4257 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4258 @@ -307,7 +305,7 @@ |
|
4259 return; |
|
4260 } |
|
4261 else |
|
4262 - retarray->base_addr = xmalloc (alloc_size); |
|
4263 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
4264 |
|
4265 } |
|
4266 else |
|
4267 @@ -485,8 +483,7 @@ |
|
4268 retarray->offset = 0; |
|
4269 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4270 |
|
4271 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4272 - * extent[rank-1]; |
|
4273 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4274 |
|
4275 if (alloc_size == 0) |
|
4276 { |
|
4277 @@ -495,7 +492,7 @@ |
|
4278 return; |
|
4279 } |
|
4280 else |
|
4281 - retarray->base_addr = xmalloc (alloc_size); |
|
4282 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
4283 } |
|
4284 else |
|
4285 { |
|
4286 Index: gcc-4.8_branch/libgfortran/generated/minloc1_4_i2.c |
|
4287 =================================================================== |
|
4288 --- gcc-4.8_branch/libgfortran/generated/minloc1_4_i2.c (revision 213312) |
|
4289 +++ gcc-4.8_branch/libgfortran/generated/minloc1_4_i2.c (revision 213313) |
|
4290 @@ -98,10 +98,9 @@ |
|
4291 retarray->offset = 0; |
|
4292 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4293 |
|
4294 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4295 - * extent[rank-1]; |
|
4296 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4297 |
|
4298 - retarray->base_addr = xmalloc (alloc_size); |
|
4299 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
4300 if (alloc_size == 0) |
|
4301 { |
|
4302 /* Make sure we have a zero-sized array. */ |
|
4303 @@ -294,8 +293,7 @@ |
|
4304 |
|
4305 } |
|
4306 |
|
4307 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4308 - * extent[rank-1]; |
|
4309 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4310 |
|
4311 retarray->offset = 0; |
|
4312 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4313 @@ -307,7 +305,7 @@ |
|
4314 return; |
|
4315 } |
|
4316 else |
|
4317 - retarray->base_addr = xmalloc (alloc_size); |
|
4318 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
4319 |
|
4320 } |
|
4321 else |
|
4322 @@ -485,8 +483,7 @@ |
|
4323 retarray->offset = 0; |
|
4324 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4325 |
|
4326 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4327 - * extent[rank-1]; |
|
4328 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4329 |
|
4330 if (alloc_size == 0) |
|
4331 { |
|
4332 @@ -495,7 +492,7 @@ |
|
4333 return; |
|
4334 } |
|
4335 else |
|
4336 - retarray->base_addr = xmalloc (alloc_size); |
|
4337 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
4338 } |
|
4339 else |
|
4340 { |
|
4341 Index: gcc-4.8_branch/libgfortran/generated/matmul_l16.c |
|
4342 =================================================================== |
|
4343 --- gcc-4.8_branch/libgfortran/generated/matmul_l16.c (revision 213312) |
|
4344 +++ gcc-4.8_branch/libgfortran/generated/matmul_l16.c (revision 213313) |
|
4345 @@ -88,7 +88,7 @@ |
|
4346 } |
|
4347 |
|
4348 retarray->base_addr |
|
4349 - = xmalloc (sizeof (GFC_LOGICAL_16) * size0 ((array_t *) retarray)); |
|
4350 + = xmallocarray (size0 ((array_t *) retarray), sizeof (GFC_LOGICAL_16)); |
|
4351 retarray->offset = 0; |
|
4352 } |
|
4353 else if (unlikely (compile_options.bounds_check)) |
|
4354 Index: gcc-4.8_branch/libgfortran/generated/maxloc1_8_i1.c |
|
4355 =================================================================== |
|
4356 --- gcc-4.8_branch/libgfortran/generated/maxloc1_8_i1.c (revision 213312) |
|
4357 +++ gcc-4.8_branch/libgfortran/generated/maxloc1_8_i1.c (revision 213313) |
|
4358 @@ -98,10 +98,9 @@ |
|
4359 retarray->offset = 0; |
|
4360 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4361 |
|
4362 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4363 - * extent[rank-1]; |
|
4364 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4365 |
|
4366 - retarray->base_addr = xmalloc (alloc_size); |
|
4367 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
4368 if (alloc_size == 0) |
|
4369 { |
|
4370 /* Make sure we have a zero-sized array. */ |
|
4371 @@ -294,8 +293,7 @@ |
|
4372 |
|
4373 } |
|
4374 |
|
4375 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4376 - * extent[rank-1]; |
|
4377 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4378 |
|
4379 retarray->offset = 0; |
|
4380 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4381 @@ -307,7 +305,7 @@ |
|
4382 return; |
|
4383 } |
|
4384 else |
|
4385 - retarray->base_addr = xmalloc (alloc_size); |
|
4386 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
4387 |
|
4388 } |
|
4389 else |
|
4390 @@ -485,8 +483,7 @@ |
|
4391 retarray->offset = 0; |
|
4392 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4393 |
|
4394 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4395 - * extent[rank-1]; |
|
4396 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4397 |
|
4398 if (alloc_size == 0) |
|
4399 { |
|
4400 @@ -495,7 +492,7 @@ |
|
4401 return; |
|
4402 } |
|
4403 else |
|
4404 - retarray->base_addr = xmalloc (alloc_size); |
|
4405 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
4406 } |
|
4407 else |
|
4408 { |
|
4409 Index: gcc-4.8_branch/libgfortran/generated/minloc1_8_i8.c |
|
4410 =================================================================== |
|
4411 --- gcc-4.8_branch/libgfortran/generated/minloc1_8_i8.c (revision 213312) |
|
4412 +++ gcc-4.8_branch/libgfortran/generated/minloc1_8_i8.c (revision 213313) |
|
4413 @@ -98,10 +98,9 @@ |
|
4414 retarray->offset = 0; |
|
4415 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4416 |
|
4417 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4418 - * extent[rank-1]; |
|
4419 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4420 |
|
4421 - retarray->base_addr = xmalloc (alloc_size); |
|
4422 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
4423 if (alloc_size == 0) |
|
4424 { |
|
4425 /* Make sure we have a zero-sized array. */ |
|
4426 @@ -294,8 +293,7 @@ |
|
4427 |
|
4428 } |
|
4429 |
|
4430 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4431 - * extent[rank-1]; |
|
4432 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4433 |
|
4434 retarray->offset = 0; |
|
4435 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4436 @@ -307,7 +305,7 @@ |
|
4437 return; |
|
4438 } |
|
4439 else |
|
4440 - retarray->base_addr = xmalloc (alloc_size); |
|
4441 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
4442 |
|
4443 } |
|
4444 else |
|
4445 @@ -485,8 +483,7 @@ |
|
4446 retarray->offset = 0; |
|
4447 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4448 |
|
4449 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4450 - * extent[rank-1]; |
|
4451 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4452 |
|
4453 if (alloc_size == 0) |
|
4454 { |
|
4455 @@ -495,7 +492,7 @@ |
|
4456 return; |
|
4457 } |
|
4458 else |
|
4459 - retarray->base_addr = xmalloc (alloc_size); |
|
4460 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
4461 } |
|
4462 else |
|
4463 { |
|
4464 Index: gcc-4.8_branch/libgfortran/generated/minloc0_4_r8.c |
|
4465 =================================================================== |
|
4466 --- gcc-4.8_branch/libgfortran/generated/minloc0_4_r8.c (revision 213312) |
|
4467 +++ gcc-4.8_branch/libgfortran/generated/minloc0_4_r8.c (revision 213313) |
|
4468 @@ -58,7 +58,7 @@ |
|
4469 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
4470 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
4471 retarray->offset = 0; |
|
4472 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
4473 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
4474 } |
|
4475 else |
|
4476 { |
|
4477 @@ -199,7 +199,7 @@ |
|
4478 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
4479 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
4480 retarray->offset = 0; |
|
4481 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
4482 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
4483 } |
|
4484 else |
|
4485 { |
|
4486 @@ -367,7 +367,7 @@ |
|
4487 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
4488 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
4489 retarray->offset = 0; |
|
4490 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
4491 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
4492 } |
|
4493 else if (unlikely (compile_options.bounds_check)) |
|
4494 { |
|
4495 Index: gcc-4.8_branch/libgfortran/generated/product_r16.c |
|
4496 =================================================================== |
|
4497 --- gcc-4.8_branch/libgfortran/generated/product_r16.c (revision 213312) |
|
4498 +++ gcc-4.8_branch/libgfortran/generated/product_r16.c (revision 213313) |
|
4499 @@ -97,10 +97,9 @@ |
|
4500 retarray->offset = 0; |
|
4501 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4502 |
|
4503 - alloc_size = sizeof (GFC_REAL_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4504 - * extent[rank-1]; |
|
4505 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4506 |
|
4507 - retarray->base_addr = xmalloc (alloc_size); |
|
4508 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_16)); |
|
4509 if (alloc_size == 0) |
|
4510 { |
|
4511 /* Make sure we have a zero-sized array. */ |
|
4512 @@ -272,8 +271,7 @@ |
|
4513 |
|
4514 } |
|
4515 |
|
4516 - alloc_size = sizeof (GFC_REAL_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4517 - * extent[rank-1]; |
|
4518 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4519 |
|
4520 retarray->offset = 0; |
|
4521 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4522 @@ -285,7 +283,7 @@ |
|
4523 return; |
|
4524 } |
|
4525 else |
|
4526 - retarray->base_addr = xmalloc (alloc_size); |
|
4527 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_16)); |
|
4528 |
|
4529 } |
|
4530 else |
|
4531 @@ -430,8 +428,7 @@ |
|
4532 retarray->offset = 0; |
|
4533 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4534 |
|
4535 - alloc_size = sizeof (GFC_REAL_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4536 - * extent[rank-1]; |
|
4537 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4538 |
|
4539 if (alloc_size == 0) |
|
4540 { |
|
4541 @@ -440,7 +437,7 @@ |
|
4542 return; |
|
4543 } |
|
4544 else |
|
4545 - retarray->base_addr = xmalloc (alloc_size); |
|
4546 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_16)); |
|
4547 } |
|
4548 else |
|
4549 { |
|
4550 Index: gcc-4.8_branch/libgfortran/generated/sum_r8.c |
|
4551 =================================================================== |
|
4552 --- gcc-4.8_branch/libgfortran/generated/sum_r8.c (revision 213312) |
|
4553 +++ gcc-4.8_branch/libgfortran/generated/sum_r8.c (revision 213313) |
|
4554 @@ -97,10 +97,9 @@ |
|
4555 retarray->offset = 0; |
|
4556 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4557 |
|
4558 - alloc_size = sizeof (GFC_REAL_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4559 - * extent[rank-1]; |
|
4560 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4561 |
|
4562 - retarray->base_addr = xmalloc (alloc_size); |
|
4563 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_8)); |
|
4564 if (alloc_size == 0) |
|
4565 { |
|
4566 /* Make sure we have a zero-sized array. */ |
|
4567 @@ -272,8 +271,7 @@ |
|
4568 |
|
4569 } |
|
4570 |
|
4571 - alloc_size = sizeof (GFC_REAL_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4572 - * extent[rank-1]; |
|
4573 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4574 |
|
4575 retarray->offset = 0; |
|
4576 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4577 @@ -285,7 +283,7 @@ |
|
4578 return; |
|
4579 } |
|
4580 else |
|
4581 - retarray->base_addr = xmalloc (alloc_size); |
|
4582 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_8)); |
|
4583 |
|
4584 } |
|
4585 else |
|
4586 @@ -430,8 +428,7 @@ |
|
4587 retarray->offset = 0; |
|
4588 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4589 |
|
4590 - alloc_size = sizeof (GFC_REAL_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4591 - * extent[rank-1]; |
|
4592 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4593 |
|
4594 if (alloc_size == 0) |
|
4595 { |
|
4596 @@ -440,7 +437,7 @@ |
|
4597 return; |
|
4598 } |
|
4599 else |
|
4600 - retarray->base_addr = xmalloc (alloc_size); |
|
4601 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_8)); |
|
4602 } |
|
4603 else |
|
4604 { |
|
4605 Index: gcc-4.8_branch/libgfortran/generated/norm2_r10.c |
|
4606 =================================================================== |
|
4607 --- gcc-4.8_branch/libgfortran/generated/norm2_r10.c (revision 213312) |
|
4608 +++ gcc-4.8_branch/libgfortran/generated/norm2_r10.c (revision 213313) |
|
4609 @@ -101,10 +101,9 @@ |
|
4610 retarray->offset = 0; |
|
4611 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4612 |
|
4613 - alloc_size = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4614 - * extent[rank-1]; |
|
4615 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4616 |
|
4617 - retarray->base_addr = xmalloc (alloc_size); |
|
4618 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_10)); |
|
4619 if (alloc_size == 0) |
|
4620 { |
|
4621 /* Make sure we have a zero-sized array. */ |
|
4622 Index: gcc-4.8_branch/libgfortran/generated/unpack_c10.c |
|
4623 =================================================================== |
|
4624 --- gcc-4.8_branch/libgfortran/generated/unpack_c10.c (revision 213312) |
|
4625 +++ gcc-4.8_branch/libgfortran/generated/unpack_c10.c (revision 213313) |
|
4626 @@ -99,7 +99,7 @@ |
|
4627 rs *= extent[n]; |
|
4628 } |
|
4629 ret->offset = 0; |
|
4630 - ret->base_addr = xmalloc (rs * sizeof (GFC_COMPLEX_10)); |
|
4631 + ret->base_addr = xmallocarray (rs, sizeof (GFC_COMPLEX_10)); |
|
4632 } |
|
4633 else |
|
4634 { |
|
4635 @@ -244,7 +244,7 @@ |
|
4636 rs *= extent[n]; |
|
4637 } |
|
4638 ret->offset = 0; |
|
4639 - ret->base_addr = xmalloc (rs * sizeof (GFC_COMPLEX_10)); |
|
4640 + ret->base_addr = xmallocarray (rs, sizeof (GFC_COMPLEX_10)); |
|
4641 } |
|
4642 else |
|
4643 { |
|
4644 Index: gcc-4.8_branch/libgfortran/generated/spread_r8.c |
|
4645 =================================================================== |
|
4646 --- gcc-4.8_branch/libgfortran/generated/spread_r8.c (revision 213312) |
|
4647 +++ gcc-4.8_branch/libgfortran/generated/spread_r8.c (revision 213313) |
|
4648 @@ -101,8 +101,8 @@ |
|
4649 } |
|
4650 ret->offset = 0; |
|
4651 |
|
4652 - /* xmalloc allocates a single byte for zero size. */ |
|
4653 - ret->base_addr = xmalloc (rs * sizeof(GFC_REAL_8)); |
|
4654 + /* xmallocarray allocates a single byte for zero size. */ |
|
4655 + ret->base_addr = xmallocarray (rs, sizeof(GFC_REAL_8)); |
|
4656 if (rs <= 0) |
|
4657 return; |
|
4658 } |
|
4659 @@ -244,7 +244,7 @@ |
|
4660 |
|
4661 if (ret->base_addr == NULL) |
|
4662 { |
|
4663 - ret->base_addr = xmalloc (ncopies * sizeof (GFC_REAL_8)); |
|
4664 + ret->base_addr = xmallocarray (ncopies, sizeof (GFC_REAL_8)); |
|
4665 ret->offset = 0; |
|
4666 GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1); |
|
4667 } |
|
4668 Index: gcc-4.8_branch/libgfortran/generated/minloc1_16_i16.c |
|
4669 =================================================================== |
|
4670 --- gcc-4.8_branch/libgfortran/generated/minloc1_16_i16.c (revision 213312) |
|
4671 +++ gcc-4.8_branch/libgfortran/generated/minloc1_16_i16.c (revision 213313) |
|
4672 @@ -98,10 +98,9 @@ |
|
4673 retarray->offset = 0; |
|
4674 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4675 |
|
4676 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4677 - * extent[rank-1]; |
|
4678 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4679 |
|
4680 - retarray->base_addr = xmalloc (alloc_size); |
|
4681 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
4682 if (alloc_size == 0) |
|
4683 { |
|
4684 /* Make sure we have a zero-sized array. */ |
|
4685 @@ -294,8 +293,7 @@ |
|
4686 |
|
4687 } |
|
4688 |
|
4689 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4690 - * extent[rank-1]; |
|
4691 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4692 |
|
4693 retarray->offset = 0; |
|
4694 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4695 @@ -307,7 +305,7 @@ |
|
4696 return; |
|
4697 } |
|
4698 else |
|
4699 - retarray->base_addr = xmalloc (alloc_size); |
|
4700 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
4701 |
|
4702 } |
|
4703 else |
|
4704 @@ -485,8 +483,7 @@ |
|
4705 retarray->offset = 0; |
|
4706 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4707 |
|
4708 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4709 - * extent[rank-1]; |
|
4710 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4711 |
|
4712 if (alloc_size == 0) |
|
4713 { |
|
4714 @@ -495,7 +492,7 @@ |
|
4715 return; |
|
4716 } |
|
4717 else |
|
4718 - retarray->base_addr = xmalloc (alloc_size); |
|
4719 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
4720 } |
|
4721 else |
|
4722 { |
|
4723 Index: gcc-4.8_branch/libgfortran/generated/maxloc1_8_r4.c |
|
4724 =================================================================== |
|
4725 --- gcc-4.8_branch/libgfortran/generated/maxloc1_8_r4.c (revision 213312) |
|
4726 +++ gcc-4.8_branch/libgfortran/generated/maxloc1_8_r4.c (revision 213313) |
|
4727 @@ -98,10 +98,9 @@ |
|
4728 retarray->offset = 0; |
|
4729 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4730 |
|
4731 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4732 - * extent[rank-1]; |
|
4733 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4734 |
|
4735 - retarray->base_addr = xmalloc (alloc_size); |
|
4736 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
4737 if (alloc_size == 0) |
|
4738 { |
|
4739 /* Make sure we have a zero-sized array. */ |
|
4740 @@ -294,8 +293,7 @@ |
|
4741 |
|
4742 } |
|
4743 |
|
4744 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4745 - * extent[rank-1]; |
|
4746 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4747 |
|
4748 retarray->offset = 0; |
|
4749 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4750 @@ -307,7 +305,7 @@ |
|
4751 return; |
|
4752 } |
|
4753 else |
|
4754 - retarray->base_addr = xmalloc (alloc_size); |
|
4755 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
4756 |
|
4757 } |
|
4758 else |
|
4759 @@ -485,8 +483,7 @@ |
|
4760 retarray->offset = 0; |
|
4761 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4762 |
|
4763 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4764 - * extent[rank-1]; |
|
4765 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4766 |
|
4767 if (alloc_size == 0) |
|
4768 { |
|
4769 @@ -495,7 +492,7 @@ |
|
4770 return; |
|
4771 } |
|
4772 else |
|
4773 - retarray->base_addr = xmalloc (alloc_size); |
|
4774 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
4775 } |
|
4776 else |
|
4777 { |
|
4778 Index: gcc-4.8_branch/libgfortran/generated/minloc1_16_i1.c |
|
4779 =================================================================== |
|
4780 --- gcc-4.8_branch/libgfortran/generated/minloc1_16_i1.c (revision 213312) |
|
4781 +++ gcc-4.8_branch/libgfortran/generated/minloc1_16_i1.c (revision 213313) |
|
4782 @@ -98,10 +98,9 @@ |
|
4783 retarray->offset = 0; |
|
4784 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4785 |
|
4786 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4787 - * extent[rank-1]; |
|
4788 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4789 |
|
4790 - retarray->base_addr = xmalloc (alloc_size); |
|
4791 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
4792 if (alloc_size == 0) |
|
4793 { |
|
4794 /* Make sure we have a zero-sized array. */ |
|
4795 @@ -294,8 +293,7 @@ |
|
4796 |
|
4797 } |
|
4798 |
|
4799 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4800 - * extent[rank-1]; |
|
4801 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4802 |
|
4803 retarray->offset = 0; |
|
4804 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4805 @@ -307,7 +305,7 @@ |
|
4806 return; |
|
4807 } |
|
4808 else |
|
4809 - retarray->base_addr = xmalloc (alloc_size); |
|
4810 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
4811 |
|
4812 } |
|
4813 else |
|
4814 @@ -485,8 +483,7 @@ |
|
4815 retarray->offset = 0; |
|
4816 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4817 |
|
4818 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4819 - * extent[rank-1]; |
|
4820 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4821 |
|
4822 if (alloc_size == 0) |
|
4823 { |
|
4824 @@ -495,7 +492,7 @@ |
|
4825 return; |
|
4826 } |
|
4827 else |
|
4828 - retarray->base_addr = xmalloc (alloc_size); |
|
4829 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
4830 } |
|
4831 else |
|
4832 { |
|
4833 Index: gcc-4.8_branch/libgfortran/generated/spread_r16.c |
|
4834 =================================================================== |
|
4835 --- gcc-4.8_branch/libgfortran/generated/spread_r16.c (revision 213312) |
|
4836 +++ gcc-4.8_branch/libgfortran/generated/spread_r16.c (revision 213313) |
|
4837 @@ -101,8 +101,8 @@ |
|
4838 } |
|
4839 ret->offset = 0; |
|
4840 |
|
4841 - /* xmalloc allocates a single byte for zero size. */ |
|
4842 - ret->base_addr = xmalloc (rs * sizeof(GFC_REAL_16)); |
|
4843 + /* xmallocarray allocates a single byte for zero size. */ |
|
4844 + ret->base_addr = xmallocarray (rs, sizeof(GFC_REAL_16)); |
|
4845 if (rs <= 0) |
|
4846 return; |
|
4847 } |
|
4848 @@ -244,7 +244,7 @@ |
|
4849 |
|
4850 if (ret->base_addr == NULL) |
|
4851 { |
|
4852 - ret->base_addr = xmalloc (ncopies * sizeof (GFC_REAL_16)); |
|
4853 + ret->base_addr = xmallocarray (ncopies, sizeof (GFC_REAL_16)); |
|
4854 ret->offset = 0; |
|
4855 GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1); |
|
4856 } |
|
4857 Index: gcc-4.8_branch/libgfortran/generated/pack_c8.c |
|
4858 =================================================================== |
|
4859 --- gcc-4.8_branch/libgfortran/generated/pack_c8.c (revision 213312) |
|
4860 +++ gcc-4.8_branch/libgfortran/generated/pack_c8.c (revision 213313) |
|
4861 @@ -167,8 +167,8 @@ |
|
4862 |
|
4863 ret->offset = 0; |
|
4864 |
|
4865 - /* xmalloc allocates a single byte for zero size. */ |
|
4866 - ret->base_addr = xmalloc (sizeof (GFC_COMPLEX_8) * total); |
|
4867 + /* xmallocarray allocates a single byte for zero size. */ |
|
4868 + ret->base_addr = xmallocarray (total, sizeof (GFC_COMPLEX_8)); |
|
4869 |
|
4870 if (total == 0) |
|
4871 return; |
|
4872 Index: gcc-4.8_branch/libgfortran/generated/minval_r10.c |
|
4873 =================================================================== |
|
4874 --- gcc-4.8_branch/libgfortran/generated/minval_r10.c (revision 213312) |
|
4875 +++ gcc-4.8_branch/libgfortran/generated/minval_r10.c (revision 213313) |
|
4876 @@ -97,10 +97,9 @@ |
|
4877 retarray->offset = 0; |
|
4878 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4879 |
|
4880 - alloc_size = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4881 - * extent[rank-1]; |
|
4882 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4883 |
|
4884 - retarray->base_addr = xmalloc (alloc_size); |
|
4885 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_10)); |
|
4886 if (alloc_size == 0) |
|
4887 { |
|
4888 /* Make sure we have a zero-sized array. */ |
|
4889 @@ -286,8 +285,7 @@ |
|
4890 |
|
4891 } |
|
4892 |
|
4893 - alloc_size = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4894 - * extent[rank-1]; |
|
4895 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4896 |
|
4897 retarray->offset = 0; |
|
4898 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4899 @@ -299,7 +297,7 @@ |
|
4900 return; |
|
4901 } |
|
4902 else |
|
4903 - retarray->base_addr = xmalloc (alloc_size); |
|
4904 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_10)); |
|
4905 |
|
4906 } |
|
4907 else |
|
4908 @@ -472,8 +470,7 @@ |
|
4909 retarray->offset = 0; |
|
4910 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4911 |
|
4912 - alloc_size = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4913 - * extent[rank-1]; |
|
4914 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4915 |
|
4916 if (alloc_size == 0) |
|
4917 { |
|
4918 @@ -482,7 +479,7 @@ |
|
4919 return; |
|
4920 } |
|
4921 else |
|
4922 - retarray->base_addr = xmalloc (alloc_size); |
|
4923 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_10)); |
|
4924 } |
|
4925 else |
|
4926 { |
|
4927 Index: gcc-4.8_branch/libgfortran/generated/parity_l8.c |
|
4928 =================================================================== |
|
4929 --- gcc-4.8_branch/libgfortran/generated/parity_l8.c (revision 213312) |
|
4930 +++ gcc-4.8_branch/libgfortran/generated/parity_l8.c (revision 213313) |
|
4931 @@ -98,10 +98,9 @@ |
|
4932 retarray->offset = 0; |
|
4933 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4934 |
|
4935 - alloc_size = sizeof (GFC_LOGICAL_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4936 - * extent[rank-1]; |
|
4937 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4938 |
|
4939 - retarray->base_addr = xmalloc (alloc_size); |
|
4940 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_LOGICAL_8)); |
|
4941 if (alloc_size == 0) |
|
4942 { |
|
4943 /* Make sure we have a zero-sized array. */ |
|
4944 Index: gcc-4.8_branch/libgfortran/generated/minval_i4.c |
|
4945 =================================================================== |
|
4946 --- gcc-4.8_branch/libgfortran/generated/minval_i4.c (revision 213312) |
|
4947 +++ gcc-4.8_branch/libgfortran/generated/minval_i4.c (revision 213313) |
|
4948 @@ -97,10 +97,9 @@ |
|
4949 retarray->offset = 0; |
|
4950 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4951 |
|
4952 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4953 - * extent[rank-1]; |
|
4954 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4955 |
|
4956 - retarray->base_addr = xmalloc (alloc_size); |
|
4957 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
4958 if (alloc_size == 0) |
|
4959 { |
|
4960 /* Make sure we have a zero-sized array. */ |
|
4961 @@ -286,8 +285,7 @@ |
|
4962 |
|
4963 } |
|
4964 |
|
4965 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4966 - * extent[rank-1]; |
|
4967 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4968 |
|
4969 retarray->offset = 0; |
|
4970 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4971 @@ -299,7 +297,7 @@ |
|
4972 return; |
|
4973 } |
|
4974 else |
|
4975 - retarray->base_addr = xmalloc (alloc_size); |
|
4976 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
4977 |
|
4978 } |
|
4979 else |
|
4980 @@ -472,8 +470,7 @@ |
|
4981 retarray->offset = 0; |
|
4982 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
4983 |
|
4984 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
4985 - * extent[rank-1]; |
|
4986 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
4987 |
|
4988 if (alloc_size == 0) |
|
4989 { |
|
4990 @@ -482,7 +479,7 @@ |
|
4991 return; |
|
4992 } |
|
4993 else |
|
4994 - retarray->base_addr = xmalloc (alloc_size); |
|
4995 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
4996 } |
|
4997 else |
|
4998 { |
|
4999 Index: gcc-4.8_branch/libgfortran/generated/maxloc1_8_i2.c |
|
5000 =================================================================== |
|
5001 --- gcc-4.8_branch/libgfortran/generated/maxloc1_8_i2.c (revision 213312) |
|
5002 +++ gcc-4.8_branch/libgfortran/generated/maxloc1_8_i2.c (revision 213313) |
|
5003 @@ -98,10 +98,9 @@ |
|
5004 retarray->offset = 0; |
|
5005 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5006 |
|
5007 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5008 - * extent[rank-1]; |
|
5009 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5010 |
|
5011 - retarray->base_addr = xmalloc (alloc_size); |
|
5012 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
5013 if (alloc_size == 0) |
|
5014 { |
|
5015 /* Make sure we have a zero-sized array. */ |
|
5016 @@ -294,8 +293,7 @@ |
|
5017 |
|
5018 } |
|
5019 |
|
5020 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5021 - * extent[rank-1]; |
|
5022 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5023 |
|
5024 retarray->offset = 0; |
|
5025 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5026 @@ -307,7 +305,7 @@ |
|
5027 return; |
|
5028 } |
|
5029 else |
|
5030 - retarray->base_addr = xmalloc (alloc_size); |
|
5031 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
5032 |
|
5033 } |
|
5034 else |
|
5035 @@ -485,8 +483,7 @@ |
|
5036 retarray->offset = 0; |
|
5037 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5038 |
|
5039 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5040 - * extent[rank-1]; |
|
5041 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5042 |
|
5043 if (alloc_size == 0) |
|
5044 { |
|
5045 @@ -495,7 +492,7 @@ |
|
5046 return; |
|
5047 } |
|
5048 else |
|
5049 - retarray->base_addr = xmalloc (alloc_size); |
|
5050 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
5051 } |
|
5052 else |
|
5053 { |
|
5054 Index: gcc-4.8_branch/libgfortran/generated/any_l8.c |
|
5055 =================================================================== |
|
5056 --- gcc-4.8_branch/libgfortran/generated/any_l8.c (revision 213312) |
|
5057 +++ gcc-4.8_branch/libgfortran/generated/any_l8.c (revision 213313) |
|
5058 @@ -101,8 +101,7 @@ |
|
5059 retarray->offset = 0; |
|
5060 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5061 |
|
5062 - alloc_size = sizeof (GFC_LOGICAL_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5063 - * extent[rank-1]; |
|
5064 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5065 |
|
5066 if (alloc_size == 0) |
|
5067 { |
|
5068 @@ -111,7 +110,7 @@ |
|
5069 return; |
|
5070 } |
|
5071 else |
|
5072 - retarray->base_addr = xmalloc (alloc_size); |
|
5073 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_LOGICAL_8)); |
|
5074 } |
|
5075 else |
|
5076 { |
|
5077 Index: gcc-4.8_branch/libgfortran/generated/maxloc0_16_r10.c |
|
5078 =================================================================== |
|
5079 --- gcc-4.8_branch/libgfortran/generated/maxloc0_16_r10.c (revision 213312) |
|
5080 +++ gcc-4.8_branch/libgfortran/generated/maxloc0_16_r10.c (revision 213313) |
|
5081 @@ -58,7 +58,7 @@ |
|
5082 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
5083 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
5084 retarray->offset = 0; |
|
5085 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
5086 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
5087 } |
|
5088 else |
|
5089 { |
|
5090 @@ -199,7 +199,7 @@ |
|
5091 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
5092 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
5093 retarray->offset = 0; |
|
5094 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
5095 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
5096 } |
|
5097 else |
|
5098 { |
|
5099 @@ -367,7 +367,7 @@ |
|
5100 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
5101 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
5102 retarray->offset = 0; |
|
5103 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
5104 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
5105 } |
|
5106 else if (unlikely (compile_options.bounds_check)) |
|
5107 { |
|
5108 Index: gcc-4.8_branch/libgfortran/generated/minloc0_4_i16.c |
|
5109 =================================================================== |
|
5110 --- gcc-4.8_branch/libgfortran/generated/minloc0_4_i16.c (revision 213312) |
|
5111 +++ gcc-4.8_branch/libgfortran/generated/minloc0_4_i16.c (revision 213313) |
|
5112 @@ -58,7 +58,7 @@ |
|
5113 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
5114 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
5115 retarray->offset = 0; |
|
5116 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
5117 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
5118 } |
|
5119 else |
|
5120 { |
|
5121 @@ -199,7 +199,7 @@ |
|
5122 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
5123 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
5124 retarray->offset = 0; |
|
5125 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
5126 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
5127 } |
|
5128 else |
|
5129 { |
|
5130 @@ -367,7 +367,7 @@ |
|
5131 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
5132 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
5133 retarray->offset = 0; |
|
5134 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
5135 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
5136 } |
|
5137 else if (unlikely (compile_options.bounds_check)) |
|
5138 { |
|
5139 Index: gcc-4.8_branch/libgfortran/generated/maxloc0_8_r8.c |
|
5140 =================================================================== |
|
5141 --- gcc-4.8_branch/libgfortran/generated/maxloc0_8_r8.c (revision 213312) |
|
5142 +++ gcc-4.8_branch/libgfortran/generated/maxloc0_8_r8.c (revision 213313) |
|
5143 @@ -58,7 +58,7 @@ |
|
5144 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
5145 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
5146 retarray->offset = 0; |
|
5147 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
5148 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
5149 } |
|
5150 else |
|
5151 { |
|
5152 @@ -199,7 +199,7 @@ |
|
5153 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
5154 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
5155 retarray->offset = 0; |
|
5156 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
5157 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
5158 } |
|
5159 else |
|
5160 { |
|
5161 @@ -367,7 +367,7 @@ |
|
5162 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
5163 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
5164 retarray->offset = 0; |
|
5165 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
5166 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
5167 } |
|
5168 else if (unlikely (compile_options.bounds_check)) |
|
5169 { |
|
5170 Index: gcc-4.8_branch/libgfortran/generated/minloc1_4_r10.c |
|
5171 =================================================================== |
|
5172 --- gcc-4.8_branch/libgfortran/generated/minloc1_4_r10.c (revision 213312) |
|
5173 +++ gcc-4.8_branch/libgfortran/generated/minloc1_4_r10.c (revision 213313) |
|
5174 @@ -98,10 +98,9 @@ |
|
5175 retarray->offset = 0; |
|
5176 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5177 |
|
5178 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5179 - * extent[rank-1]; |
|
5180 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5181 |
|
5182 - retarray->base_addr = xmalloc (alloc_size); |
|
5183 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
5184 if (alloc_size == 0) |
|
5185 { |
|
5186 /* Make sure we have a zero-sized array. */ |
|
5187 @@ -294,8 +293,7 @@ |
|
5188 |
|
5189 } |
|
5190 |
|
5191 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5192 - * extent[rank-1]; |
|
5193 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5194 |
|
5195 retarray->offset = 0; |
|
5196 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5197 @@ -307,7 +305,7 @@ |
|
5198 return; |
|
5199 } |
|
5200 else |
|
5201 - retarray->base_addr = xmalloc (alloc_size); |
|
5202 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
5203 |
|
5204 } |
|
5205 else |
|
5206 @@ -485,8 +483,7 @@ |
|
5207 retarray->offset = 0; |
|
5208 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5209 |
|
5210 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5211 - * extent[rank-1]; |
|
5212 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5213 |
|
5214 if (alloc_size == 0) |
|
5215 { |
|
5216 @@ -495,7 +492,7 @@ |
|
5217 return; |
|
5218 } |
|
5219 else |
|
5220 - retarray->base_addr = xmalloc (alloc_size); |
|
5221 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
5222 } |
|
5223 else |
|
5224 { |
|
5225 Index: gcc-4.8_branch/libgfortran/generated/minloc1_8_i16.c |
|
5226 =================================================================== |
|
5227 --- gcc-4.8_branch/libgfortran/generated/minloc1_8_i16.c (revision 213312) |
|
5228 +++ gcc-4.8_branch/libgfortran/generated/minloc1_8_i16.c (revision 213313) |
|
5229 @@ -98,10 +98,9 @@ |
|
5230 retarray->offset = 0; |
|
5231 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5232 |
|
5233 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5234 - * extent[rank-1]; |
|
5235 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5236 |
|
5237 - retarray->base_addr = xmalloc (alloc_size); |
|
5238 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
5239 if (alloc_size == 0) |
|
5240 { |
|
5241 /* Make sure we have a zero-sized array. */ |
|
5242 @@ -294,8 +293,7 @@ |
|
5243 |
|
5244 } |
|
5245 |
|
5246 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5247 - * extent[rank-1]; |
|
5248 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5249 |
|
5250 retarray->offset = 0; |
|
5251 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5252 @@ -307,7 +305,7 @@ |
|
5253 return; |
|
5254 } |
|
5255 else |
|
5256 - retarray->base_addr = xmalloc (alloc_size); |
|
5257 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
5258 |
|
5259 } |
|
5260 else |
|
5261 @@ -485,8 +483,7 @@ |
|
5262 retarray->offset = 0; |
|
5263 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5264 |
|
5265 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5266 - * extent[rank-1]; |
|
5267 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5268 |
|
5269 if (alloc_size == 0) |
|
5270 { |
|
5271 @@ -495,7 +492,7 @@ |
|
5272 return; |
|
5273 } |
|
5274 else |
|
5275 - retarray->base_addr = xmalloc (alloc_size); |
|
5276 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
5277 } |
|
5278 else |
|
5279 { |
|
5280 Index: gcc-4.8_branch/libgfortran/generated/maxloc0_8_r10.c |
|
5281 =================================================================== |
|
5282 --- gcc-4.8_branch/libgfortran/generated/maxloc0_8_r10.c (revision 213312) |
|
5283 +++ gcc-4.8_branch/libgfortran/generated/maxloc0_8_r10.c (revision 213313) |
|
5284 @@ -58,7 +58,7 @@ |
|
5285 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
5286 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
5287 retarray->offset = 0; |
|
5288 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
5289 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
5290 } |
|
5291 else |
|
5292 { |
|
5293 @@ -199,7 +199,7 @@ |
|
5294 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
5295 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
5296 retarray->offset = 0; |
|
5297 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
5298 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
5299 } |
|
5300 else |
|
5301 { |
|
5302 @@ -367,7 +367,7 @@ |
|
5303 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
5304 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
5305 retarray->offset = 0; |
|
5306 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
5307 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
5308 } |
|
5309 else if (unlikely (compile_options.bounds_check)) |
|
5310 { |
|
5311 Index: gcc-4.8_branch/libgfortran/generated/unpack_i4.c |
|
5312 =================================================================== |
|
5313 --- gcc-4.8_branch/libgfortran/generated/unpack_i4.c (revision 213312) |
|
5314 +++ gcc-4.8_branch/libgfortran/generated/unpack_i4.c (revision 213313) |
|
5315 @@ -99,7 +99,7 @@ |
|
5316 rs *= extent[n]; |
|
5317 } |
|
5318 ret->offset = 0; |
|
5319 - ret->base_addr = xmalloc (rs * sizeof (GFC_INTEGER_4)); |
|
5320 + ret->base_addr = xmallocarray (rs, sizeof (GFC_INTEGER_4)); |
|
5321 } |
|
5322 else |
|
5323 { |
|
5324 @@ -244,7 +244,7 @@ |
|
5325 rs *= extent[n]; |
|
5326 } |
|
5327 ret->offset = 0; |
|
5328 - ret->base_addr = xmalloc (rs * sizeof (GFC_INTEGER_4)); |
|
5329 + ret->base_addr = xmallocarray (rs, sizeof (GFC_INTEGER_4)); |
|
5330 } |
|
5331 else |
|
5332 { |
|
5333 Index: gcc-4.8_branch/libgfortran/generated/minloc1_16_r4.c |
|
5334 =================================================================== |
|
5335 --- gcc-4.8_branch/libgfortran/generated/minloc1_16_r4.c (revision 213312) |
|
5336 +++ gcc-4.8_branch/libgfortran/generated/minloc1_16_r4.c (revision 213313) |
|
5337 @@ -98,10 +98,9 @@ |
|
5338 retarray->offset = 0; |
|
5339 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5340 |
|
5341 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5342 - * extent[rank-1]; |
|
5343 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5344 |
|
5345 - retarray->base_addr = xmalloc (alloc_size); |
|
5346 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
5347 if (alloc_size == 0) |
|
5348 { |
|
5349 /* Make sure we have a zero-sized array. */ |
|
5350 @@ -294,8 +293,7 @@ |
|
5351 |
|
5352 } |
|
5353 |
|
5354 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5355 - * extent[rank-1]; |
|
5356 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5357 |
|
5358 retarray->offset = 0; |
|
5359 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5360 @@ -307,7 +305,7 @@ |
|
5361 return; |
|
5362 } |
|
5363 else |
|
5364 - retarray->base_addr = xmalloc (alloc_size); |
|
5365 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
5366 |
|
5367 } |
|
5368 else |
|
5369 @@ -485,8 +483,7 @@ |
|
5370 retarray->offset = 0; |
|
5371 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5372 |
|
5373 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5374 - * extent[rank-1]; |
|
5375 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5376 |
|
5377 if (alloc_size == 0) |
|
5378 { |
|
5379 @@ -495,7 +492,7 @@ |
|
5380 return; |
|
5381 } |
|
5382 else |
|
5383 - retarray->base_addr = xmalloc (alloc_size); |
|
5384 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
5385 } |
|
5386 else |
|
5387 { |
|
5388 Index: gcc-4.8_branch/libgfortran/generated/product_i8.c |
|
5389 =================================================================== |
|
5390 --- gcc-4.8_branch/libgfortran/generated/product_i8.c (revision 213312) |
|
5391 +++ gcc-4.8_branch/libgfortran/generated/product_i8.c (revision 213313) |
|
5392 @@ -97,10 +97,9 @@ |
|
5393 retarray->offset = 0; |
|
5394 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5395 |
|
5396 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5397 - * extent[rank-1]; |
|
5398 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5399 |
|
5400 - retarray->base_addr = xmalloc (alloc_size); |
|
5401 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
5402 if (alloc_size == 0) |
|
5403 { |
|
5404 /* Make sure we have a zero-sized array. */ |
|
5405 @@ -272,8 +271,7 @@ |
|
5406 |
|
5407 } |
|
5408 |
|
5409 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5410 - * extent[rank-1]; |
|
5411 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5412 |
|
5413 retarray->offset = 0; |
|
5414 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5415 @@ -285,7 +283,7 @@ |
|
5416 return; |
|
5417 } |
|
5418 else |
|
5419 - retarray->base_addr = xmalloc (alloc_size); |
|
5420 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
5421 |
|
5422 } |
|
5423 else |
|
5424 @@ -430,8 +428,7 @@ |
|
5425 retarray->offset = 0; |
|
5426 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5427 |
|
5428 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5429 - * extent[rank-1]; |
|
5430 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5431 |
|
5432 if (alloc_size == 0) |
|
5433 { |
|
5434 @@ -440,7 +437,7 @@ |
|
5435 return; |
|
5436 } |
|
5437 else |
|
5438 - retarray->base_addr = xmalloc (alloc_size); |
|
5439 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
5440 } |
|
5441 else |
|
5442 { |
|
5443 Index: gcc-4.8_branch/libgfortran/generated/minloc0_16_r8.c |
|
5444 =================================================================== |
|
5445 --- gcc-4.8_branch/libgfortran/generated/minloc0_16_r8.c (revision 213312) |
|
5446 +++ gcc-4.8_branch/libgfortran/generated/minloc0_16_r8.c (revision 213313) |
|
5447 @@ -58,7 +58,7 @@ |
|
5448 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
5449 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
5450 retarray->offset = 0; |
|
5451 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
5452 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
5453 } |
|
5454 else |
|
5455 { |
|
5456 @@ -199,7 +199,7 @@ |
|
5457 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
5458 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
5459 retarray->offset = 0; |
|
5460 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
5461 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
5462 } |
|
5463 else |
|
5464 { |
|
5465 @@ -367,7 +367,7 @@ |
|
5466 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
5467 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
5468 retarray->offset = 0; |
|
5469 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
5470 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
5471 } |
|
5472 else if (unlikely (compile_options.bounds_check)) |
|
5473 { |
|
5474 Index: gcc-4.8_branch/libgfortran/generated/count_2_l.c |
|
5475 =================================================================== |
|
5476 --- gcc-4.8_branch/libgfortran/generated/count_2_l.c (revision 213312) |
|
5477 +++ gcc-4.8_branch/libgfortran/generated/count_2_l.c (revision 213313) |
|
5478 @@ -101,8 +101,7 @@ |
|
5479 retarray->offset = 0; |
|
5480 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5481 |
|
5482 - alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5483 - * extent[rank-1]; |
|
5484 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5485 |
|
5486 if (alloc_size == 0) |
|
5487 { |
|
5488 @@ -111,7 +110,7 @@ |
|
5489 return; |
|
5490 } |
|
5491 else |
|
5492 - retarray->base_addr = xmalloc (alloc_size); |
|
5493 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); |
|
5494 } |
|
5495 else |
|
5496 { |
|
5497 Index: gcc-4.8_branch/libgfortran/generated/transpose_r8.c |
|
5498 =================================================================== |
|
5499 --- gcc-4.8_branch/libgfortran/generated/transpose_r8.c (revision 213312) |
|
5500 +++ gcc-4.8_branch/libgfortran/generated/transpose_r8.c (revision 213313) |
|
5501 @@ -60,7 +60,8 @@ |
|
5502 GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0) - 1, |
|
5503 GFC_DESCRIPTOR_EXTENT(source, 1)); |
|
5504 |
|
5505 - ret->base_addr = xmalloc (sizeof (GFC_REAL_8) * size0 ((array_t *) ret)); |
|
5506 + ret->base_addr = xmallocarray (size0 ((array_t *) ret), |
|
5507 + sizeof (GFC_REAL_8)); |
|
5508 ret->offset = 0; |
|
5509 } else if (unlikely (compile_options.bounds_check)) |
|
5510 { |
|
5511 Index: gcc-4.8_branch/libgfortran/generated/cshift1_8.c |
|
5512 =================================================================== |
|
5513 --- gcc-4.8_branch/libgfortran/generated/cshift1_8.c (revision 213312) |
|
5514 +++ gcc-4.8_branch/libgfortran/generated/cshift1_8.c (revision 213313) |
|
5515 @@ -80,7 +80,7 @@ |
|
5516 { |
|
5517 int i; |
|
5518 |
|
5519 - ret->base_addr = xmalloc (size * arraysize); |
|
5520 + ret->base_addr = xmallocarray (arraysize, size); |
|
5521 ret->offset = 0; |
|
5522 ret->dtype = array->dtype; |
|
5523 for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++) |
|
5524 Index: gcc-4.8_branch/libgfortran/generated/matmul_i4.c |
|
5525 =================================================================== |
|
5526 --- gcc-4.8_branch/libgfortran/generated/matmul_i4.c (revision 213312) |
|
5527 +++ gcc-4.8_branch/libgfortran/generated/matmul_i4.c (revision 213313) |
|
5528 @@ -124,7 +124,7 @@ |
|
5529 } |
|
5530 |
|
5531 retarray->base_addr |
|
5532 - = xmalloc (sizeof (GFC_INTEGER_4) * size0 ((array_t *) retarray)); |
|
5533 + = xmallocarray (size0 ((array_t *) retarray), sizeof (GFC_INTEGER_4)); |
|
5534 retarray->offset = 0; |
|
5535 } |
|
5536 else if (unlikely (compile_options.bounds_check)) |
|
5537 Index: gcc-4.8_branch/libgfortran/generated/pack_r10.c |
|
5538 =================================================================== |
|
5539 --- gcc-4.8_branch/libgfortran/generated/pack_r10.c (revision 213312) |
|
5540 +++ gcc-4.8_branch/libgfortran/generated/pack_r10.c (revision 213313) |
|
5541 @@ -167,8 +167,8 @@ |
|
5542 |
|
5543 ret->offset = 0; |
|
5544 |
|
5545 - /* xmalloc allocates a single byte for zero size. */ |
|
5546 - ret->base_addr = xmalloc (sizeof (GFC_REAL_10) * total); |
|
5547 + /* xmallocarray allocates a single byte for zero size. */ |
|
5548 + ret->base_addr = xmallocarray (total, sizeof (GFC_REAL_10)); |
|
5549 |
|
5550 if (total == 0) |
|
5551 return; |
|
5552 Index: gcc-4.8_branch/libgfortran/generated/minloc1_16_i2.c |
|
5553 =================================================================== |
|
5554 --- gcc-4.8_branch/libgfortran/generated/minloc1_16_i2.c (revision 213312) |
|
5555 +++ gcc-4.8_branch/libgfortran/generated/minloc1_16_i2.c (revision 213313) |
|
5556 @@ -98,10 +98,9 @@ |
|
5557 retarray->offset = 0; |
|
5558 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5559 |
|
5560 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5561 - * extent[rank-1]; |
|
5562 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5563 |
|
5564 - retarray->base_addr = xmalloc (alloc_size); |
|
5565 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
5566 if (alloc_size == 0) |
|
5567 { |
|
5568 /* Make sure we have a zero-sized array. */ |
|
5569 @@ -294,8 +293,7 @@ |
|
5570 |
|
5571 } |
|
5572 |
|
5573 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5574 - * extent[rank-1]; |
|
5575 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5576 |
|
5577 retarray->offset = 0; |
|
5578 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5579 @@ -307,7 +305,7 @@ |
|
5580 return; |
|
5581 } |
|
5582 else |
|
5583 - retarray->base_addr = xmalloc (alloc_size); |
|
5584 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
5585 |
|
5586 } |
|
5587 else |
|
5588 @@ -485,8 +483,7 @@ |
|
5589 retarray->offset = 0; |
|
5590 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5591 |
|
5592 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5593 - * extent[rank-1]; |
|
5594 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5595 |
|
5596 if (alloc_size == 0) |
|
5597 { |
|
5598 @@ -495,7 +492,7 @@ |
|
5599 return; |
|
5600 } |
|
5601 else |
|
5602 - retarray->base_addr = xmalloc (alloc_size); |
|
5603 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
5604 } |
|
5605 else |
|
5606 { |
|
5607 Index: gcc-4.8_branch/libgfortran/generated/in_pack_i8.c |
|
5608 =================================================================== |
|
5609 --- gcc-4.8_branch/libgfortran/generated/in_pack_i8.c (revision 213312) |
|
5610 +++ gcc-4.8_branch/libgfortran/generated/in_pack_i8.c (revision 213313) |
|
5611 @@ -76,7 +76,7 @@ |
|
5612 return source->base_addr; |
|
5613 |
|
5614 /* Allocate storage for the destination. */ |
|
5615 - destptr = (GFC_INTEGER_8 *)xmalloc (ssize * sizeof (GFC_INTEGER_8)); |
|
5616 + destptr = xmallocarray (ssize, sizeof (GFC_INTEGER_8)); |
|
5617 dest = destptr; |
|
5618 src = source->base_addr; |
|
5619 stride0 = stride[0]; |
|
5620 Index: gcc-4.8_branch/libgfortran/generated/transpose_r16.c |
|
5621 =================================================================== |
|
5622 --- gcc-4.8_branch/libgfortran/generated/transpose_r16.c (revision 213312) |
|
5623 +++ gcc-4.8_branch/libgfortran/generated/transpose_r16.c (revision 213313) |
|
5624 @@ -60,7 +60,8 @@ |
|
5625 GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0) - 1, |
|
5626 GFC_DESCRIPTOR_EXTENT(source, 1)); |
|
5627 |
|
5628 - ret->base_addr = xmalloc (sizeof (GFC_REAL_16) * size0 ((array_t *) ret)); |
|
5629 + ret->base_addr = xmallocarray (size0 ((array_t *) ret), |
|
5630 + sizeof (GFC_REAL_16)); |
|
5631 ret->offset = 0; |
|
5632 } else if (unlikely (compile_options.bounds_check)) |
|
5633 { |
|
5634 Index: gcc-4.8_branch/libgfortran/generated/minloc1_4_i4.c |
|
5635 =================================================================== |
|
5636 --- gcc-4.8_branch/libgfortran/generated/minloc1_4_i4.c (revision 213312) |
|
5637 +++ gcc-4.8_branch/libgfortran/generated/minloc1_4_i4.c (revision 213313) |
|
5638 @@ -98,10 +98,9 @@ |
|
5639 retarray->offset = 0; |
|
5640 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5641 |
|
5642 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5643 - * extent[rank-1]; |
|
5644 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5645 |
|
5646 - retarray->base_addr = xmalloc (alloc_size); |
|
5647 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
5648 if (alloc_size == 0) |
|
5649 { |
|
5650 /* Make sure we have a zero-sized array. */ |
|
5651 @@ -294,8 +293,7 @@ |
|
5652 |
|
5653 } |
|
5654 |
|
5655 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5656 - * extent[rank-1]; |
|
5657 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5658 |
|
5659 retarray->offset = 0; |
|
5660 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5661 @@ -307,7 +305,7 @@ |
|
5662 return; |
|
5663 } |
|
5664 else |
|
5665 - retarray->base_addr = xmalloc (alloc_size); |
|
5666 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
5667 |
|
5668 } |
|
5669 else |
|
5670 @@ -485,8 +483,7 @@ |
|
5671 retarray->offset = 0; |
|
5672 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5673 |
|
5674 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5675 - * extent[rank-1]; |
|
5676 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5677 |
|
5678 if (alloc_size == 0) |
|
5679 { |
|
5680 @@ -495,7 +492,7 @@ |
|
5681 return; |
|
5682 } |
|
5683 else |
|
5684 - retarray->base_addr = xmalloc (alloc_size); |
|
5685 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
5686 } |
|
5687 else |
|
5688 { |
|
5689 Index: gcc-4.8_branch/libgfortran/generated/maxval_i1.c |
|
5690 =================================================================== |
|
5691 --- gcc-4.8_branch/libgfortran/generated/maxval_i1.c (revision 213312) |
|
5692 +++ gcc-4.8_branch/libgfortran/generated/maxval_i1.c (revision 213313) |
|
5693 @@ -97,10 +97,9 @@ |
|
5694 retarray->offset = 0; |
|
5695 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5696 |
|
5697 - alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5698 - * extent[rank-1]; |
|
5699 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5700 |
|
5701 - retarray->base_addr = xmalloc (alloc_size); |
|
5702 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); |
|
5703 if (alloc_size == 0) |
|
5704 { |
|
5705 /* Make sure we have a zero-sized array. */ |
|
5706 @@ -286,8 +285,7 @@ |
|
5707 |
|
5708 } |
|
5709 |
|
5710 - alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5711 - * extent[rank-1]; |
|
5712 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5713 |
|
5714 retarray->offset = 0; |
|
5715 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5716 @@ -299,7 +297,7 @@ |
|
5717 return; |
|
5718 } |
|
5719 else |
|
5720 - retarray->base_addr = xmalloc (alloc_size); |
|
5721 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); |
|
5722 |
|
5723 } |
|
5724 else |
|
5725 @@ -472,8 +470,7 @@ |
|
5726 retarray->offset = 0; |
|
5727 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5728 |
|
5729 - alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5730 - * extent[rank-1]; |
|
5731 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5732 |
|
5733 if (alloc_size == 0) |
|
5734 { |
|
5735 @@ -482,7 +479,7 @@ |
|
5736 return; |
|
5737 } |
|
5738 else |
|
5739 - retarray->base_addr = xmalloc (alloc_size); |
|
5740 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); |
|
5741 } |
|
5742 else |
|
5743 { |
|
5744 Index: gcc-4.8_branch/libgfortran/generated/product_c16.c |
|
5745 =================================================================== |
|
5746 --- gcc-4.8_branch/libgfortran/generated/product_c16.c (revision 213312) |
|
5747 +++ gcc-4.8_branch/libgfortran/generated/product_c16.c (revision 213313) |
|
5748 @@ -97,10 +97,9 @@ |
|
5749 retarray->offset = 0; |
|
5750 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5751 |
|
5752 - alloc_size = sizeof (GFC_COMPLEX_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5753 - * extent[rank-1]; |
|
5754 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5755 |
|
5756 - retarray->base_addr = xmalloc (alloc_size); |
|
5757 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_16)); |
|
5758 if (alloc_size == 0) |
|
5759 { |
|
5760 /* Make sure we have a zero-sized array. */ |
|
5761 @@ -272,8 +271,7 @@ |
|
5762 |
|
5763 } |
|
5764 |
|
5765 - alloc_size = sizeof (GFC_COMPLEX_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5766 - * extent[rank-1]; |
|
5767 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5768 |
|
5769 retarray->offset = 0; |
|
5770 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5771 @@ -285,7 +283,7 @@ |
|
5772 return; |
|
5773 } |
|
5774 else |
|
5775 - retarray->base_addr = xmalloc (alloc_size); |
|
5776 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_16)); |
|
5777 |
|
5778 } |
|
5779 else |
|
5780 @@ -430,8 +428,7 @@ |
|
5781 retarray->offset = 0; |
|
5782 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5783 |
|
5784 - alloc_size = sizeof (GFC_COMPLEX_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5785 - * extent[rank-1]; |
|
5786 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5787 |
|
5788 if (alloc_size == 0) |
|
5789 { |
|
5790 @@ -440,7 +437,7 @@ |
|
5791 return; |
|
5792 } |
|
5793 else |
|
5794 - retarray->base_addr = xmalloc (alloc_size); |
|
5795 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_16)); |
|
5796 } |
|
5797 else |
|
5798 { |
|
5799 Index: gcc-4.8_branch/libgfortran/generated/reshape_r4.c |
|
5800 =================================================================== |
|
5801 --- gcc-4.8_branch/libgfortran/generated/reshape_r4.c (revision 213312) |
|
5802 +++ gcc-4.8_branch/libgfortran/generated/reshape_r4.c (revision 213313) |
|
5803 @@ -111,11 +111,11 @@ |
|
5804 ret->offset = 0; |
|
5805 |
|
5806 if (unlikely (rs < 1)) |
|
5807 - alloc_size = 1; |
|
5808 + alloc_size = 0; |
|
5809 else |
|
5810 - alloc_size = rs * sizeof (GFC_REAL_4); |
|
5811 + alloc_size = rs; |
|
5812 |
|
5813 - ret->base_addr = xmalloc (alloc_size); |
|
5814 + ret->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_4)); |
|
5815 ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim; |
|
5816 } |
|
5817 |
|
5818 Index: gcc-4.8_branch/libgfortran/generated/iany_i8.c |
|
5819 =================================================================== |
|
5820 --- gcc-4.8_branch/libgfortran/generated/iany_i8.c (revision 213312) |
|
5821 +++ gcc-4.8_branch/libgfortran/generated/iany_i8.c (revision 213313) |
|
5822 @@ -97,10 +97,9 @@ |
|
5823 retarray->offset = 0; |
|
5824 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5825 |
|
5826 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5827 - * extent[rank-1]; |
|
5828 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5829 |
|
5830 - retarray->base_addr = xmalloc (alloc_size); |
|
5831 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
5832 if (alloc_size == 0) |
|
5833 { |
|
5834 /* Make sure we have a zero-sized array. */ |
|
5835 @@ -272,8 +271,7 @@ |
|
5836 |
|
5837 } |
|
5838 |
|
5839 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5840 - * extent[rank-1]; |
|
5841 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5842 |
|
5843 retarray->offset = 0; |
|
5844 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5845 @@ -285,7 +283,7 @@ |
|
5846 return; |
|
5847 } |
|
5848 else |
|
5849 - retarray->base_addr = xmalloc (alloc_size); |
|
5850 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
5851 |
|
5852 } |
|
5853 else |
|
5854 @@ -430,8 +428,7 @@ |
|
5855 retarray->offset = 0; |
|
5856 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5857 |
|
5858 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5859 - * extent[rank-1]; |
|
5860 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5861 |
|
5862 if (alloc_size == 0) |
|
5863 { |
|
5864 @@ -440,7 +437,7 @@ |
|
5865 return; |
|
5866 } |
|
5867 else |
|
5868 - retarray->base_addr = xmalloc (alloc_size); |
|
5869 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
5870 } |
|
5871 else |
|
5872 { |
|
5873 Index: gcc-4.8_branch/libgfortran/generated/cshift1_16.c |
|
5874 =================================================================== |
|
5875 --- gcc-4.8_branch/libgfortran/generated/cshift1_16.c (revision 213312) |
|
5876 +++ gcc-4.8_branch/libgfortran/generated/cshift1_16.c (revision 213313) |
|
5877 @@ -80,7 +80,7 @@ |
|
5878 { |
|
5879 int i; |
|
5880 |
|
5881 - ret->base_addr = xmalloc (size * arraysize); |
|
5882 + ret->base_addr = xmallocarray (arraysize, size); |
|
5883 ret->offset = 0; |
|
5884 ret->dtype = array->dtype; |
|
5885 for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++) |
|
5886 Index: gcc-4.8_branch/libgfortran/generated/maxloc0_4_i1.c |
|
5887 =================================================================== |
|
5888 --- gcc-4.8_branch/libgfortran/generated/maxloc0_4_i1.c (revision 213312) |
|
5889 +++ gcc-4.8_branch/libgfortran/generated/maxloc0_4_i1.c (revision 213313) |
|
5890 @@ -58,7 +58,7 @@ |
|
5891 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
5892 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
5893 retarray->offset = 0; |
|
5894 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
5895 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
5896 } |
|
5897 else |
|
5898 { |
|
5899 @@ -199,7 +199,7 @@ |
|
5900 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
5901 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
5902 retarray->offset = 0; |
|
5903 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
5904 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
5905 } |
|
5906 else |
|
5907 { |
|
5908 @@ -367,7 +367,7 @@ |
|
5909 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
5910 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
5911 retarray->offset = 0; |
|
5912 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
5913 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
5914 } |
|
5915 else if (unlikely (compile_options.bounds_check)) |
|
5916 { |
|
5917 Index: gcc-4.8_branch/libgfortran/generated/minloc0_4_i8.c |
|
5918 =================================================================== |
|
5919 --- gcc-4.8_branch/libgfortran/generated/minloc0_4_i8.c (revision 213312) |
|
5920 +++ gcc-4.8_branch/libgfortran/generated/minloc0_4_i8.c (revision 213313) |
|
5921 @@ -58,7 +58,7 @@ |
|
5922 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
5923 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
5924 retarray->offset = 0; |
|
5925 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
5926 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
5927 } |
|
5928 else |
|
5929 { |
|
5930 @@ -199,7 +199,7 @@ |
|
5931 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
5932 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
5933 retarray->offset = 0; |
|
5934 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
5935 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
5936 } |
|
5937 else |
|
5938 { |
|
5939 @@ -367,7 +367,7 @@ |
|
5940 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
5941 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
5942 retarray->offset = 0; |
|
5943 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
5944 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
5945 } |
|
5946 else if (unlikely (compile_options.bounds_check)) |
|
5947 { |
|
5948 Index: gcc-4.8_branch/libgfortran/generated/spread_c16.c |
|
5949 =================================================================== |
|
5950 --- gcc-4.8_branch/libgfortran/generated/spread_c16.c (revision 213312) |
|
5951 +++ gcc-4.8_branch/libgfortran/generated/spread_c16.c (revision 213313) |
|
5952 @@ -101,8 +101,8 @@ |
|
5953 } |
|
5954 ret->offset = 0; |
|
5955 |
|
5956 - /* xmalloc allocates a single byte for zero size. */ |
|
5957 - ret->base_addr = xmalloc (rs * sizeof(GFC_COMPLEX_16)); |
|
5958 + /* xmallocarray allocates a single byte for zero size. */ |
|
5959 + ret->base_addr = xmallocarray (rs, sizeof(GFC_COMPLEX_16)); |
|
5960 if (rs <= 0) |
|
5961 return; |
|
5962 } |
|
5963 @@ -244,7 +244,7 @@ |
|
5964 |
|
5965 if (ret->base_addr == NULL) |
|
5966 { |
|
5967 - ret->base_addr = xmalloc (ncopies * sizeof (GFC_COMPLEX_16)); |
|
5968 + ret->base_addr = xmallocarray (ncopies, sizeof (GFC_COMPLEX_16)); |
|
5969 ret->offset = 0; |
|
5970 GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1); |
|
5971 } |
|
5972 Index: gcc-4.8_branch/libgfortran/generated/maxval_r4.c |
|
5973 =================================================================== |
|
5974 --- gcc-4.8_branch/libgfortran/generated/maxval_r4.c (revision 213312) |
|
5975 +++ gcc-4.8_branch/libgfortran/generated/maxval_r4.c (revision 213313) |
|
5976 @@ -97,10 +97,9 @@ |
|
5977 retarray->offset = 0; |
|
5978 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5979 |
|
5980 - alloc_size = sizeof (GFC_REAL_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5981 - * extent[rank-1]; |
|
5982 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5983 |
|
5984 - retarray->base_addr = xmalloc (alloc_size); |
|
5985 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_4)); |
|
5986 if (alloc_size == 0) |
|
5987 { |
|
5988 /* Make sure we have a zero-sized array. */ |
|
5989 @@ -286,8 +285,7 @@ |
|
5990 |
|
5991 } |
|
5992 |
|
5993 - alloc_size = sizeof (GFC_REAL_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
5994 - * extent[rank-1]; |
|
5995 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
5996 |
|
5997 retarray->offset = 0; |
|
5998 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
5999 @@ -299,7 +297,7 @@ |
|
6000 return; |
|
6001 } |
|
6002 else |
|
6003 - retarray->base_addr = xmalloc (alloc_size); |
|
6004 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_4)); |
|
6005 |
|
6006 } |
|
6007 else |
|
6008 @@ -472,8 +470,7 @@ |
|
6009 retarray->offset = 0; |
|
6010 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6011 |
|
6012 - alloc_size = sizeof (GFC_REAL_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6013 - * extent[rank-1]; |
|
6014 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6015 |
|
6016 if (alloc_size == 0) |
|
6017 { |
|
6018 @@ -482,7 +479,7 @@ |
|
6019 return; |
|
6020 } |
|
6021 else |
|
6022 - retarray->base_addr = xmalloc (alloc_size); |
|
6023 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_4)); |
|
6024 } |
|
6025 else |
|
6026 { |
|
6027 Index: gcc-4.8_branch/libgfortran/generated/minval_r8.c |
|
6028 =================================================================== |
|
6029 --- gcc-4.8_branch/libgfortran/generated/minval_r8.c (revision 213312) |
|
6030 +++ gcc-4.8_branch/libgfortran/generated/minval_r8.c (revision 213313) |
|
6031 @@ -97,10 +97,9 @@ |
|
6032 retarray->offset = 0; |
|
6033 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6034 |
|
6035 - alloc_size = sizeof (GFC_REAL_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6036 - * extent[rank-1]; |
|
6037 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6038 |
|
6039 - retarray->base_addr = xmalloc (alloc_size); |
|
6040 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_8)); |
|
6041 if (alloc_size == 0) |
|
6042 { |
|
6043 /* Make sure we have a zero-sized array. */ |
|
6044 @@ -286,8 +285,7 @@ |
|
6045 |
|
6046 } |
|
6047 |
|
6048 - alloc_size = sizeof (GFC_REAL_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6049 - * extent[rank-1]; |
|
6050 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6051 |
|
6052 retarray->offset = 0; |
|
6053 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6054 @@ -299,7 +297,7 @@ |
|
6055 return; |
|
6056 } |
|
6057 else |
|
6058 - retarray->base_addr = xmalloc (alloc_size); |
|
6059 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_8)); |
|
6060 |
|
6061 } |
|
6062 else |
|
6063 @@ -472,8 +470,7 @@ |
|
6064 retarray->offset = 0; |
|
6065 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6066 |
|
6067 - alloc_size = sizeof (GFC_REAL_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6068 - * extent[rank-1]; |
|
6069 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6070 |
|
6071 if (alloc_size == 0) |
|
6072 { |
|
6073 @@ -482,7 +479,7 @@ |
|
6074 return; |
|
6075 } |
|
6076 else |
|
6077 - retarray->base_addr = xmalloc (alloc_size); |
|
6078 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_8)); |
|
6079 } |
|
6080 else |
|
6081 { |
|
6082 Index: gcc-4.8_branch/libgfortran/generated/minloc1_16_r16.c |
|
6083 =================================================================== |
|
6084 --- gcc-4.8_branch/libgfortran/generated/minloc1_16_r16.c (revision 213312) |
|
6085 +++ gcc-4.8_branch/libgfortran/generated/minloc1_16_r16.c (revision 213313) |
|
6086 @@ -98,10 +98,9 @@ |
|
6087 retarray->offset = 0; |
|
6088 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6089 |
|
6090 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6091 - * extent[rank-1]; |
|
6092 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6093 |
|
6094 - retarray->base_addr = xmalloc (alloc_size); |
|
6095 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
6096 if (alloc_size == 0) |
|
6097 { |
|
6098 /* Make sure we have a zero-sized array. */ |
|
6099 @@ -294,8 +293,7 @@ |
|
6100 |
|
6101 } |
|
6102 |
|
6103 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6104 - * extent[rank-1]; |
|
6105 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6106 |
|
6107 retarray->offset = 0; |
|
6108 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6109 @@ -307,7 +305,7 @@ |
|
6110 return; |
|
6111 } |
|
6112 else |
|
6113 - retarray->base_addr = xmalloc (alloc_size); |
|
6114 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
6115 |
|
6116 } |
|
6117 else |
|
6118 @@ -485,8 +483,7 @@ |
|
6119 retarray->offset = 0; |
|
6120 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6121 |
|
6122 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6123 - * extent[rank-1]; |
|
6124 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6125 |
|
6126 if (alloc_size == 0) |
|
6127 { |
|
6128 @@ -495,7 +492,7 @@ |
|
6129 return; |
|
6130 } |
|
6131 else |
|
6132 - retarray->base_addr = xmalloc (alloc_size); |
|
6133 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
6134 } |
|
6135 else |
|
6136 { |
|
6137 Index: gcc-4.8_branch/libgfortran/generated/unpack_i16.c |
|
6138 =================================================================== |
|
6139 --- gcc-4.8_branch/libgfortran/generated/unpack_i16.c (revision 213312) |
|
6140 +++ gcc-4.8_branch/libgfortran/generated/unpack_i16.c (revision 213313) |
|
6141 @@ -99,7 +99,7 @@ |
|
6142 rs *= extent[n]; |
|
6143 } |
|
6144 ret->offset = 0; |
|
6145 - ret->base_addr = xmalloc (rs * sizeof (GFC_INTEGER_16)); |
|
6146 + ret->base_addr = xmallocarray (rs, sizeof (GFC_INTEGER_16)); |
|
6147 } |
|
6148 else |
|
6149 { |
|
6150 @@ -244,7 +244,7 @@ |
|
6151 rs *= extent[n]; |
|
6152 } |
|
6153 ret->offset = 0; |
|
6154 - ret->base_addr = xmalloc (rs * sizeof (GFC_INTEGER_16)); |
|
6155 + ret->base_addr = xmallocarray (rs, sizeof (GFC_INTEGER_16)); |
|
6156 } |
|
6157 else |
|
6158 { |
|
6159 Index: gcc-4.8_branch/libgfortran/generated/sum_i8.c |
|
6160 =================================================================== |
|
6161 --- gcc-4.8_branch/libgfortran/generated/sum_i8.c (revision 213312) |
|
6162 +++ gcc-4.8_branch/libgfortran/generated/sum_i8.c (revision 213313) |
|
6163 @@ -97,10 +97,9 @@ |
|
6164 retarray->offset = 0; |
|
6165 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6166 |
|
6167 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6168 - * extent[rank-1]; |
|
6169 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6170 |
|
6171 - retarray->base_addr = xmalloc (alloc_size); |
|
6172 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
6173 if (alloc_size == 0) |
|
6174 { |
|
6175 /* Make sure we have a zero-sized array. */ |
|
6176 @@ -272,8 +271,7 @@ |
|
6177 |
|
6178 } |
|
6179 |
|
6180 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6181 - * extent[rank-1]; |
|
6182 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6183 |
|
6184 retarray->offset = 0; |
|
6185 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6186 @@ -285,7 +283,7 @@ |
|
6187 return; |
|
6188 } |
|
6189 else |
|
6190 - retarray->base_addr = xmalloc (alloc_size); |
|
6191 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
6192 |
|
6193 } |
|
6194 else |
|
6195 @@ -430,8 +428,7 @@ |
|
6196 retarray->offset = 0; |
|
6197 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6198 |
|
6199 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6200 - * extent[rank-1]; |
|
6201 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6202 |
|
6203 if (alloc_size == 0) |
|
6204 { |
|
6205 @@ -440,7 +437,7 @@ |
|
6206 return; |
|
6207 } |
|
6208 else |
|
6209 - retarray->base_addr = xmalloc (alloc_size); |
|
6210 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
6211 } |
|
6212 else |
|
6213 { |
|
6214 Index: gcc-4.8_branch/libgfortran/generated/pack_i1.c |
|
6215 =================================================================== |
|
6216 --- gcc-4.8_branch/libgfortran/generated/pack_i1.c (revision 213312) |
|
6217 +++ gcc-4.8_branch/libgfortran/generated/pack_i1.c (revision 213313) |
|
6218 @@ -167,8 +167,8 @@ |
|
6219 |
|
6220 ret->offset = 0; |
|
6221 |
|
6222 - /* xmalloc allocates a single byte for zero size. */ |
|
6223 - ret->base_addr = xmalloc (sizeof (GFC_INTEGER_1) * total); |
|
6224 + /* xmallocarray allocates a single byte for zero size. */ |
|
6225 + ret->base_addr = xmallocarray (total, sizeof (GFC_INTEGER_1)); |
|
6226 |
|
6227 if (total == 0) |
|
6228 return; |
|
6229 Index: gcc-4.8_branch/libgfortran/generated/any_l16.c |
|
6230 =================================================================== |
|
6231 --- gcc-4.8_branch/libgfortran/generated/any_l16.c (revision 213312) |
|
6232 +++ gcc-4.8_branch/libgfortran/generated/any_l16.c (revision 213313) |
|
6233 @@ -101,8 +101,7 @@ |
|
6234 retarray->offset = 0; |
|
6235 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6236 |
|
6237 - alloc_size = sizeof (GFC_LOGICAL_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6238 - * extent[rank-1]; |
|
6239 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6240 |
|
6241 if (alloc_size == 0) |
|
6242 { |
|
6243 @@ -111,7 +110,7 @@ |
|
6244 return; |
|
6245 } |
|
6246 else |
|
6247 - retarray->base_addr = xmalloc (alloc_size); |
|
6248 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_LOGICAL_16)); |
|
6249 } |
|
6250 else |
|
6251 { |
|
6252 Index: gcc-4.8_branch/libgfortran/generated/spread_i8.c |
|
6253 =================================================================== |
|
6254 --- gcc-4.8_branch/libgfortran/generated/spread_i8.c (revision 213312) |
|
6255 +++ gcc-4.8_branch/libgfortran/generated/spread_i8.c (revision 213313) |
|
6256 @@ -101,8 +101,8 @@ |
|
6257 } |
|
6258 ret->offset = 0; |
|
6259 |
|
6260 - /* xmalloc allocates a single byte for zero size. */ |
|
6261 - ret->base_addr = xmalloc (rs * sizeof(GFC_INTEGER_8)); |
|
6262 + /* xmallocarray allocates a single byte for zero size. */ |
|
6263 + ret->base_addr = xmallocarray (rs, sizeof(GFC_INTEGER_8)); |
|
6264 if (rs <= 0) |
|
6265 return; |
|
6266 } |
|
6267 @@ -244,7 +244,7 @@ |
|
6268 |
|
6269 if (ret->base_addr == NULL) |
|
6270 { |
|
6271 - ret->base_addr = xmalloc (ncopies * sizeof (GFC_INTEGER_8)); |
|
6272 + ret->base_addr = xmallocarray (ncopies, sizeof (GFC_INTEGER_8)); |
|
6273 ret->offset = 0; |
|
6274 GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1); |
|
6275 } |
|
6276 Index: gcc-4.8_branch/libgfortran/generated/maxval_i2.c |
|
6277 =================================================================== |
|
6278 --- gcc-4.8_branch/libgfortran/generated/maxval_i2.c (revision 213312) |
|
6279 +++ gcc-4.8_branch/libgfortran/generated/maxval_i2.c (revision 213313) |
|
6280 @@ -97,10 +97,9 @@ |
|
6281 retarray->offset = 0; |
|
6282 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6283 |
|
6284 - alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6285 - * extent[rank-1]; |
|
6286 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6287 |
|
6288 - retarray->base_addr = xmalloc (alloc_size); |
|
6289 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); |
|
6290 if (alloc_size == 0) |
|
6291 { |
|
6292 /* Make sure we have a zero-sized array. */ |
|
6293 @@ -286,8 +285,7 @@ |
|
6294 |
|
6295 } |
|
6296 |
|
6297 - alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6298 - * extent[rank-1]; |
|
6299 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6300 |
|
6301 retarray->offset = 0; |
|
6302 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6303 @@ -299,7 +297,7 @@ |
|
6304 return; |
|
6305 } |
|
6306 else |
|
6307 - retarray->base_addr = xmalloc (alloc_size); |
|
6308 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); |
|
6309 |
|
6310 } |
|
6311 else |
|
6312 @@ -472,8 +470,7 @@ |
|
6313 retarray->offset = 0; |
|
6314 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6315 |
|
6316 - alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6317 - * extent[rank-1]; |
|
6318 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6319 |
|
6320 if (alloc_size == 0) |
|
6321 { |
|
6322 @@ -482,7 +479,7 @@ |
|
6323 return; |
|
6324 } |
|
6325 else |
|
6326 - retarray->base_addr = xmalloc (alloc_size); |
|
6327 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); |
|
6328 } |
|
6329 else |
|
6330 { |
|
6331 Index: gcc-4.8_branch/libgfortran/generated/maxloc1_8_i4.c |
|
6332 =================================================================== |
|
6333 --- gcc-4.8_branch/libgfortran/generated/maxloc1_8_i4.c (revision 213312) |
|
6334 +++ gcc-4.8_branch/libgfortran/generated/maxloc1_8_i4.c (revision 213313) |
|
6335 @@ -98,10 +98,9 @@ |
|
6336 retarray->offset = 0; |
|
6337 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6338 |
|
6339 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6340 - * extent[rank-1]; |
|
6341 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6342 |
|
6343 - retarray->base_addr = xmalloc (alloc_size); |
|
6344 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
6345 if (alloc_size == 0) |
|
6346 { |
|
6347 /* Make sure we have a zero-sized array. */ |
|
6348 @@ -294,8 +293,7 @@ |
|
6349 |
|
6350 } |
|
6351 |
|
6352 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6353 - * extent[rank-1]; |
|
6354 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6355 |
|
6356 retarray->offset = 0; |
|
6357 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6358 @@ -307,7 +305,7 @@ |
|
6359 return; |
|
6360 } |
|
6361 else |
|
6362 - retarray->base_addr = xmalloc (alloc_size); |
|
6363 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
6364 |
|
6365 } |
|
6366 else |
|
6367 @@ -485,8 +483,7 @@ |
|
6368 retarray->offset = 0; |
|
6369 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6370 |
|
6371 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6372 - * extent[rank-1]; |
|
6373 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6374 |
|
6375 if (alloc_size == 0) |
|
6376 { |
|
6377 @@ -495,7 +492,7 @@ |
|
6378 return; |
|
6379 } |
|
6380 else |
|
6381 - retarray->base_addr = xmalloc (alloc_size); |
|
6382 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
6383 } |
|
6384 else |
|
6385 { |
|
6386 Index: gcc-4.8_branch/libgfortran/generated/unpack_r8.c |
|
6387 =================================================================== |
|
6388 --- gcc-4.8_branch/libgfortran/generated/unpack_r8.c (revision 213312) |
|
6389 +++ gcc-4.8_branch/libgfortran/generated/unpack_r8.c (revision 213313) |
|
6390 @@ -99,7 +99,7 @@ |
|
6391 rs *= extent[n]; |
|
6392 } |
|
6393 ret->offset = 0; |
|
6394 - ret->base_addr = xmalloc (rs * sizeof (GFC_REAL_8)); |
|
6395 + ret->base_addr = xmallocarray (rs, sizeof (GFC_REAL_8)); |
|
6396 } |
|
6397 else |
|
6398 { |
|
6399 @@ -244,7 +244,7 @@ |
|
6400 rs *= extent[n]; |
|
6401 } |
|
6402 ret->offset = 0; |
|
6403 - ret->base_addr = xmalloc (rs * sizeof (GFC_REAL_8)); |
|
6404 + ret->base_addr = xmallocarray (rs, sizeof (GFC_REAL_8)); |
|
6405 } |
|
6406 else |
|
6407 { |
|
6408 Index: gcc-4.8_branch/libgfortran/generated/maxloc0_4_r4.c |
|
6409 =================================================================== |
|
6410 --- gcc-4.8_branch/libgfortran/generated/maxloc0_4_r4.c (revision 213312) |
|
6411 +++ gcc-4.8_branch/libgfortran/generated/maxloc0_4_r4.c (revision 213313) |
|
6412 @@ -58,7 +58,7 @@ |
|
6413 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
6414 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
6415 retarray->offset = 0; |
|
6416 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
6417 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
6418 } |
|
6419 else |
|
6420 { |
|
6421 @@ -199,7 +199,7 @@ |
|
6422 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
6423 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
6424 retarray->offset = 0; |
|
6425 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
6426 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
6427 } |
|
6428 else |
|
6429 { |
|
6430 @@ -367,7 +367,7 @@ |
|
6431 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
6432 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
6433 retarray->offset = 0; |
|
6434 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
6435 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
6436 } |
|
6437 else if (unlikely (compile_options.bounds_check)) |
|
6438 { |
|
6439 Index: gcc-4.8_branch/libgfortran/generated/all_l1.c |
|
6440 =================================================================== |
|
6441 --- gcc-4.8_branch/libgfortran/generated/all_l1.c (revision 213312) |
|
6442 +++ gcc-4.8_branch/libgfortran/generated/all_l1.c (revision 213313) |
|
6443 @@ -101,8 +101,7 @@ |
|
6444 retarray->offset = 0; |
|
6445 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6446 |
|
6447 - alloc_size = sizeof (GFC_LOGICAL_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6448 - * extent[rank-1]; |
|
6449 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6450 |
|
6451 if (alloc_size == 0) |
|
6452 { |
|
6453 @@ -111,7 +110,7 @@ |
|
6454 return; |
|
6455 } |
|
6456 else |
|
6457 - retarray->base_addr = xmalloc (alloc_size); |
|
6458 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_LOGICAL_1)); |
|
6459 } |
|
6460 else |
|
6461 { |
|
6462 Index: gcc-4.8_branch/libgfortran/generated/matmul_r8.c |
|
6463 =================================================================== |
|
6464 --- gcc-4.8_branch/libgfortran/generated/matmul_r8.c (revision 213312) |
|
6465 +++ gcc-4.8_branch/libgfortran/generated/matmul_r8.c (revision 213313) |
|
6466 @@ -124,7 +124,7 @@ |
|
6467 } |
|
6468 |
|
6469 retarray->base_addr |
|
6470 - = xmalloc (sizeof (GFC_REAL_8) * size0 ((array_t *) retarray)); |
|
6471 + = xmallocarray (size0 ((array_t *) retarray), sizeof (GFC_REAL_8)); |
|
6472 retarray->offset = 0; |
|
6473 } |
|
6474 else if (unlikely (compile_options.bounds_check)) |
|
6475 Index: gcc-4.8_branch/libgfortran/generated/minloc0_4_r16.c |
|
6476 =================================================================== |
|
6477 --- gcc-4.8_branch/libgfortran/generated/minloc0_4_r16.c (revision 213312) |
|
6478 +++ gcc-4.8_branch/libgfortran/generated/minloc0_4_r16.c (revision 213313) |
|
6479 @@ -58,7 +58,7 @@ |
|
6480 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
6481 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
6482 retarray->offset = 0; |
|
6483 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
6484 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
6485 } |
|
6486 else |
|
6487 { |
|
6488 @@ -199,7 +199,7 @@ |
|
6489 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
6490 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
6491 retarray->offset = 0; |
|
6492 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
6493 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
6494 } |
|
6495 else |
|
6496 { |
|
6497 @@ -367,7 +367,7 @@ |
|
6498 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
6499 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
6500 retarray->offset = 0; |
|
6501 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
6502 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
6503 } |
|
6504 else if (unlikely (compile_options.bounds_check)) |
|
6505 { |
|
6506 Index: gcc-4.8_branch/libgfortran/generated/maxloc0_4_i2.c |
|
6507 =================================================================== |
|
6508 --- gcc-4.8_branch/libgfortran/generated/maxloc0_4_i2.c (revision 213312) |
|
6509 +++ gcc-4.8_branch/libgfortran/generated/maxloc0_4_i2.c (revision 213313) |
|
6510 @@ -58,7 +58,7 @@ |
|
6511 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
6512 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
6513 retarray->offset = 0; |
|
6514 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
6515 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
6516 } |
|
6517 else |
|
6518 { |
|
6519 @@ -199,7 +199,7 @@ |
|
6520 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
6521 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
6522 retarray->offset = 0; |
|
6523 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
6524 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
6525 } |
|
6526 else |
|
6527 { |
|
6528 @@ -367,7 +367,7 @@ |
|
6529 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
6530 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
6531 retarray->offset = 0; |
|
6532 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
6533 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
6534 } |
|
6535 else if (unlikely (compile_options.bounds_check)) |
|
6536 { |
|
6537 Index: gcc-4.8_branch/libgfortran/generated/minloc1_8_r16.c |
|
6538 =================================================================== |
|
6539 --- gcc-4.8_branch/libgfortran/generated/minloc1_8_r16.c (revision 213312) |
|
6540 +++ gcc-4.8_branch/libgfortran/generated/minloc1_8_r16.c (revision 213313) |
|
6541 @@ -98,10 +98,9 @@ |
|
6542 retarray->offset = 0; |
|
6543 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6544 |
|
6545 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6546 - * extent[rank-1]; |
|
6547 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6548 |
|
6549 - retarray->base_addr = xmalloc (alloc_size); |
|
6550 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
6551 if (alloc_size == 0) |
|
6552 { |
|
6553 /* Make sure we have a zero-sized array. */ |
|
6554 @@ -294,8 +293,7 @@ |
|
6555 |
|
6556 } |
|
6557 |
|
6558 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6559 - * extent[rank-1]; |
|
6560 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6561 |
|
6562 retarray->offset = 0; |
|
6563 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6564 @@ -307,7 +305,7 @@ |
|
6565 return; |
|
6566 } |
|
6567 else |
|
6568 - retarray->base_addr = xmalloc (alloc_size); |
|
6569 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
6570 |
|
6571 } |
|
6572 else |
|
6573 @@ -485,8 +483,7 @@ |
|
6574 retarray->offset = 0; |
|
6575 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6576 |
|
6577 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6578 - * extent[rank-1]; |
|
6579 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6580 |
|
6581 if (alloc_size == 0) |
|
6582 { |
|
6583 @@ -495,7 +492,7 @@ |
|
6584 return; |
|
6585 } |
|
6586 else |
|
6587 - retarray->base_addr = xmalloc (alloc_size); |
|
6588 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
6589 } |
|
6590 else |
|
6591 { |
|
6592 Index: gcc-4.8_branch/libgfortran/generated/pack_c10.c |
|
6593 =================================================================== |
|
6594 --- gcc-4.8_branch/libgfortran/generated/pack_c10.c (revision 213312) |
|
6595 +++ gcc-4.8_branch/libgfortran/generated/pack_c10.c (revision 213313) |
|
6596 @@ -167,8 +167,8 @@ |
|
6597 |
|
6598 ret->offset = 0; |
|
6599 |
|
6600 - /* xmalloc allocates a single byte for zero size. */ |
|
6601 - ret->base_addr = xmalloc (sizeof (GFC_COMPLEX_10) * total); |
|
6602 + /* xmallocarray allocates a single byte for zero size. */ |
|
6603 + ret->base_addr = xmallocarray (total, sizeof (GFC_COMPLEX_10)); |
|
6604 |
|
6605 if (total == 0) |
|
6606 return; |
|
6607 Index: gcc-4.8_branch/libgfortran/generated/pack_r4.c |
|
6608 =================================================================== |
|
6609 --- gcc-4.8_branch/libgfortran/generated/pack_r4.c (revision 213312) |
|
6610 +++ gcc-4.8_branch/libgfortran/generated/pack_r4.c (revision 213313) |
|
6611 @@ -167,8 +167,8 @@ |
|
6612 |
|
6613 ret->offset = 0; |
|
6614 |
|
6615 - /* xmalloc allocates a single byte for zero size. */ |
|
6616 - ret->base_addr = xmalloc (sizeof (GFC_REAL_4) * total); |
|
6617 + /* xmallocarray allocates a single byte for zero size. */ |
|
6618 + ret->base_addr = xmallocarray (total, sizeof (GFC_REAL_4)); |
|
6619 |
|
6620 if (total == 0) |
|
6621 return; |
|
6622 Index: gcc-4.8_branch/libgfortran/generated/transpose_c16.c |
|
6623 =================================================================== |
|
6624 --- gcc-4.8_branch/libgfortran/generated/transpose_c16.c (revision 213312) |
|
6625 +++ gcc-4.8_branch/libgfortran/generated/transpose_c16.c (revision 213313) |
|
6626 @@ -60,7 +60,8 @@ |
|
6627 GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0) - 1, |
|
6628 GFC_DESCRIPTOR_EXTENT(source, 1)); |
|
6629 |
|
6630 - ret->base_addr = xmalloc (sizeof (GFC_COMPLEX_16) * size0 ((array_t *) ret)); |
|
6631 + ret->base_addr = xmallocarray (size0 ((array_t *) ret), |
|
6632 + sizeof (GFC_COMPLEX_16)); |
|
6633 ret->offset = 0; |
|
6634 } else if (unlikely (compile_options.bounds_check)) |
|
6635 { |
|
6636 Index: gcc-4.8_branch/libgfortran/generated/maxloc0_8_i8.c |
|
6637 =================================================================== |
|
6638 --- gcc-4.8_branch/libgfortran/generated/maxloc0_8_i8.c (revision 213312) |
|
6639 +++ gcc-4.8_branch/libgfortran/generated/maxloc0_8_i8.c (revision 213313) |
|
6640 @@ -58,7 +58,7 @@ |
|
6641 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
6642 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
6643 retarray->offset = 0; |
|
6644 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
6645 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
6646 } |
|
6647 else |
|
6648 { |
|
6649 @@ -199,7 +199,7 @@ |
|
6650 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
6651 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
6652 retarray->offset = 0; |
|
6653 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
6654 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
6655 } |
|
6656 else |
|
6657 { |
|
6658 @@ -367,7 +367,7 @@ |
|
6659 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
6660 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
6661 retarray->offset = 0; |
|
6662 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
6663 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
6664 } |
|
6665 else if (unlikely (compile_options.bounds_check)) |
|
6666 { |
|
6667 Index: gcc-4.8_branch/libgfortran/generated/minloc1_4_r8.c |
|
6668 =================================================================== |
|
6669 --- gcc-4.8_branch/libgfortran/generated/minloc1_4_r8.c (revision 213312) |
|
6670 +++ gcc-4.8_branch/libgfortran/generated/minloc1_4_r8.c (revision 213313) |
|
6671 @@ -98,10 +98,9 @@ |
|
6672 retarray->offset = 0; |
|
6673 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6674 |
|
6675 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6676 - * extent[rank-1]; |
|
6677 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6678 |
|
6679 - retarray->base_addr = xmalloc (alloc_size); |
|
6680 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
6681 if (alloc_size == 0) |
|
6682 { |
|
6683 /* Make sure we have a zero-sized array. */ |
|
6684 @@ -294,8 +293,7 @@ |
|
6685 |
|
6686 } |
|
6687 |
|
6688 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6689 - * extent[rank-1]; |
|
6690 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6691 |
|
6692 retarray->offset = 0; |
|
6693 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6694 @@ -307,7 +305,7 @@ |
|
6695 return; |
|
6696 } |
|
6697 else |
|
6698 - retarray->base_addr = xmalloc (alloc_size); |
|
6699 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
6700 |
|
6701 } |
|
6702 else |
|
6703 @@ -485,8 +483,7 @@ |
|
6704 retarray->offset = 0; |
|
6705 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6706 |
|
6707 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6708 - * extent[rank-1]; |
|
6709 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6710 |
|
6711 if (alloc_size == 0) |
|
6712 { |
|
6713 @@ -495,7 +492,7 @@ |
|
6714 return; |
|
6715 } |
|
6716 else |
|
6717 - retarray->base_addr = xmalloc (alloc_size); |
|
6718 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
6719 } |
|
6720 else |
|
6721 { |
|
6722 Index: gcc-4.8_branch/libgfortran/generated/minloc1_16_i4.c |
|
6723 =================================================================== |
|
6724 --- gcc-4.8_branch/libgfortran/generated/minloc1_16_i4.c (revision 213312) |
|
6725 +++ gcc-4.8_branch/libgfortran/generated/minloc1_16_i4.c (revision 213313) |
|
6726 @@ -98,10 +98,9 @@ |
|
6727 retarray->offset = 0; |
|
6728 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6729 |
|
6730 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6731 - * extent[rank-1]; |
|
6732 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6733 |
|
6734 - retarray->base_addr = xmalloc (alloc_size); |
|
6735 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
6736 if (alloc_size == 0) |
|
6737 { |
|
6738 /* Make sure we have a zero-sized array. */ |
|
6739 @@ -294,8 +293,7 @@ |
|
6740 |
|
6741 } |
|
6742 |
|
6743 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6744 - * extent[rank-1]; |
|
6745 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6746 |
|
6747 retarray->offset = 0; |
|
6748 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6749 @@ -307,7 +305,7 @@ |
|
6750 return; |
|
6751 } |
|
6752 else |
|
6753 - retarray->base_addr = xmalloc (alloc_size); |
|
6754 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
6755 |
|
6756 } |
|
6757 else |
|
6758 @@ -485,8 +483,7 @@ |
|
6759 retarray->offset = 0; |
|
6760 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6761 |
|
6762 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6763 - * extent[rank-1]; |
|
6764 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6765 |
|
6766 if (alloc_size == 0) |
|
6767 { |
|
6768 @@ -495,7 +492,7 @@ |
|
6769 return; |
|
6770 } |
|
6771 else |
|
6772 - retarray->base_addr = xmalloc (alloc_size); |
|
6773 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
6774 } |
|
6775 else |
|
6776 { |
|
6777 Index: gcc-4.8_branch/libgfortran/generated/minloc0_16_i8.c |
|
6778 =================================================================== |
|
6779 --- gcc-4.8_branch/libgfortran/generated/minloc0_16_i8.c (revision 213312) |
|
6780 +++ gcc-4.8_branch/libgfortran/generated/minloc0_16_i8.c (revision 213313) |
|
6781 @@ -58,7 +58,7 @@ |
|
6782 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
6783 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
6784 retarray->offset = 0; |
|
6785 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
6786 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
6787 } |
|
6788 else |
|
6789 { |
|
6790 @@ -199,7 +199,7 @@ |
|
6791 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
6792 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
6793 retarray->offset = 0; |
|
6794 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
6795 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
6796 } |
|
6797 else |
|
6798 { |
|
6799 @@ -367,7 +367,7 @@ |
|
6800 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
6801 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
6802 retarray->offset = 0; |
|
6803 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
6804 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
6805 } |
|
6806 else if (unlikely (compile_options.bounds_check)) |
|
6807 { |
|
6808 Index: gcc-4.8_branch/libgfortran/generated/pack_i2.c |
|
6809 =================================================================== |
|
6810 --- gcc-4.8_branch/libgfortran/generated/pack_i2.c (revision 213312) |
|
6811 +++ gcc-4.8_branch/libgfortran/generated/pack_i2.c (revision 213313) |
|
6812 @@ -167,8 +167,8 @@ |
|
6813 |
|
6814 ret->offset = 0; |
|
6815 |
|
6816 - /* xmalloc allocates a single byte for zero size. */ |
|
6817 - ret->base_addr = xmalloc (sizeof (GFC_INTEGER_2) * total); |
|
6818 + /* xmallocarray allocates a single byte for zero size. */ |
|
6819 + ret->base_addr = xmallocarray (total, sizeof (GFC_INTEGER_2)); |
|
6820 |
|
6821 if (total == 0) |
|
6822 return; |
|
6823 Index: gcc-4.8_branch/libgfortran/generated/transpose_i8.c |
|
6824 =================================================================== |
|
6825 --- gcc-4.8_branch/libgfortran/generated/transpose_i8.c (revision 213312) |
|
6826 +++ gcc-4.8_branch/libgfortran/generated/transpose_i8.c (revision 213313) |
|
6827 @@ -60,7 +60,8 @@ |
|
6828 GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0) - 1, |
|
6829 GFC_DESCRIPTOR_EXTENT(source, 1)); |
|
6830 |
|
6831 - ret->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * size0 ((array_t *) ret)); |
|
6832 + ret->base_addr = xmallocarray (size0 ((array_t *) ret), |
|
6833 + sizeof (GFC_INTEGER_8)); |
|
6834 ret->offset = 0; |
|
6835 } else if (unlikely (compile_options.bounds_check)) |
|
6836 { |
|
6837 Index: gcc-4.8_branch/libgfortran/generated/eoshift1_16.c |
|
6838 =================================================================== |
|
6839 --- gcc-4.8_branch/libgfortran/generated/eoshift1_16.c (revision 213312) |
|
6840 +++ gcc-4.8_branch/libgfortran/generated/eoshift1_16.c (revision 213313) |
|
6841 @@ -105,8 +105,8 @@ |
|
6842 GFC_DIMENSION_SET(ret->dim[i], 0, ub, str); |
|
6843 |
|
6844 } |
|
6845 - /* xmalloc allocates a single byte for zero size. */ |
|
6846 - ret->base_addr = xmalloc (size * arraysize); |
|
6847 + /* xmallocarray allocates a single byte for zero size. */ |
|
6848 + ret->base_addr = xmallocarray (arraysize, size); |
|
6849 |
|
6850 } |
|
6851 else if (unlikely (compile_options.bounds_check)) |
|
6852 Index: gcc-4.8_branch/libgfortran/generated/all_l2.c |
|
6853 =================================================================== |
|
6854 --- gcc-4.8_branch/libgfortran/generated/all_l2.c (revision 213312) |
|
6855 +++ gcc-4.8_branch/libgfortran/generated/all_l2.c (revision 213313) |
|
6856 @@ -101,8 +101,7 @@ |
|
6857 retarray->offset = 0; |
|
6858 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6859 |
|
6860 - alloc_size = sizeof (GFC_LOGICAL_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6861 - * extent[rank-1]; |
|
6862 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6863 |
|
6864 if (alloc_size == 0) |
|
6865 { |
|
6866 @@ -111,7 +110,7 @@ |
|
6867 return; |
|
6868 } |
|
6869 else |
|
6870 - retarray->base_addr = xmalloc (alloc_size); |
|
6871 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_LOGICAL_2)); |
|
6872 } |
|
6873 else |
|
6874 { |
|
6875 Index: gcc-4.8_branch/libgfortran/generated/product_c4.c |
|
6876 =================================================================== |
|
6877 --- gcc-4.8_branch/libgfortran/generated/product_c4.c (revision 213312) |
|
6878 +++ gcc-4.8_branch/libgfortran/generated/product_c4.c (revision 213313) |
|
6879 @@ -97,10 +97,9 @@ |
|
6880 retarray->offset = 0; |
|
6881 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6882 |
|
6883 - alloc_size = sizeof (GFC_COMPLEX_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6884 - * extent[rank-1]; |
|
6885 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6886 |
|
6887 - retarray->base_addr = xmalloc (alloc_size); |
|
6888 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_4)); |
|
6889 if (alloc_size == 0) |
|
6890 { |
|
6891 /* Make sure we have a zero-sized array. */ |
|
6892 @@ -272,8 +271,7 @@ |
|
6893 |
|
6894 } |
|
6895 |
|
6896 - alloc_size = sizeof (GFC_COMPLEX_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6897 - * extent[rank-1]; |
|
6898 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6899 |
|
6900 retarray->offset = 0; |
|
6901 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6902 @@ -285,7 +283,7 @@ |
|
6903 return; |
|
6904 } |
|
6905 else |
|
6906 - retarray->base_addr = xmalloc (alloc_size); |
|
6907 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_4)); |
|
6908 |
|
6909 } |
|
6910 else |
|
6911 @@ -430,8 +428,7 @@ |
|
6912 retarray->offset = 0; |
|
6913 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6914 |
|
6915 - alloc_size = sizeof (GFC_COMPLEX_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6916 - * extent[rank-1]; |
|
6917 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6918 |
|
6919 if (alloc_size == 0) |
|
6920 { |
|
6921 @@ -440,7 +437,7 @@ |
|
6922 return; |
|
6923 } |
|
6924 else |
|
6925 - retarray->base_addr = xmalloc (alloc_size); |
|
6926 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_4)); |
|
6927 } |
|
6928 else |
|
6929 { |
|
6930 Index: gcc-4.8_branch/libgfortran/generated/iall_i1.c |
|
6931 =================================================================== |
|
6932 --- gcc-4.8_branch/libgfortran/generated/iall_i1.c (revision 213312) |
|
6933 +++ gcc-4.8_branch/libgfortran/generated/iall_i1.c (revision 213313) |
|
6934 @@ -97,10 +97,9 @@ |
|
6935 retarray->offset = 0; |
|
6936 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6937 |
|
6938 - alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6939 - * extent[rank-1]; |
|
6940 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6941 |
|
6942 - retarray->base_addr = xmalloc (alloc_size); |
|
6943 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); |
|
6944 if (alloc_size == 0) |
|
6945 { |
|
6946 /* Make sure we have a zero-sized array. */ |
|
6947 @@ -272,8 +271,7 @@ |
|
6948 |
|
6949 } |
|
6950 |
|
6951 - alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6952 - * extent[rank-1]; |
|
6953 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6954 |
|
6955 retarray->offset = 0; |
|
6956 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6957 @@ -285,7 +283,7 @@ |
|
6958 return; |
|
6959 } |
|
6960 else |
|
6961 - retarray->base_addr = xmalloc (alloc_size); |
|
6962 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); |
|
6963 |
|
6964 } |
|
6965 else |
|
6966 @@ -430,8 +428,7 @@ |
|
6967 retarray->offset = 0; |
|
6968 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
6969 |
|
6970 - alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
6971 - * extent[rank-1]; |
|
6972 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
6973 |
|
6974 if (alloc_size == 0) |
|
6975 { |
|
6976 @@ -440,7 +437,7 @@ |
|
6977 return; |
|
6978 } |
|
6979 else |
|
6980 - retarray->base_addr = xmalloc (alloc_size); |
|
6981 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); |
|
6982 } |
|
6983 else |
|
6984 { |
|
6985 Index: gcc-4.8_branch/libgfortran/generated/reshape_i4.c |
|
6986 =================================================================== |
|
6987 --- gcc-4.8_branch/libgfortran/generated/reshape_i4.c (revision 213312) |
|
6988 +++ gcc-4.8_branch/libgfortran/generated/reshape_i4.c (revision 213313) |
|
6989 @@ -111,11 +111,11 @@ |
|
6990 ret->offset = 0; |
|
6991 |
|
6992 if (unlikely (rs < 1)) |
|
6993 - alloc_size = 1; |
|
6994 + alloc_size = 0; |
|
6995 else |
|
6996 - alloc_size = rs * sizeof (GFC_INTEGER_4); |
|
6997 + alloc_size = rs; |
|
6998 |
|
6999 - ret->base_addr = xmalloc (alloc_size); |
|
7000 + ret->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
7001 ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim; |
|
7002 } |
|
7003 |
|
7004 Index: gcc-4.8_branch/libgfortran/generated/in_pack_r10.c |
|
7005 =================================================================== |
|
7006 --- gcc-4.8_branch/libgfortran/generated/in_pack_r10.c (revision 213312) |
|
7007 +++ gcc-4.8_branch/libgfortran/generated/in_pack_r10.c (revision 213313) |
|
7008 @@ -76,7 +76,7 @@ |
|
7009 return source->base_addr; |
|
7010 |
|
7011 /* Allocate storage for the destination. */ |
|
7012 - destptr = (GFC_REAL_10 *)xmalloc (ssize * sizeof (GFC_REAL_10)); |
|
7013 + destptr = xmallocarray (ssize, sizeof (GFC_REAL_10)); |
|
7014 dest = destptr; |
|
7015 src = source->base_addr; |
|
7016 stride0 = stride[0]; |
|
7017 Index: gcc-4.8_branch/libgfortran/generated/in_pack_c4.c |
|
7018 =================================================================== |
|
7019 --- gcc-4.8_branch/libgfortran/generated/in_pack_c4.c (revision 213312) |
|
7020 +++ gcc-4.8_branch/libgfortran/generated/in_pack_c4.c (revision 213313) |
|
7021 @@ -76,7 +76,7 @@ |
|
7022 return source->base_addr; |
|
7023 |
|
7024 /* Allocate storage for the destination. */ |
|
7025 - destptr = (GFC_COMPLEX_4 *)xmalloc (ssize * sizeof (GFC_COMPLEX_4)); |
|
7026 + destptr = xmallocarray (ssize, sizeof (GFC_COMPLEX_4)); |
|
7027 dest = destptr; |
|
7028 src = source->base_addr; |
|
7029 stride0 = stride[0]; |
|
7030 Index: gcc-4.8_branch/libgfortran/generated/all_l16.c |
|
7031 =================================================================== |
|
7032 --- gcc-4.8_branch/libgfortran/generated/all_l16.c (revision 213312) |
|
7033 +++ gcc-4.8_branch/libgfortran/generated/all_l16.c (revision 213313) |
|
7034 @@ -101,8 +101,7 @@ |
|
7035 retarray->offset = 0; |
|
7036 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7037 |
|
7038 - alloc_size = sizeof (GFC_LOGICAL_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7039 - * extent[rank-1]; |
|
7040 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7041 |
|
7042 if (alloc_size == 0) |
|
7043 { |
|
7044 @@ -111,7 +110,7 @@ |
|
7045 return; |
|
7046 } |
|
7047 else |
|
7048 - retarray->base_addr = xmalloc (alloc_size); |
|
7049 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_LOGICAL_16)); |
|
7050 } |
|
7051 else |
|
7052 { |
|
7053 Index: gcc-4.8_branch/libgfortran/generated/maxloc0_16_i1.c |
|
7054 =================================================================== |
|
7055 --- gcc-4.8_branch/libgfortran/generated/maxloc0_16_i1.c (revision 213312) |
|
7056 +++ gcc-4.8_branch/libgfortran/generated/maxloc0_16_i1.c (revision 213313) |
|
7057 @@ -58,7 +58,7 @@ |
|
7058 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
7059 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
7060 retarray->offset = 0; |
|
7061 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
7062 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
7063 } |
|
7064 else |
|
7065 { |
|
7066 @@ -199,7 +199,7 @@ |
|
7067 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
7068 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
7069 retarray->offset = 0; |
|
7070 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
7071 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
7072 } |
|
7073 else |
|
7074 { |
|
7075 @@ -367,7 +367,7 @@ |
|
7076 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
7077 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
7078 retarray->offset = 0; |
|
7079 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
7080 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
7081 } |
|
7082 else if (unlikely (compile_options.bounds_check)) |
|
7083 { |
|
7084 Index: gcc-4.8_branch/libgfortran/generated/maxloc1_8_r8.c |
|
7085 =================================================================== |
|
7086 --- gcc-4.8_branch/libgfortran/generated/maxloc1_8_r8.c (revision 213312) |
|
7087 +++ gcc-4.8_branch/libgfortran/generated/maxloc1_8_r8.c (revision 213313) |
|
7088 @@ -98,10 +98,9 @@ |
|
7089 retarray->offset = 0; |
|
7090 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7091 |
|
7092 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7093 - * extent[rank-1]; |
|
7094 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7095 |
|
7096 - retarray->base_addr = xmalloc (alloc_size); |
|
7097 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
7098 if (alloc_size == 0) |
|
7099 { |
|
7100 /* Make sure we have a zero-sized array. */ |
|
7101 @@ -294,8 +293,7 @@ |
|
7102 |
|
7103 } |
|
7104 |
|
7105 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7106 - * extent[rank-1]; |
|
7107 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7108 |
|
7109 retarray->offset = 0; |
|
7110 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7111 @@ -307,7 +305,7 @@ |
|
7112 return; |
|
7113 } |
|
7114 else |
|
7115 - retarray->base_addr = xmalloc (alloc_size); |
|
7116 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
7117 |
|
7118 } |
|
7119 else |
|
7120 @@ -485,8 +483,7 @@ |
|
7121 retarray->offset = 0; |
|
7122 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7123 |
|
7124 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7125 - * extent[rank-1]; |
|
7126 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7127 |
|
7128 if (alloc_size == 0) |
|
7129 { |
|
7130 @@ -495,7 +492,7 @@ |
|
7131 return; |
|
7132 } |
|
7133 else |
|
7134 - retarray->base_addr = xmalloc (alloc_size); |
|
7135 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
7136 } |
|
7137 else |
|
7138 { |
|
7139 Index: gcc-4.8_branch/libgfortran/generated/minval_i16.c |
|
7140 =================================================================== |
|
7141 --- gcc-4.8_branch/libgfortran/generated/minval_i16.c (revision 213312) |
|
7142 +++ gcc-4.8_branch/libgfortran/generated/minval_i16.c (revision 213313) |
|
7143 @@ -97,10 +97,9 @@ |
|
7144 retarray->offset = 0; |
|
7145 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7146 |
|
7147 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7148 - * extent[rank-1]; |
|
7149 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7150 |
|
7151 - retarray->base_addr = xmalloc (alloc_size); |
|
7152 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
7153 if (alloc_size == 0) |
|
7154 { |
|
7155 /* Make sure we have a zero-sized array. */ |
|
7156 @@ -286,8 +285,7 @@ |
|
7157 |
|
7158 } |
|
7159 |
|
7160 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7161 - * extent[rank-1]; |
|
7162 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7163 |
|
7164 retarray->offset = 0; |
|
7165 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7166 @@ -299,7 +297,7 @@ |
|
7167 return; |
|
7168 } |
|
7169 else |
|
7170 - retarray->base_addr = xmalloc (alloc_size); |
|
7171 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
7172 |
|
7173 } |
|
7174 else |
|
7175 @@ -472,8 +470,7 @@ |
|
7176 retarray->offset = 0; |
|
7177 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7178 |
|
7179 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7180 - * extent[rank-1]; |
|
7181 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7182 |
|
7183 if (alloc_size == 0) |
|
7184 { |
|
7185 @@ -482,7 +479,7 @@ |
|
7186 return; |
|
7187 } |
|
7188 else |
|
7189 - retarray->base_addr = xmalloc (alloc_size); |
|
7190 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
7191 } |
|
7192 else |
|
7193 { |
|
7194 Index: gcc-4.8_branch/libgfortran/generated/reshape_r10.c |
|
7195 =================================================================== |
|
7196 --- gcc-4.8_branch/libgfortran/generated/reshape_r10.c (revision 213312) |
|
7197 +++ gcc-4.8_branch/libgfortran/generated/reshape_r10.c (revision 213313) |
|
7198 @@ -111,11 +111,11 @@ |
|
7199 ret->offset = 0; |
|
7200 |
|
7201 if (unlikely (rs < 1)) |
|
7202 - alloc_size = 1; |
|
7203 + alloc_size = 0; |
|
7204 else |
|
7205 - alloc_size = rs * sizeof (GFC_REAL_10); |
|
7206 + alloc_size = rs; |
|
7207 |
|
7208 - ret->base_addr = xmalloc (alloc_size); |
|
7209 + ret->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_10)); |
|
7210 ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim; |
|
7211 } |
|
7212 |
|
7213 Index: gcc-4.8_branch/libgfortran/generated/unpack_r16.c |
|
7214 =================================================================== |
|
7215 --- gcc-4.8_branch/libgfortran/generated/unpack_r16.c (revision 213312) |
|
7216 +++ gcc-4.8_branch/libgfortran/generated/unpack_r16.c (revision 213313) |
|
7217 @@ -99,7 +99,7 @@ |
|
7218 rs *= extent[n]; |
|
7219 } |
|
7220 ret->offset = 0; |
|
7221 - ret->base_addr = xmalloc (rs * sizeof (GFC_REAL_16)); |
|
7222 + ret->base_addr = xmallocarray (rs, sizeof (GFC_REAL_16)); |
|
7223 } |
|
7224 else |
|
7225 { |
|
7226 @@ -244,7 +244,7 @@ |
|
7227 rs *= extent[n]; |
|
7228 } |
|
7229 ret->offset = 0; |
|
7230 - ret->base_addr = xmalloc (rs * sizeof (GFC_REAL_16)); |
|
7231 + ret->base_addr = xmallocarray (rs, sizeof (GFC_REAL_16)); |
|
7232 } |
|
7233 else |
|
7234 { |
|
7235 Index: gcc-4.8_branch/libgfortran/generated/maxval_i4.c |
|
7236 =================================================================== |
|
7237 --- gcc-4.8_branch/libgfortran/generated/maxval_i4.c (revision 213312) |
|
7238 +++ gcc-4.8_branch/libgfortran/generated/maxval_i4.c (revision 213313) |
|
7239 @@ -97,10 +97,9 @@ |
|
7240 retarray->offset = 0; |
|
7241 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7242 |
|
7243 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7244 - * extent[rank-1]; |
|
7245 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7246 |
|
7247 - retarray->base_addr = xmalloc (alloc_size); |
|
7248 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
7249 if (alloc_size == 0) |
|
7250 { |
|
7251 /* Make sure we have a zero-sized array. */ |
|
7252 @@ -286,8 +285,7 @@ |
|
7253 |
|
7254 } |
|
7255 |
|
7256 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7257 - * extent[rank-1]; |
|
7258 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7259 |
|
7260 retarray->offset = 0; |
|
7261 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7262 @@ -299,7 +297,7 @@ |
|
7263 return; |
|
7264 } |
|
7265 else |
|
7266 - retarray->base_addr = xmalloc (alloc_size); |
|
7267 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
7268 |
|
7269 } |
|
7270 else |
|
7271 @@ -472,8 +470,7 @@ |
|
7272 retarray->offset = 0; |
|
7273 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7274 |
|
7275 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7276 - * extent[rank-1]; |
|
7277 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7278 |
|
7279 if (alloc_size == 0) |
|
7280 { |
|
7281 @@ -482,7 +479,7 @@ |
|
7282 return; |
|
7283 } |
|
7284 else |
|
7285 - retarray->base_addr = xmalloc (alloc_size); |
|
7286 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
7287 } |
|
7288 else |
|
7289 { |
|
7290 Index: gcc-4.8_branch/libgfortran/generated/minval_i8.c |
|
7291 =================================================================== |
|
7292 --- gcc-4.8_branch/libgfortran/generated/minval_i8.c (revision 213312) |
|
7293 +++ gcc-4.8_branch/libgfortran/generated/minval_i8.c (revision 213313) |
|
7294 @@ -97,10 +97,9 @@ |
|
7295 retarray->offset = 0; |
|
7296 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7297 |
|
7298 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7299 - * extent[rank-1]; |
|
7300 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7301 |
|
7302 - retarray->base_addr = xmalloc (alloc_size); |
|
7303 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
7304 if (alloc_size == 0) |
|
7305 { |
|
7306 /* Make sure we have a zero-sized array. */ |
|
7307 @@ -286,8 +285,7 @@ |
|
7308 |
|
7309 } |
|
7310 |
|
7311 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7312 - * extent[rank-1]; |
|
7313 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7314 |
|
7315 retarray->offset = 0; |
|
7316 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7317 @@ -299,7 +297,7 @@ |
|
7318 return; |
|
7319 } |
|
7320 else |
|
7321 - retarray->base_addr = xmalloc (alloc_size); |
|
7322 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
7323 |
|
7324 } |
|
7325 else |
|
7326 @@ -472,8 +470,7 @@ |
|
7327 retarray->offset = 0; |
|
7328 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7329 |
|
7330 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7331 - * extent[rank-1]; |
|
7332 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7333 |
|
7334 if (alloc_size == 0) |
|
7335 { |
|
7336 @@ -482,7 +479,7 @@ |
|
7337 return; |
|
7338 } |
|
7339 else |
|
7340 - retarray->base_addr = xmalloc (alloc_size); |
|
7341 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
7342 } |
|
7343 else |
|
7344 { |
|
7345 Index: gcc-4.8_branch/libgfortran/generated/maxloc0_16_i16.c |
|
7346 =================================================================== |
|
7347 --- gcc-4.8_branch/libgfortran/generated/maxloc0_16_i16.c (revision 213312) |
|
7348 +++ gcc-4.8_branch/libgfortran/generated/maxloc0_16_i16.c (revision 213313) |
|
7349 @@ -58,7 +58,7 @@ |
|
7350 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
7351 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
7352 retarray->offset = 0; |
|
7353 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
7354 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
7355 } |
|
7356 else |
|
7357 { |
|
7358 @@ -199,7 +199,7 @@ |
|
7359 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
7360 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
7361 retarray->offset = 0; |
|
7362 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
7363 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
7364 } |
|
7365 else |
|
7366 { |
|
7367 @@ -367,7 +367,7 @@ |
|
7368 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
7369 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
7370 retarray->offset = 0; |
|
7371 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
7372 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
7373 } |
|
7374 else if (unlikely (compile_options.bounds_check)) |
|
7375 { |
|
7376 Index: gcc-4.8_branch/libgfortran/generated/shape_i4.c |
|
7377 =================================================================== |
|
7378 --- gcc-4.8_branch/libgfortran/generated/shape_i4.c (revision 213312) |
|
7379 +++ gcc-4.8_branch/libgfortran/generated/shape_i4.c (revision 213313) |
|
7380 @@ -49,7 +49,7 @@ |
|
7381 { |
|
7382 GFC_DIMENSION_SET(ret->dim[0], 0, rank - 1, 1); |
|
7383 ret->offset = 0; |
|
7384 - ret->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
7385 + ret->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
7386 } |
|
7387 |
|
7388 stride = GFC_DESCRIPTOR_STRIDE(ret,0); |
|
7389 Index: gcc-4.8_branch/libgfortran/generated/minloc1_4_i16.c |
|
7390 =================================================================== |
|
7391 --- gcc-4.8_branch/libgfortran/generated/minloc1_4_i16.c (revision 213312) |
|
7392 +++ gcc-4.8_branch/libgfortran/generated/minloc1_4_i16.c (revision 213313) |
|
7393 @@ -98,10 +98,9 @@ |
|
7394 retarray->offset = 0; |
|
7395 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7396 |
|
7397 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7398 - * extent[rank-1]; |
|
7399 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7400 |
|
7401 - retarray->base_addr = xmalloc (alloc_size); |
|
7402 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
7403 if (alloc_size == 0) |
|
7404 { |
|
7405 /* Make sure we have a zero-sized array. */ |
|
7406 @@ -294,8 +293,7 @@ |
|
7407 |
|
7408 } |
|
7409 |
|
7410 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7411 - * extent[rank-1]; |
|
7412 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7413 |
|
7414 retarray->offset = 0; |
|
7415 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7416 @@ -307,7 +305,7 @@ |
|
7417 return; |
|
7418 } |
|
7419 else |
|
7420 - retarray->base_addr = xmalloc (alloc_size); |
|
7421 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
7422 |
|
7423 } |
|
7424 else |
|
7425 @@ -485,8 +483,7 @@ |
|
7426 retarray->offset = 0; |
|
7427 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7428 |
|
7429 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7430 - * extent[rank-1]; |
|
7431 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7432 |
|
7433 if (alloc_size == 0) |
|
7434 { |
|
7435 @@ -495,7 +492,7 @@ |
|
7436 return; |
|
7437 } |
|
7438 else |
|
7439 - retarray->base_addr = xmalloc (alloc_size); |
|
7440 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
7441 } |
|
7442 else |
|
7443 { |
|
7444 Index: gcc-4.8_branch/libgfortran/generated/maxloc0_4_r10.c |
|
7445 =================================================================== |
|
7446 --- gcc-4.8_branch/libgfortran/generated/maxloc0_4_r10.c (revision 213312) |
|
7447 +++ gcc-4.8_branch/libgfortran/generated/maxloc0_4_r10.c (revision 213313) |
|
7448 @@ -58,7 +58,7 @@ |
|
7449 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
7450 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
7451 retarray->offset = 0; |
|
7452 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
7453 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
7454 } |
|
7455 else |
|
7456 { |
|
7457 @@ -199,7 +199,7 @@ |
|
7458 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
7459 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
7460 retarray->offset = 0; |
|
7461 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
7462 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
7463 } |
|
7464 else |
|
7465 { |
|
7466 @@ -367,7 +367,7 @@ |
|
7467 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
7468 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
7469 retarray->offset = 0; |
|
7470 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
7471 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
7472 } |
|
7473 else if (unlikely (compile_options.bounds_check)) |
|
7474 { |
|
7475 Index: gcc-4.8_branch/libgfortran/generated/maxloc0_8_i16.c |
|
7476 =================================================================== |
|
7477 --- gcc-4.8_branch/libgfortran/generated/maxloc0_8_i16.c (revision 213312) |
|
7478 +++ gcc-4.8_branch/libgfortran/generated/maxloc0_8_i16.c (revision 213313) |
|
7479 @@ -58,7 +58,7 @@ |
|
7480 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
7481 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
7482 retarray->offset = 0; |
|
7483 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
7484 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
7485 } |
|
7486 else |
|
7487 { |
|
7488 @@ -199,7 +199,7 @@ |
|
7489 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
7490 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
7491 retarray->offset = 0; |
|
7492 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
7493 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
7494 } |
|
7495 else |
|
7496 { |
|
7497 @@ -367,7 +367,7 @@ |
|
7498 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
7499 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
7500 retarray->offset = 0; |
|
7501 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
7502 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
7503 } |
|
7504 else if (unlikely (compile_options.bounds_check)) |
|
7505 { |
|
7506 Index: gcc-4.8_branch/libgfortran/generated/iall_i2.c |
|
7507 =================================================================== |
|
7508 --- gcc-4.8_branch/libgfortran/generated/iall_i2.c (revision 213312) |
|
7509 +++ gcc-4.8_branch/libgfortran/generated/iall_i2.c (revision 213313) |
|
7510 @@ -97,10 +97,9 @@ |
|
7511 retarray->offset = 0; |
|
7512 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7513 |
|
7514 - alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7515 - * extent[rank-1]; |
|
7516 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7517 |
|
7518 - retarray->base_addr = xmalloc (alloc_size); |
|
7519 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); |
|
7520 if (alloc_size == 0) |
|
7521 { |
|
7522 /* Make sure we have a zero-sized array. */ |
|
7523 @@ -272,8 +271,7 @@ |
|
7524 |
|
7525 } |
|
7526 |
|
7527 - alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7528 - * extent[rank-1]; |
|
7529 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7530 |
|
7531 retarray->offset = 0; |
|
7532 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7533 @@ -285,7 +283,7 @@ |
|
7534 return; |
|
7535 } |
|
7536 else |
|
7537 - retarray->base_addr = xmalloc (alloc_size); |
|
7538 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); |
|
7539 |
|
7540 } |
|
7541 else |
|
7542 @@ -430,8 +428,7 @@ |
|
7543 retarray->offset = 0; |
|
7544 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7545 |
|
7546 - alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7547 - * extent[rank-1]; |
|
7548 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7549 |
|
7550 if (alloc_size == 0) |
|
7551 { |
|
7552 @@ -440,7 +437,7 @@ |
|
7553 return; |
|
7554 } |
|
7555 else |
|
7556 - retarray->base_addr = xmalloc (alloc_size); |
|
7557 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); |
|
7558 } |
|
7559 else |
|
7560 { |
|
7561 Index: gcc-4.8_branch/libgfortran/generated/maxloc1_8_r10.c |
|
7562 =================================================================== |
|
7563 --- gcc-4.8_branch/libgfortran/generated/maxloc1_8_r10.c (revision 213312) |
|
7564 +++ gcc-4.8_branch/libgfortran/generated/maxloc1_8_r10.c (revision 213313) |
|
7565 @@ -98,10 +98,9 @@ |
|
7566 retarray->offset = 0; |
|
7567 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7568 |
|
7569 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7570 - * extent[rank-1]; |
|
7571 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7572 |
|
7573 - retarray->base_addr = xmalloc (alloc_size); |
|
7574 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
7575 if (alloc_size == 0) |
|
7576 { |
|
7577 /* Make sure we have a zero-sized array. */ |
|
7578 @@ -294,8 +293,7 @@ |
|
7579 |
|
7580 } |
|
7581 |
|
7582 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7583 - * extent[rank-1]; |
|
7584 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7585 |
|
7586 retarray->offset = 0; |
|
7587 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7588 @@ -307,7 +305,7 @@ |
|
7589 return; |
|
7590 } |
|
7591 else |
|
7592 - retarray->base_addr = xmalloc (alloc_size); |
|
7593 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
7594 |
|
7595 } |
|
7596 else |
|
7597 @@ -485,8 +483,7 @@ |
|
7598 retarray->offset = 0; |
|
7599 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7600 |
|
7601 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7602 - * extent[rank-1]; |
|
7603 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7604 |
|
7605 if (alloc_size == 0) |
|
7606 { |
|
7607 @@ -495,7 +492,7 @@ |
|
7608 return; |
|
7609 } |
|
7610 else |
|
7611 - retarray->base_addr = xmalloc (alloc_size); |
|
7612 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
7613 } |
|
7614 else |
|
7615 { |
|
7616 Index: gcc-4.8_branch/libgfortran/generated/maxloc0_16_r4.c |
|
7617 =================================================================== |
|
7618 --- gcc-4.8_branch/libgfortran/generated/maxloc0_16_r4.c (revision 213312) |
|
7619 +++ gcc-4.8_branch/libgfortran/generated/maxloc0_16_r4.c (revision 213313) |
|
7620 @@ -58,7 +58,7 @@ |
|
7621 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
7622 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
7623 retarray->offset = 0; |
|
7624 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
7625 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
7626 } |
|
7627 else |
|
7628 { |
|
7629 @@ -199,7 +199,7 @@ |
|
7630 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
7631 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
7632 retarray->offset = 0; |
|
7633 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
7634 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
7635 } |
|
7636 else |
|
7637 { |
|
7638 @@ -367,7 +367,7 @@ |
|
7639 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
7640 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
7641 retarray->offset = 0; |
|
7642 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
7643 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
7644 } |
|
7645 else if (unlikely (compile_options.bounds_check)) |
|
7646 { |
|
7647 Index: gcc-4.8_branch/libgfortran/generated/minloc0_8_i1.c |
|
7648 =================================================================== |
|
7649 --- gcc-4.8_branch/libgfortran/generated/minloc0_8_i1.c (revision 213312) |
|
7650 +++ gcc-4.8_branch/libgfortran/generated/minloc0_8_i1.c (revision 213313) |
|
7651 @@ -58,7 +58,7 @@ |
|
7652 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
7653 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
7654 retarray->offset = 0; |
|
7655 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
7656 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
7657 } |
|
7658 else |
|
7659 { |
|
7660 @@ -199,7 +199,7 @@ |
|
7661 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
7662 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
7663 retarray->offset = 0; |
|
7664 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
7665 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
7666 } |
|
7667 else |
|
7668 { |
|
7669 @@ -367,7 +367,7 @@ |
|
7670 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
7671 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
7672 retarray->offset = 0; |
|
7673 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
7674 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
7675 } |
|
7676 else if (unlikely (compile_options.bounds_check)) |
|
7677 { |
|
7678 Index: gcc-4.8_branch/libgfortran/generated/minloc1_16_r8.c |
|
7679 =================================================================== |
|
7680 --- gcc-4.8_branch/libgfortran/generated/minloc1_16_r8.c (revision 213312) |
|
7681 +++ gcc-4.8_branch/libgfortran/generated/minloc1_16_r8.c (revision 213313) |
|
7682 @@ -98,10 +98,9 @@ |
|
7683 retarray->offset = 0; |
|
7684 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7685 |
|
7686 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7687 - * extent[rank-1]; |
|
7688 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7689 |
|
7690 - retarray->base_addr = xmalloc (alloc_size); |
|
7691 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
7692 if (alloc_size == 0) |
|
7693 { |
|
7694 /* Make sure we have a zero-sized array. */ |
|
7695 @@ -294,8 +293,7 @@ |
|
7696 |
|
7697 } |
|
7698 |
|
7699 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7700 - * extent[rank-1]; |
|
7701 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7702 |
|
7703 retarray->offset = 0; |
|
7704 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7705 @@ -307,7 +305,7 @@ |
|
7706 return; |
|
7707 } |
|
7708 else |
|
7709 - retarray->base_addr = xmalloc (alloc_size); |
|
7710 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
7711 |
|
7712 } |
|
7713 else |
|
7714 @@ -485,8 +483,7 @@ |
|
7715 retarray->offset = 0; |
|
7716 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7717 |
|
7718 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7719 - * extent[rank-1]; |
|
7720 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7721 |
|
7722 if (alloc_size == 0) |
|
7723 { |
|
7724 @@ -495,7 +492,7 @@ |
|
7725 return; |
|
7726 } |
|
7727 else |
|
7728 - retarray->base_addr = xmalloc (alloc_size); |
|
7729 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
7730 } |
|
7731 else |
|
7732 { |
|
7733 Index: gcc-4.8_branch/libgfortran/generated/unpack_i8.c |
|
7734 =================================================================== |
|
7735 --- gcc-4.8_branch/libgfortran/generated/unpack_i8.c (revision 213312) |
|
7736 +++ gcc-4.8_branch/libgfortran/generated/unpack_i8.c (revision 213313) |
|
7737 @@ -99,7 +99,7 @@ |
|
7738 rs *= extent[n]; |
|
7739 } |
|
7740 ret->offset = 0; |
|
7741 - ret->base_addr = xmalloc (rs * sizeof (GFC_INTEGER_8)); |
|
7742 + ret->base_addr = xmallocarray (rs, sizeof (GFC_INTEGER_8)); |
|
7743 } |
|
7744 else |
|
7745 { |
|
7746 @@ -244,7 +244,7 @@ |
|
7747 rs *= extent[n]; |
|
7748 } |
|
7749 ret->offset = 0; |
|
7750 - ret->base_addr = xmalloc (rs * sizeof (GFC_INTEGER_8)); |
|
7751 + ret->base_addr = xmallocarray (rs, sizeof (GFC_INTEGER_8)); |
|
7752 } |
|
7753 else |
|
7754 { |
|
7755 Index: gcc-4.8_branch/libgfortran/generated/maxloc0_4_i4.c |
|
7756 =================================================================== |
|
7757 --- gcc-4.8_branch/libgfortran/generated/maxloc0_4_i4.c (revision 213312) |
|
7758 +++ gcc-4.8_branch/libgfortran/generated/maxloc0_4_i4.c (revision 213313) |
|
7759 @@ -58,7 +58,7 @@ |
|
7760 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
7761 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
7762 retarray->offset = 0; |
|
7763 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
7764 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
7765 } |
|
7766 else |
|
7767 { |
|
7768 @@ -199,7 +199,7 @@ |
|
7769 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
7770 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
7771 retarray->offset = 0; |
|
7772 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
7773 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
7774 } |
|
7775 else |
|
7776 { |
|
7777 @@ -367,7 +367,7 @@ |
|
7778 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
7779 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
7780 retarray->offset = 0; |
|
7781 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
7782 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
7783 } |
|
7784 else if (unlikely (compile_options.bounds_check)) |
|
7785 { |
|
7786 Index: gcc-4.8_branch/libgfortran/generated/count_4_l.c |
|
7787 =================================================================== |
|
7788 --- gcc-4.8_branch/libgfortran/generated/count_4_l.c (revision 213312) |
|
7789 +++ gcc-4.8_branch/libgfortran/generated/count_4_l.c (revision 213313) |
|
7790 @@ -101,8 +101,7 @@ |
|
7791 retarray->offset = 0; |
|
7792 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7793 |
|
7794 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7795 - * extent[rank-1]; |
|
7796 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7797 |
|
7798 if (alloc_size == 0) |
|
7799 { |
|
7800 @@ -111,7 +110,7 @@ |
|
7801 return; |
|
7802 } |
|
7803 else |
|
7804 - retarray->base_addr = xmalloc (alloc_size); |
|
7805 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
7806 } |
|
7807 else |
|
7808 { |
|
7809 Index: gcc-4.8_branch/libgfortran/generated/sum_r10.c |
|
7810 =================================================================== |
|
7811 --- gcc-4.8_branch/libgfortran/generated/sum_r10.c (revision 213312) |
|
7812 +++ gcc-4.8_branch/libgfortran/generated/sum_r10.c (revision 213313) |
|
7813 @@ -97,10 +97,9 @@ |
|
7814 retarray->offset = 0; |
|
7815 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7816 |
|
7817 - alloc_size = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7818 - * extent[rank-1]; |
|
7819 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7820 |
|
7821 - retarray->base_addr = xmalloc (alloc_size); |
|
7822 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_10)); |
|
7823 if (alloc_size == 0) |
|
7824 { |
|
7825 /* Make sure we have a zero-sized array. */ |
|
7826 @@ -272,8 +271,7 @@ |
|
7827 |
|
7828 } |
|
7829 |
|
7830 - alloc_size = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7831 - * extent[rank-1]; |
|
7832 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7833 |
|
7834 retarray->offset = 0; |
|
7835 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7836 @@ -285,7 +283,7 @@ |
|
7837 return; |
|
7838 } |
|
7839 else |
|
7840 - retarray->base_addr = xmalloc (alloc_size); |
|
7841 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_10)); |
|
7842 |
|
7843 } |
|
7844 else |
|
7845 @@ -430,8 +428,7 @@ |
|
7846 retarray->offset = 0; |
|
7847 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7848 |
|
7849 - alloc_size = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7850 - * extent[rank-1]; |
|
7851 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7852 |
|
7853 if (alloc_size == 0) |
|
7854 { |
|
7855 @@ -440,7 +437,7 @@ |
|
7856 return; |
|
7857 } |
|
7858 else |
|
7859 - retarray->base_addr = xmalloc (alloc_size); |
|
7860 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_10)); |
|
7861 } |
|
7862 else |
|
7863 { |
|
7864 Index: gcc-4.8_branch/libgfortran/generated/sum_c4.c |
|
7865 =================================================================== |
|
7866 --- gcc-4.8_branch/libgfortran/generated/sum_c4.c (revision 213312) |
|
7867 +++ gcc-4.8_branch/libgfortran/generated/sum_c4.c (revision 213313) |
|
7868 @@ -97,10 +97,9 @@ |
|
7869 retarray->offset = 0; |
|
7870 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7871 |
|
7872 - alloc_size = sizeof (GFC_COMPLEX_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7873 - * extent[rank-1]; |
|
7874 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7875 |
|
7876 - retarray->base_addr = xmalloc (alloc_size); |
|
7877 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_4)); |
|
7878 if (alloc_size == 0) |
|
7879 { |
|
7880 /* Make sure we have a zero-sized array. */ |
|
7881 @@ -272,8 +271,7 @@ |
|
7882 |
|
7883 } |
|
7884 |
|
7885 - alloc_size = sizeof (GFC_COMPLEX_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7886 - * extent[rank-1]; |
|
7887 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7888 |
|
7889 retarray->offset = 0; |
|
7890 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7891 @@ -285,7 +283,7 @@ |
|
7892 return; |
|
7893 } |
|
7894 else |
|
7895 - retarray->base_addr = xmalloc (alloc_size); |
|
7896 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_4)); |
|
7897 |
|
7898 } |
|
7899 else |
|
7900 @@ -430,8 +428,7 @@ |
|
7901 retarray->offset = 0; |
|
7902 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7903 |
|
7904 - alloc_size = sizeof (GFC_COMPLEX_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7905 - * extent[rank-1]; |
|
7906 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7907 |
|
7908 if (alloc_size == 0) |
|
7909 { |
|
7910 @@ -440,7 +437,7 @@ |
|
7911 return; |
|
7912 } |
|
7913 else |
|
7914 - retarray->base_addr = xmalloc (alloc_size); |
|
7915 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_4)); |
|
7916 } |
|
7917 else |
|
7918 { |
|
7919 Index: gcc-4.8_branch/libgfortran/generated/maxloc1_16_r10.c |
|
7920 =================================================================== |
|
7921 --- gcc-4.8_branch/libgfortran/generated/maxloc1_16_r10.c (revision 213312) |
|
7922 +++ gcc-4.8_branch/libgfortran/generated/maxloc1_16_r10.c (revision 213313) |
|
7923 @@ -98,10 +98,9 @@ |
|
7924 retarray->offset = 0; |
|
7925 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7926 |
|
7927 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7928 - * extent[rank-1]; |
|
7929 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7930 |
|
7931 - retarray->base_addr = xmalloc (alloc_size); |
|
7932 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
7933 if (alloc_size == 0) |
|
7934 { |
|
7935 /* Make sure we have a zero-sized array. */ |
|
7936 @@ -294,8 +293,7 @@ |
|
7937 |
|
7938 } |
|
7939 |
|
7940 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7941 - * extent[rank-1]; |
|
7942 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7943 |
|
7944 retarray->offset = 0; |
|
7945 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7946 @@ -307,7 +305,7 @@ |
|
7947 return; |
|
7948 } |
|
7949 else |
|
7950 - retarray->base_addr = xmalloc (alloc_size); |
|
7951 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
7952 |
|
7953 } |
|
7954 else |
|
7955 @@ -485,8 +483,7 @@ |
|
7956 retarray->offset = 0; |
|
7957 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
7958 |
|
7959 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
7960 - * extent[rank-1]; |
|
7961 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
7962 |
|
7963 if (alloc_size == 0) |
|
7964 { |
|
7965 @@ -495,7 +492,7 @@ |
|
7966 return; |
|
7967 } |
|
7968 else |
|
7969 - retarray->base_addr = xmalloc (alloc_size); |
|
7970 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
7971 } |
|
7972 else |
|
7973 { |
|
7974 Index: gcc-4.8_branch/libgfortran/generated/pack_i16.c |
|
7975 =================================================================== |
|
7976 --- gcc-4.8_branch/libgfortran/generated/pack_i16.c (revision 213312) |
|
7977 +++ gcc-4.8_branch/libgfortran/generated/pack_i16.c (revision 213313) |
|
7978 @@ -167,8 +167,8 @@ |
|
7979 |
|
7980 ret->offset = 0; |
|
7981 |
|
7982 - /* xmalloc allocates a single byte for zero size. */ |
|
7983 - ret->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * total); |
|
7984 + /* xmallocarray allocates a single byte for zero size. */ |
|
7985 + ret->base_addr = xmallocarray (total, sizeof (GFC_INTEGER_16)); |
|
7986 |
|
7987 if (total == 0) |
|
7988 return; |
|
7989 Index: gcc-4.8_branch/libgfortran/generated/matmul_i8.c |
|
7990 =================================================================== |
|
7991 --- gcc-4.8_branch/libgfortran/generated/matmul_i8.c (revision 213312) |
|
7992 +++ gcc-4.8_branch/libgfortran/generated/matmul_i8.c (revision 213313) |
|
7993 @@ -124,7 +124,7 @@ |
|
7994 } |
|
7995 |
|
7996 retarray->base_addr |
|
7997 - = xmalloc (sizeof (GFC_INTEGER_8) * size0 ((array_t *) retarray)); |
|
7998 + = xmallocarray (size0 ((array_t *) retarray), sizeof (GFC_INTEGER_8)); |
|
7999 retarray->offset = 0; |
|
8000 } |
|
8001 else if (unlikely (compile_options.bounds_check)) |
|
8002 Index: gcc-4.8_branch/libgfortran/generated/maxloc0_16_i2.c |
|
8003 =================================================================== |
|
8004 --- gcc-4.8_branch/libgfortran/generated/maxloc0_16_i2.c (revision 213312) |
|
8005 +++ gcc-4.8_branch/libgfortran/generated/maxloc0_16_i2.c (revision 213313) |
|
8006 @@ -58,7 +58,7 @@ |
|
8007 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
8008 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
8009 retarray->offset = 0; |
|
8010 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
8011 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
8012 } |
|
8013 else |
|
8014 { |
|
8015 @@ -199,7 +199,7 @@ |
|
8016 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
8017 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
8018 retarray->offset = 0; |
|
8019 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
8020 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
8021 } |
|
8022 else |
|
8023 { |
|
8024 @@ -367,7 +367,7 @@ |
|
8025 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
8026 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
8027 retarray->offset = 0; |
|
8028 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
8029 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
8030 } |
|
8031 else if (unlikely (compile_options.bounds_check)) |
|
8032 { |
|
8033 Index: gcc-4.8_branch/libgfortran/generated/spread_c4.c |
|
8034 =================================================================== |
|
8035 --- gcc-4.8_branch/libgfortran/generated/spread_c4.c (revision 213312) |
|
8036 +++ gcc-4.8_branch/libgfortran/generated/spread_c4.c (revision 213313) |
|
8037 @@ -101,8 +101,8 @@ |
|
8038 } |
|
8039 ret->offset = 0; |
|
8040 |
|
8041 - /* xmalloc allocates a single byte for zero size. */ |
|
8042 - ret->base_addr = xmalloc (rs * sizeof(GFC_COMPLEX_4)); |
|
8043 + /* xmallocarray allocates a single byte for zero size. */ |
|
8044 + ret->base_addr = xmallocarray (rs, sizeof(GFC_COMPLEX_4)); |
|
8045 if (rs <= 0) |
|
8046 return; |
|
8047 } |
|
8048 @@ -244,7 +244,7 @@ |
|
8049 |
|
8050 if (ret->base_addr == NULL) |
|
8051 { |
|
8052 - ret->base_addr = xmalloc (ncopies * sizeof (GFC_COMPLEX_4)); |
|
8053 + ret->base_addr = xmallocarray (ncopies, sizeof (GFC_COMPLEX_4)); |
|
8054 ret->offset = 0; |
|
8055 GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1); |
|
8056 } |
|
8057 Index: gcc-4.8_branch/libgfortran/generated/maxval_r10.c |
|
8058 =================================================================== |
|
8059 --- gcc-4.8_branch/libgfortran/generated/maxval_r10.c (revision 213312) |
|
8060 +++ gcc-4.8_branch/libgfortran/generated/maxval_r10.c (revision 213313) |
|
8061 @@ -97,10 +97,9 @@ |
|
8062 retarray->offset = 0; |
|
8063 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8064 |
|
8065 - alloc_size = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8066 - * extent[rank-1]; |
|
8067 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8068 |
|
8069 - retarray->base_addr = xmalloc (alloc_size); |
|
8070 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_10)); |
|
8071 if (alloc_size == 0) |
|
8072 { |
|
8073 /* Make sure we have a zero-sized array. */ |
|
8074 @@ -286,8 +285,7 @@ |
|
8075 |
|
8076 } |
|
8077 |
|
8078 - alloc_size = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8079 - * extent[rank-1]; |
|
8080 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8081 |
|
8082 retarray->offset = 0; |
|
8083 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8084 @@ -299,7 +297,7 @@ |
|
8085 return; |
|
8086 } |
|
8087 else |
|
8088 - retarray->base_addr = xmalloc (alloc_size); |
|
8089 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_10)); |
|
8090 |
|
8091 } |
|
8092 else |
|
8093 @@ -472,8 +470,7 @@ |
|
8094 retarray->offset = 0; |
|
8095 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8096 |
|
8097 - alloc_size = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8098 - * extent[rank-1]; |
|
8099 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8100 |
|
8101 if (alloc_size == 0) |
|
8102 { |
|
8103 @@ -482,7 +479,7 @@ |
|
8104 return; |
|
8105 } |
|
8106 else |
|
8107 - retarray->base_addr = xmalloc (alloc_size); |
|
8108 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_10)); |
|
8109 } |
|
8110 else |
|
8111 { |
|
8112 Index: gcc-4.8_branch/libgfortran/generated/pack_i4.c |
|
8113 =================================================================== |
|
8114 --- gcc-4.8_branch/libgfortran/generated/pack_i4.c (revision 213312) |
|
8115 +++ gcc-4.8_branch/libgfortran/generated/pack_i4.c (revision 213313) |
|
8116 @@ -167,8 +167,8 @@ |
|
8117 |
|
8118 ret->offset = 0; |
|
8119 |
|
8120 - /* xmalloc allocates a single byte for zero size. */ |
|
8121 - ret->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * total); |
|
8122 + /* xmallocarray allocates a single byte for zero size. */ |
|
8123 + ret->base_addr = xmallocarray (total, sizeof (GFC_INTEGER_4)); |
|
8124 |
|
8125 if (total == 0) |
|
8126 return; |
|
8127 Index: gcc-4.8_branch/libgfortran/generated/maxloc1_4_i1.c |
|
8128 =================================================================== |
|
8129 --- gcc-4.8_branch/libgfortran/generated/maxloc1_4_i1.c (revision 213312) |
|
8130 +++ gcc-4.8_branch/libgfortran/generated/maxloc1_4_i1.c (revision 213313) |
|
8131 @@ -98,10 +98,9 @@ |
|
8132 retarray->offset = 0; |
|
8133 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8134 |
|
8135 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8136 - * extent[rank-1]; |
|
8137 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8138 |
|
8139 - retarray->base_addr = xmalloc (alloc_size); |
|
8140 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
8141 if (alloc_size == 0) |
|
8142 { |
|
8143 /* Make sure we have a zero-sized array. */ |
|
8144 @@ -294,8 +293,7 @@ |
|
8145 |
|
8146 } |
|
8147 |
|
8148 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8149 - * extent[rank-1]; |
|
8150 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8151 |
|
8152 retarray->offset = 0; |
|
8153 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8154 @@ -307,7 +305,7 @@ |
|
8155 return; |
|
8156 } |
|
8157 else |
|
8158 - retarray->base_addr = xmalloc (alloc_size); |
|
8159 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
8160 |
|
8161 } |
|
8162 else |
|
8163 @@ -485,8 +483,7 @@ |
|
8164 retarray->offset = 0; |
|
8165 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8166 |
|
8167 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8168 - * extent[rank-1]; |
|
8169 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8170 |
|
8171 if (alloc_size == 0) |
|
8172 { |
|
8173 @@ -495,7 +492,7 @@ |
|
8174 return; |
|
8175 } |
|
8176 else |
|
8177 - retarray->base_addr = xmalloc (alloc_size); |
|
8178 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
8179 } |
|
8180 else |
|
8181 { |
|
8182 Index: gcc-4.8_branch/libgfortran/generated/matmul_r10.c |
|
8183 =================================================================== |
|
8184 --- gcc-4.8_branch/libgfortran/generated/matmul_r10.c (revision 213312) |
|
8185 +++ gcc-4.8_branch/libgfortran/generated/matmul_r10.c (revision 213313) |
|
8186 @@ -124,7 +124,7 @@ |
|
8187 } |
|
8188 |
|
8189 retarray->base_addr |
|
8190 - = xmalloc (sizeof (GFC_REAL_10) * size0 ((array_t *) retarray)); |
|
8191 + = xmallocarray (size0 ((array_t *) retarray), sizeof (GFC_REAL_10)); |
|
8192 retarray->offset = 0; |
|
8193 } |
|
8194 else if (unlikely (compile_options.bounds_check)) |
|
8195 Index: gcc-4.8_branch/libgfortran/generated/minloc1_4_i8.c |
|
8196 =================================================================== |
|
8197 --- gcc-4.8_branch/libgfortran/generated/minloc1_4_i8.c (revision 213312) |
|
8198 +++ gcc-4.8_branch/libgfortran/generated/minloc1_4_i8.c (revision 213313) |
|
8199 @@ -98,10 +98,9 @@ |
|
8200 retarray->offset = 0; |
|
8201 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8202 |
|
8203 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8204 - * extent[rank-1]; |
|
8205 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8206 |
|
8207 - retarray->base_addr = xmalloc (alloc_size); |
|
8208 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
8209 if (alloc_size == 0) |
|
8210 { |
|
8211 /* Make sure we have a zero-sized array. */ |
|
8212 @@ -294,8 +293,7 @@ |
|
8213 |
|
8214 } |
|
8215 |
|
8216 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8217 - * extent[rank-1]; |
|
8218 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8219 |
|
8220 retarray->offset = 0; |
|
8221 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8222 @@ -307,7 +305,7 @@ |
|
8223 return; |
|
8224 } |
|
8225 else |
|
8226 - retarray->base_addr = xmalloc (alloc_size); |
|
8227 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
8228 |
|
8229 } |
|
8230 else |
|
8231 @@ -485,8 +483,7 @@ |
|
8232 retarray->offset = 0; |
|
8233 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8234 |
|
8235 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8236 - * extent[rank-1]; |
|
8237 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8238 |
|
8239 if (alloc_size == 0) |
|
8240 { |
|
8241 @@ -495,7 +492,7 @@ |
|
8242 return; |
|
8243 } |
|
8244 else |
|
8245 - retarray->base_addr = xmalloc (alloc_size); |
|
8246 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
8247 } |
|
8248 else |
|
8249 { |
|
8250 Index: gcc-4.8_branch/libgfortran/generated/minloc0_8_r4.c |
|
8251 =================================================================== |
|
8252 --- gcc-4.8_branch/libgfortran/generated/minloc0_8_r4.c (revision 213312) |
|
8253 +++ gcc-4.8_branch/libgfortran/generated/minloc0_8_r4.c (revision 213313) |
|
8254 @@ -58,7 +58,7 @@ |
|
8255 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
8256 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
8257 retarray->offset = 0; |
|
8258 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
8259 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
8260 } |
|
8261 else |
|
8262 { |
|
8263 @@ -199,7 +199,7 @@ |
|
8264 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
8265 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
8266 retarray->offset = 0; |
|
8267 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
8268 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
8269 } |
|
8270 else |
|
8271 { |
|
8272 @@ -367,7 +367,7 @@ |
|
8273 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
8274 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
8275 retarray->offset = 0; |
|
8276 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
8277 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
8278 } |
|
8279 else if (unlikely (compile_options.bounds_check)) |
|
8280 { |
|
8281 Index: gcc-4.8_branch/libgfortran/generated/matmul_l4.c |
|
8282 =================================================================== |
|
8283 --- gcc-4.8_branch/libgfortran/generated/matmul_l4.c (revision 213312) |
|
8284 +++ gcc-4.8_branch/libgfortran/generated/matmul_l4.c (revision 213313) |
|
8285 @@ -88,7 +88,7 @@ |
|
8286 } |
|
8287 |
|
8288 retarray->base_addr |
|
8289 - = xmalloc (sizeof (GFC_LOGICAL_4) * size0 ((array_t *) retarray)); |
|
8290 + = xmallocarray (size0 ((array_t *) retarray), sizeof (GFC_LOGICAL_4)); |
|
8291 retarray->offset = 0; |
|
8292 } |
|
8293 else if (unlikely (compile_options.bounds_check)) |
|
8294 Index: gcc-4.8_branch/libgfortran/generated/reshape_r8.c |
|
8295 =================================================================== |
|
8296 --- gcc-4.8_branch/libgfortran/generated/reshape_r8.c (revision 213312) |
|
8297 +++ gcc-4.8_branch/libgfortran/generated/reshape_r8.c (revision 213313) |
|
8298 @@ -111,11 +111,11 @@ |
|
8299 ret->offset = 0; |
|
8300 |
|
8301 if (unlikely (rs < 1)) |
|
8302 - alloc_size = 1; |
|
8303 + alloc_size = 0; |
|
8304 else |
|
8305 - alloc_size = rs * sizeof (GFC_REAL_8); |
|
8306 + alloc_size = rs; |
|
8307 |
|
8308 - ret->base_addr = xmalloc (alloc_size); |
|
8309 + ret->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_8)); |
|
8310 ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim; |
|
8311 } |
|
8312 |
|
8313 Index: gcc-4.8_branch/libgfortran/generated/in_pack_c10.c |
|
8314 =================================================================== |
|
8315 --- gcc-4.8_branch/libgfortran/generated/in_pack_c10.c (revision 213312) |
|
8316 +++ gcc-4.8_branch/libgfortran/generated/in_pack_c10.c (revision 213313) |
|
8317 @@ -76,7 +76,7 @@ |
|
8318 return source->base_addr; |
|
8319 |
|
8320 /* Allocate storage for the destination. */ |
|
8321 - destptr = (GFC_COMPLEX_10 *)xmalloc (ssize * sizeof (GFC_COMPLEX_10)); |
|
8322 + destptr = xmallocarray (ssize, sizeof (GFC_COMPLEX_10)); |
|
8323 dest = destptr; |
|
8324 src = source->base_addr; |
|
8325 stride0 = stride[0]; |
|
8326 Index: gcc-4.8_branch/libgfortran/generated/all_l4.c |
|
8327 =================================================================== |
|
8328 --- gcc-4.8_branch/libgfortran/generated/all_l4.c (revision 213312) |
|
8329 +++ gcc-4.8_branch/libgfortran/generated/all_l4.c (revision 213313) |
|
8330 @@ -101,8 +101,7 @@ |
|
8331 retarray->offset = 0; |
|
8332 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8333 |
|
8334 - alloc_size = sizeof (GFC_LOGICAL_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8335 - * extent[rank-1]; |
|
8336 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8337 |
|
8338 if (alloc_size == 0) |
|
8339 { |
|
8340 @@ -111,7 +110,7 @@ |
|
8341 return; |
|
8342 } |
|
8343 else |
|
8344 - retarray->base_addr = xmalloc (alloc_size); |
|
8345 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_LOGICAL_4)); |
|
8346 } |
|
8347 else |
|
8348 { |
|
8349 Index: gcc-4.8_branch/libgfortran/generated/minloc0_8_i2.c |
|
8350 =================================================================== |
|
8351 --- gcc-4.8_branch/libgfortran/generated/minloc0_8_i2.c (revision 213312) |
|
8352 +++ gcc-4.8_branch/libgfortran/generated/minloc0_8_i2.c (revision 213313) |
|
8353 @@ -58,7 +58,7 @@ |
|
8354 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
8355 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
8356 retarray->offset = 0; |
|
8357 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
8358 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
8359 } |
|
8360 else |
|
8361 { |
|
8362 @@ -199,7 +199,7 @@ |
|
8363 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
8364 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
8365 retarray->offset = 0; |
|
8366 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
8367 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
8368 } |
|
8369 else |
|
8370 { |
|
8371 @@ -367,7 +367,7 @@ |
|
8372 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
8373 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
8374 retarray->offset = 0; |
|
8375 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
8376 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
8377 } |
|
8378 else if (unlikely (compile_options.bounds_check)) |
|
8379 { |
|
8380 Index: gcc-4.8_branch/libgfortran/generated/norm2_r16.c |
|
8381 =================================================================== |
|
8382 --- gcc-4.8_branch/libgfortran/generated/norm2_r16.c (revision 213312) |
|
8383 +++ gcc-4.8_branch/libgfortran/generated/norm2_r16.c (revision 213313) |
|
8384 @@ -105,10 +105,9 @@ |
|
8385 retarray->offset = 0; |
|
8386 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8387 |
|
8388 - alloc_size = sizeof (GFC_REAL_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8389 - * extent[rank-1]; |
|
8390 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8391 |
|
8392 - retarray->base_addr = xmalloc (alloc_size); |
|
8393 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_16)); |
|
8394 if (alloc_size == 0) |
|
8395 { |
|
8396 /* Make sure we have a zero-sized array. */ |
|
8397 Index: gcc-4.8_branch/libgfortran/generated/reshape_c10.c |
|
8398 =================================================================== |
|
8399 --- gcc-4.8_branch/libgfortran/generated/reshape_c10.c (revision 213312) |
|
8400 +++ gcc-4.8_branch/libgfortran/generated/reshape_c10.c (revision 213313) |
|
8401 @@ -111,11 +111,11 @@ |
|
8402 ret->offset = 0; |
|
8403 |
|
8404 if (unlikely (rs < 1)) |
|
8405 - alloc_size = 1; |
|
8406 + alloc_size = 0; |
|
8407 else |
|
8408 - alloc_size = rs * sizeof (GFC_COMPLEX_10); |
|
8409 + alloc_size = rs; |
|
8410 |
|
8411 - ret->base_addr = xmalloc (alloc_size); |
|
8412 + ret->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_10)); |
|
8413 ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim; |
|
8414 } |
|
8415 |
|
8416 Index: gcc-4.8_branch/libgfortran/generated/unpack_c16.c |
|
8417 =================================================================== |
|
8418 --- gcc-4.8_branch/libgfortran/generated/unpack_c16.c (revision 213312) |
|
8419 +++ gcc-4.8_branch/libgfortran/generated/unpack_c16.c (revision 213313) |
|
8420 @@ -99,7 +99,7 @@ |
|
8421 rs *= extent[n]; |
|
8422 } |
|
8423 ret->offset = 0; |
|
8424 - ret->base_addr = xmalloc (rs * sizeof (GFC_COMPLEX_16)); |
|
8425 + ret->base_addr = xmallocarray (rs, sizeof (GFC_COMPLEX_16)); |
|
8426 } |
|
8427 else |
|
8428 { |
|
8429 @@ -244,7 +244,7 @@ |
|
8430 rs *= extent[n]; |
|
8431 } |
|
8432 ret->offset = 0; |
|
8433 - ret->base_addr = xmalloc (rs * sizeof (GFC_COMPLEX_16)); |
|
8434 + ret->base_addr = xmallocarray (rs, sizeof (GFC_COMPLEX_16)); |
|
8435 } |
|
8436 else |
|
8437 { |
|
8438 Index: gcc-4.8_branch/libgfortran/generated/maxloc1_4_r4.c |
|
8439 =================================================================== |
|
8440 --- gcc-4.8_branch/libgfortran/generated/maxloc1_4_r4.c (revision 213312) |
|
8441 +++ gcc-4.8_branch/libgfortran/generated/maxloc1_4_r4.c (revision 213313) |
|
8442 @@ -98,10 +98,9 @@ |
|
8443 retarray->offset = 0; |
|
8444 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8445 |
|
8446 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8447 - * extent[rank-1]; |
|
8448 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8449 |
|
8450 - retarray->base_addr = xmalloc (alloc_size); |
|
8451 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
8452 if (alloc_size == 0) |
|
8453 { |
|
8454 /* Make sure we have a zero-sized array. */ |
|
8455 @@ -294,8 +293,7 @@ |
|
8456 |
|
8457 } |
|
8458 |
|
8459 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8460 - * extent[rank-1]; |
|
8461 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8462 |
|
8463 retarray->offset = 0; |
|
8464 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8465 @@ -307,7 +305,7 @@ |
|
8466 return; |
|
8467 } |
|
8468 else |
|
8469 - retarray->base_addr = xmalloc (alloc_size); |
|
8470 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
8471 |
|
8472 } |
|
8473 else |
|
8474 @@ -485,8 +483,7 @@ |
|
8475 retarray->offset = 0; |
|
8476 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8477 |
|
8478 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8479 - * extent[rank-1]; |
|
8480 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8481 |
|
8482 if (alloc_size == 0) |
|
8483 { |
|
8484 @@ -495,7 +492,7 @@ |
|
8485 return; |
|
8486 } |
|
8487 else |
|
8488 - retarray->base_addr = xmalloc (alloc_size); |
|
8489 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
8490 } |
|
8491 else |
|
8492 { |
|
8493 Index: gcc-4.8_branch/libgfortran/generated/maxval_r8.c |
|
8494 =================================================================== |
|
8495 --- gcc-4.8_branch/libgfortran/generated/maxval_r8.c (revision 213312) |
|
8496 +++ gcc-4.8_branch/libgfortran/generated/maxval_r8.c (revision 213313) |
|
8497 @@ -97,10 +97,9 @@ |
|
8498 retarray->offset = 0; |
|
8499 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8500 |
|
8501 - alloc_size = sizeof (GFC_REAL_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8502 - * extent[rank-1]; |
|
8503 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8504 |
|
8505 - retarray->base_addr = xmalloc (alloc_size); |
|
8506 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_8)); |
|
8507 if (alloc_size == 0) |
|
8508 { |
|
8509 /* Make sure we have a zero-sized array. */ |
|
8510 @@ -286,8 +285,7 @@ |
|
8511 |
|
8512 } |
|
8513 |
|
8514 - alloc_size = sizeof (GFC_REAL_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8515 - * extent[rank-1]; |
|
8516 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8517 |
|
8518 retarray->offset = 0; |
|
8519 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8520 @@ -299,7 +297,7 @@ |
|
8521 return; |
|
8522 } |
|
8523 else |
|
8524 - retarray->base_addr = xmalloc (alloc_size); |
|
8525 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_8)); |
|
8526 |
|
8527 } |
|
8528 else |
|
8529 @@ -472,8 +470,7 @@ |
|
8530 retarray->offset = 0; |
|
8531 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8532 |
|
8533 - alloc_size = sizeof (GFC_REAL_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8534 - * extent[rank-1]; |
|
8535 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8536 |
|
8537 if (alloc_size == 0) |
|
8538 { |
|
8539 @@ -482,7 +479,7 @@ |
|
8540 return; |
|
8541 } |
|
8542 else |
|
8543 - retarray->base_addr = xmalloc (alloc_size); |
|
8544 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_8)); |
|
8545 } |
|
8546 else |
|
8547 { |
|
8548 Index: gcc-4.8_branch/libgfortran/generated/transpose_c4.c |
|
8549 =================================================================== |
|
8550 --- gcc-4.8_branch/libgfortran/generated/transpose_c4.c (revision 213312) |
|
8551 +++ gcc-4.8_branch/libgfortran/generated/transpose_c4.c (revision 213313) |
|
8552 @@ -60,7 +60,8 @@ |
|
8553 GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0) - 1, |
|
8554 GFC_DESCRIPTOR_EXTENT(source, 1)); |
|
8555 |
|
8556 - ret->base_addr = xmalloc (sizeof (GFC_COMPLEX_4) * size0 ((array_t *) ret)); |
|
8557 + ret->base_addr = xmallocarray (size0 ((array_t *) ret), |
|
8558 + sizeof (GFC_COMPLEX_4)); |
|
8559 ret->offset = 0; |
|
8560 } else if (unlikely (compile_options.bounds_check)) |
|
8561 { |
|
8562 Index: gcc-4.8_branch/libgfortran/generated/eoshift1_4.c |
|
8563 =================================================================== |
|
8564 --- gcc-4.8_branch/libgfortran/generated/eoshift1_4.c (revision 213312) |
|
8565 +++ gcc-4.8_branch/libgfortran/generated/eoshift1_4.c (revision 213313) |
|
8566 @@ -105,8 +105,8 @@ |
|
8567 GFC_DIMENSION_SET(ret->dim[i], 0, ub, str); |
|
8568 |
|
8569 } |
|
8570 - /* xmalloc allocates a single byte for zero size. */ |
|
8571 - ret->base_addr = xmalloc (size * arraysize); |
|
8572 + /* xmallocarray allocates a single byte for zero size. */ |
|
8573 + ret->base_addr = xmallocarray (arraysize, size); |
|
8574 |
|
8575 } |
|
8576 else if (unlikely (compile_options.bounds_check)) |
|
8577 Index: gcc-4.8_branch/libgfortran/generated/minval_r16.c |
|
8578 =================================================================== |
|
8579 --- gcc-4.8_branch/libgfortran/generated/minval_r16.c (revision 213312) |
|
8580 +++ gcc-4.8_branch/libgfortran/generated/minval_r16.c (revision 213313) |
|
8581 @@ -97,10 +97,9 @@ |
|
8582 retarray->offset = 0; |
|
8583 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8584 |
|
8585 - alloc_size = sizeof (GFC_REAL_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8586 - * extent[rank-1]; |
|
8587 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8588 |
|
8589 - retarray->base_addr = xmalloc (alloc_size); |
|
8590 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_16)); |
|
8591 if (alloc_size == 0) |
|
8592 { |
|
8593 /* Make sure we have a zero-sized array. */ |
|
8594 @@ -286,8 +285,7 @@ |
|
8595 |
|
8596 } |
|
8597 |
|
8598 - alloc_size = sizeof (GFC_REAL_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8599 - * extent[rank-1]; |
|
8600 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8601 |
|
8602 retarray->offset = 0; |
|
8603 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8604 @@ -299,7 +297,7 @@ |
|
8605 return; |
|
8606 } |
|
8607 else |
|
8608 - retarray->base_addr = xmalloc (alloc_size); |
|
8609 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_16)); |
|
8610 |
|
8611 } |
|
8612 else |
|
8613 @@ -472,8 +470,7 @@ |
|
8614 retarray->offset = 0; |
|
8615 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8616 |
|
8617 - alloc_size = sizeof (GFC_REAL_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8618 - * extent[rank-1]; |
|
8619 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8620 |
|
8621 if (alloc_size == 0) |
|
8622 { |
|
8623 @@ -482,7 +479,7 @@ |
|
8624 return; |
|
8625 } |
|
8626 else |
|
8627 - retarray->base_addr = xmalloc (alloc_size); |
|
8628 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_16)); |
|
8629 } |
|
8630 else |
|
8631 { |
|
8632 Index: gcc-4.8_branch/libgfortran/generated/iany_i16.c |
|
8633 =================================================================== |
|
8634 --- gcc-4.8_branch/libgfortran/generated/iany_i16.c (revision 213312) |
|
8635 +++ gcc-4.8_branch/libgfortran/generated/iany_i16.c (revision 213313) |
|
8636 @@ -97,10 +97,9 @@ |
|
8637 retarray->offset = 0; |
|
8638 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8639 |
|
8640 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8641 - * extent[rank-1]; |
|
8642 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8643 |
|
8644 - retarray->base_addr = xmalloc (alloc_size); |
|
8645 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
8646 if (alloc_size == 0) |
|
8647 { |
|
8648 /* Make sure we have a zero-sized array. */ |
|
8649 @@ -272,8 +271,7 @@ |
|
8650 |
|
8651 } |
|
8652 |
|
8653 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8654 - * extent[rank-1]; |
|
8655 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8656 |
|
8657 retarray->offset = 0; |
|
8658 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8659 @@ -285,7 +283,7 @@ |
|
8660 return; |
|
8661 } |
|
8662 else |
|
8663 - retarray->base_addr = xmalloc (alloc_size); |
|
8664 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
8665 |
|
8666 } |
|
8667 else |
|
8668 @@ -430,8 +428,7 @@ |
|
8669 retarray->offset = 0; |
|
8670 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8671 |
|
8672 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8673 - * extent[rank-1]; |
|
8674 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8675 |
|
8676 if (alloc_size == 0) |
|
8677 { |
|
8678 @@ -440,7 +437,7 @@ |
|
8679 return; |
|
8680 } |
|
8681 else |
|
8682 - retarray->base_addr = xmalloc (alloc_size); |
|
8683 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
8684 } |
|
8685 else |
|
8686 { |
|
8687 Index: gcc-4.8_branch/libgfortran/generated/maxloc1_4_i2.c |
|
8688 =================================================================== |
|
8689 --- gcc-4.8_branch/libgfortran/generated/maxloc1_4_i2.c (revision 213312) |
|
8690 +++ gcc-4.8_branch/libgfortran/generated/maxloc1_4_i2.c (revision 213313) |
|
8691 @@ -98,10 +98,9 @@ |
|
8692 retarray->offset = 0; |
|
8693 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8694 |
|
8695 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8696 - * extent[rank-1]; |
|
8697 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8698 |
|
8699 - retarray->base_addr = xmalloc (alloc_size); |
|
8700 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
8701 if (alloc_size == 0) |
|
8702 { |
|
8703 /* Make sure we have a zero-sized array. */ |
|
8704 @@ -294,8 +293,7 @@ |
|
8705 |
|
8706 } |
|
8707 |
|
8708 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8709 - * extent[rank-1]; |
|
8710 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8711 |
|
8712 retarray->offset = 0; |
|
8713 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8714 @@ -307,7 +305,7 @@ |
|
8715 return; |
|
8716 } |
|
8717 else |
|
8718 - retarray->base_addr = xmalloc (alloc_size); |
|
8719 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
8720 |
|
8721 } |
|
8722 else |
|
8723 @@ -485,8 +483,7 @@ |
|
8724 retarray->offset = 0; |
|
8725 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8726 |
|
8727 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8728 - * extent[rank-1]; |
|
8729 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8730 |
|
8731 if (alloc_size == 0) |
|
8732 { |
|
8733 @@ -495,7 +492,7 @@ |
|
8734 return; |
|
8735 } |
|
8736 else |
|
8737 - retarray->base_addr = xmalloc (alloc_size); |
|
8738 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
8739 } |
|
8740 else |
|
8741 { |
|
8742 Index: gcc-4.8_branch/libgfortran/generated/maxloc1_8_i8.c |
|
8743 =================================================================== |
|
8744 --- gcc-4.8_branch/libgfortran/generated/maxloc1_8_i8.c (revision 213312) |
|
8745 +++ gcc-4.8_branch/libgfortran/generated/maxloc1_8_i8.c (revision 213313) |
|
8746 @@ -98,10 +98,9 @@ |
|
8747 retarray->offset = 0; |
|
8748 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8749 |
|
8750 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8751 - * extent[rank-1]; |
|
8752 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8753 |
|
8754 - retarray->base_addr = xmalloc (alloc_size); |
|
8755 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
8756 if (alloc_size == 0) |
|
8757 { |
|
8758 /* Make sure we have a zero-sized array. */ |
|
8759 @@ -294,8 +293,7 @@ |
|
8760 |
|
8761 } |
|
8762 |
|
8763 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8764 - * extent[rank-1]; |
|
8765 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8766 |
|
8767 retarray->offset = 0; |
|
8768 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8769 @@ -307,7 +305,7 @@ |
|
8770 return; |
|
8771 } |
|
8772 else |
|
8773 - retarray->base_addr = xmalloc (alloc_size); |
|
8774 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
8775 |
|
8776 } |
|
8777 else |
|
8778 @@ -485,8 +483,7 @@ |
|
8779 retarray->offset = 0; |
|
8780 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8781 |
|
8782 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8783 - * extent[rank-1]; |
|
8784 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8785 |
|
8786 if (alloc_size == 0) |
|
8787 { |
|
8788 @@ -495,7 +492,7 @@ |
|
8789 return; |
|
8790 } |
|
8791 else |
|
8792 - retarray->base_addr = xmalloc (alloc_size); |
|
8793 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
8794 } |
|
8795 else |
|
8796 { |
|
8797 Index: gcc-4.8_branch/libgfortran/generated/maxloc0_4_r8.c |
|
8798 =================================================================== |
|
8799 --- gcc-4.8_branch/libgfortran/generated/maxloc0_4_r8.c (revision 213312) |
|
8800 +++ gcc-4.8_branch/libgfortran/generated/maxloc0_4_r8.c (revision 213313) |
|
8801 @@ -58,7 +58,7 @@ |
|
8802 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
8803 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
8804 retarray->offset = 0; |
|
8805 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
8806 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
8807 } |
|
8808 else |
|
8809 { |
|
8810 @@ -199,7 +199,7 @@ |
|
8811 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
8812 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
8813 retarray->offset = 0; |
|
8814 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
8815 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
8816 } |
|
8817 else |
|
8818 { |
|
8819 @@ -367,7 +367,7 @@ |
|
8820 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
8821 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
8822 retarray->offset = 0; |
|
8823 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
8824 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
8825 } |
|
8826 else if (unlikely (compile_options.bounds_check)) |
|
8827 { |
|
8828 Index: gcc-4.8_branch/libgfortran/generated/maxloc0_16_r16.c |
|
8829 =================================================================== |
|
8830 --- gcc-4.8_branch/libgfortran/generated/maxloc0_16_r16.c (revision 213312) |
|
8831 +++ gcc-4.8_branch/libgfortran/generated/maxloc0_16_r16.c (revision 213313) |
|
8832 @@ -58,7 +58,7 @@ |
|
8833 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
8834 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
8835 retarray->offset = 0; |
|
8836 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
8837 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
8838 } |
|
8839 else |
|
8840 { |
|
8841 @@ -199,7 +199,7 @@ |
|
8842 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
8843 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
8844 retarray->offset = 0; |
|
8845 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
8846 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
8847 } |
|
8848 else |
|
8849 { |
|
8850 @@ -367,7 +367,7 @@ |
|
8851 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
8852 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
8853 retarray->offset = 0; |
|
8854 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
8855 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
8856 } |
|
8857 else if (unlikely (compile_options.bounds_check)) |
|
8858 { |
|
8859 Index: gcc-4.8_branch/libgfortran/generated/sum_c10.c |
|
8860 =================================================================== |
|
8861 --- gcc-4.8_branch/libgfortran/generated/sum_c10.c (revision 213312) |
|
8862 +++ gcc-4.8_branch/libgfortran/generated/sum_c10.c (revision 213313) |
|
8863 @@ -97,10 +97,9 @@ |
|
8864 retarray->offset = 0; |
|
8865 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8866 |
|
8867 - alloc_size = sizeof (GFC_COMPLEX_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8868 - * extent[rank-1]; |
|
8869 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8870 |
|
8871 - retarray->base_addr = xmalloc (alloc_size); |
|
8872 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_10)); |
|
8873 if (alloc_size == 0) |
|
8874 { |
|
8875 /* Make sure we have a zero-sized array. */ |
|
8876 @@ -272,8 +271,7 @@ |
|
8877 |
|
8878 } |
|
8879 |
|
8880 - alloc_size = sizeof (GFC_COMPLEX_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8881 - * extent[rank-1]; |
|
8882 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8883 |
|
8884 retarray->offset = 0; |
|
8885 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8886 @@ -285,7 +283,7 @@ |
|
8887 return; |
|
8888 } |
|
8889 else |
|
8890 - retarray->base_addr = xmalloc (alloc_size); |
|
8891 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_10)); |
|
8892 |
|
8893 } |
|
8894 else |
|
8895 @@ -430,8 +428,7 @@ |
|
8896 retarray->offset = 0; |
|
8897 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8898 |
|
8899 - alloc_size = sizeof (GFC_COMPLEX_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8900 - * extent[rank-1]; |
|
8901 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8902 |
|
8903 if (alloc_size == 0) |
|
8904 { |
|
8905 @@ -440,7 +437,7 @@ |
|
8906 return; |
|
8907 } |
|
8908 else |
|
8909 - retarray->base_addr = xmalloc (alloc_size); |
|
8910 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_10)); |
|
8911 } |
|
8912 else |
|
8913 { |
|
8914 Index: gcc-4.8_branch/libgfortran/generated/iall_i4.c |
|
8915 =================================================================== |
|
8916 --- gcc-4.8_branch/libgfortran/generated/iall_i4.c (revision 213312) |
|
8917 +++ gcc-4.8_branch/libgfortran/generated/iall_i4.c (revision 213313) |
|
8918 @@ -97,10 +97,9 @@ |
|
8919 retarray->offset = 0; |
|
8920 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8921 |
|
8922 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8923 - * extent[rank-1]; |
|
8924 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8925 |
|
8926 - retarray->base_addr = xmalloc (alloc_size); |
|
8927 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
8928 if (alloc_size == 0) |
|
8929 { |
|
8930 /* Make sure we have a zero-sized array. */ |
|
8931 @@ -272,8 +271,7 @@ |
|
8932 |
|
8933 } |
|
8934 |
|
8935 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8936 - * extent[rank-1]; |
|
8937 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8938 |
|
8939 retarray->offset = 0; |
|
8940 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8941 @@ -285,7 +283,7 @@ |
|
8942 return; |
|
8943 } |
|
8944 else |
|
8945 - retarray->base_addr = xmalloc (alloc_size); |
|
8946 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
8947 |
|
8948 } |
|
8949 else |
|
8950 @@ -430,8 +428,7 @@ |
|
8951 retarray->offset = 0; |
|
8952 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8953 |
|
8954 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8955 - * extent[rank-1]; |
|
8956 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8957 |
|
8958 if (alloc_size == 0) |
|
8959 { |
|
8960 @@ -440,7 +437,7 @@ |
|
8961 return; |
|
8962 } |
|
8963 else |
|
8964 - retarray->base_addr = xmalloc (alloc_size); |
|
8965 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
8966 } |
|
8967 else |
|
8968 { |
|
8969 Index: gcc-4.8_branch/libgfortran/generated/minloc1_4_r16.c |
|
8970 =================================================================== |
|
8971 --- gcc-4.8_branch/libgfortran/generated/minloc1_4_r16.c (revision 213312) |
|
8972 +++ gcc-4.8_branch/libgfortran/generated/minloc1_4_r16.c (revision 213313) |
|
8973 @@ -98,10 +98,9 @@ |
|
8974 retarray->offset = 0; |
|
8975 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8976 |
|
8977 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8978 - * extent[rank-1]; |
|
8979 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8980 |
|
8981 - retarray->base_addr = xmalloc (alloc_size); |
|
8982 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
8983 if (alloc_size == 0) |
|
8984 { |
|
8985 /* Make sure we have a zero-sized array. */ |
|
8986 @@ -294,8 +293,7 @@ |
|
8987 |
|
8988 } |
|
8989 |
|
8990 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
8991 - * extent[rank-1]; |
|
8992 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
8993 |
|
8994 retarray->offset = 0; |
|
8995 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
8996 @@ -307,7 +305,7 @@ |
|
8997 return; |
|
8998 } |
|
8999 else |
|
9000 - retarray->base_addr = xmalloc (alloc_size); |
|
9001 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
9002 |
|
9003 } |
|
9004 else |
|
9005 @@ -485,8 +483,7 @@ |
|
9006 retarray->offset = 0; |
|
9007 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9008 |
|
9009 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9010 - * extent[rank-1]; |
|
9011 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9012 |
|
9013 if (alloc_size == 0) |
|
9014 { |
|
9015 @@ -495,7 +492,7 @@ |
|
9016 return; |
|
9017 } |
|
9018 else |
|
9019 - retarray->base_addr = xmalloc (alloc_size); |
|
9020 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
9021 } |
|
9022 else |
|
9023 { |
|
9024 Index: gcc-4.8_branch/libgfortran/generated/maxloc0_8_r16.c |
|
9025 =================================================================== |
|
9026 --- gcc-4.8_branch/libgfortran/generated/maxloc0_8_r16.c (revision 213312) |
|
9027 +++ gcc-4.8_branch/libgfortran/generated/maxloc0_8_r16.c (revision 213313) |
|
9028 @@ -58,7 +58,7 @@ |
|
9029 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
9030 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
9031 retarray->offset = 0; |
|
9032 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
9033 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
9034 } |
|
9035 else |
|
9036 { |
|
9037 @@ -199,7 +199,7 @@ |
|
9038 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
9039 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
9040 retarray->offset = 0; |
|
9041 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
9042 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
9043 } |
|
9044 else |
|
9045 { |
|
9046 @@ -367,7 +367,7 @@ |
|
9047 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
9048 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
9049 retarray->offset = 0; |
|
9050 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
9051 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
9052 } |
|
9053 else if (unlikely (compile_options.bounds_check)) |
|
9054 { |
|
9055 Index: gcc-4.8_branch/libgfortran/generated/pack_r8.c |
|
9056 =================================================================== |
|
9057 --- gcc-4.8_branch/libgfortran/generated/pack_r8.c (revision 213312) |
|
9058 +++ gcc-4.8_branch/libgfortran/generated/pack_r8.c (revision 213313) |
|
9059 @@ -167,8 +167,8 @@ |
|
9060 |
|
9061 ret->offset = 0; |
|
9062 |
|
9063 - /* xmalloc allocates a single byte for zero size. */ |
|
9064 - ret->base_addr = xmalloc (sizeof (GFC_REAL_8) * total); |
|
9065 + /* xmallocarray allocates a single byte for zero size. */ |
|
9066 + ret->base_addr = xmallocarray (total, sizeof (GFC_REAL_8)); |
|
9067 |
|
9068 if (total == 0) |
|
9069 return; |
|
9070 Index: gcc-4.8_branch/libgfortran/generated/matmul_c10.c |
|
9071 =================================================================== |
|
9072 --- gcc-4.8_branch/libgfortran/generated/matmul_c10.c (revision 213312) |
|
9073 +++ gcc-4.8_branch/libgfortran/generated/matmul_c10.c (revision 213313) |
|
9074 @@ -124,7 +124,7 @@ |
|
9075 } |
|
9076 |
|
9077 retarray->base_addr |
|
9078 - = xmalloc (sizeof (GFC_COMPLEX_10) * size0 ((array_t *) retarray)); |
|
9079 + = xmallocarray (size0 ((array_t *) retarray), sizeof (GFC_COMPLEX_10)); |
|
9080 retarray->offset = 0; |
|
9081 } |
|
9082 else if (unlikely (compile_options.bounds_check)) |
|
9083 Index: gcc-4.8_branch/libgfortran/generated/maxloc0_16_i4.c |
|
9084 =================================================================== |
|
9085 --- gcc-4.8_branch/libgfortran/generated/maxloc0_16_i4.c (revision 213312) |
|
9086 +++ gcc-4.8_branch/libgfortran/generated/maxloc0_16_i4.c (revision 213313) |
|
9087 @@ -58,7 +58,7 @@ |
|
9088 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
9089 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
9090 retarray->offset = 0; |
|
9091 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
9092 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
9093 } |
|
9094 else |
|
9095 { |
|
9096 @@ -199,7 +199,7 @@ |
|
9097 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
9098 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
9099 retarray->offset = 0; |
|
9100 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
9101 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
9102 } |
|
9103 else |
|
9104 { |
|
9105 @@ -367,7 +367,7 @@ |
|
9106 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
9107 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
9108 retarray->offset = 0; |
|
9109 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
9110 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
9111 } |
|
9112 else if (unlikely (compile_options.bounds_check)) |
|
9113 { |
|
9114 Index: gcc-4.8_branch/libgfortran/generated/pack_r16.c |
|
9115 =================================================================== |
|
9116 --- gcc-4.8_branch/libgfortran/generated/pack_r16.c (revision 213312) |
|
9117 +++ gcc-4.8_branch/libgfortran/generated/pack_r16.c (revision 213313) |
|
9118 @@ -167,8 +167,8 @@ |
|
9119 |
|
9120 ret->offset = 0; |
|
9121 |
|
9122 - /* xmalloc allocates a single byte for zero size. */ |
|
9123 - ret->base_addr = xmalloc (sizeof (GFC_REAL_16) * total); |
|
9124 + /* xmallocarray allocates a single byte for zero size. */ |
|
9125 + ret->base_addr = xmallocarray (total, sizeof (GFC_REAL_16)); |
|
9126 |
|
9127 if (total == 0) |
|
9128 return; |
|
9129 Index: gcc-4.8_branch/libgfortran/generated/minloc1_16_i8.c |
|
9130 =================================================================== |
|
9131 --- gcc-4.8_branch/libgfortran/generated/minloc1_16_i8.c (revision 213312) |
|
9132 +++ gcc-4.8_branch/libgfortran/generated/minloc1_16_i8.c (revision 213313) |
|
9133 @@ -98,10 +98,9 @@ |
|
9134 retarray->offset = 0; |
|
9135 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9136 |
|
9137 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9138 - * extent[rank-1]; |
|
9139 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9140 |
|
9141 - retarray->base_addr = xmalloc (alloc_size); |
|
9142 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
9143 if (alloc_size == 0) |
|
9144 { |
|
9145 /* Make sure we have a zero-sized array. */ |
|
9146 @@ -294,8 +293,7 @@ |
|
9147 |
|
9148 } |
|
9149 |
|
9150 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9151 - * extent[rank-1]; |
|
9152 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9153 |
|
9154 retarray->offset = 0; |
|
9155 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9156 @@ -307,7 +305,7 @@ |
|
9157 return; |
|
9158 } |
|
9159 else |
|
9160 - retarray->base_addr = xmalloc (alloc_size); |
|
9161 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
9162 |
|
9163 } |
|
9164 else |
|
9165 @@ -485,8 +483,7 @@ |
|
9166 retarray->offset = 0; |
|
9167 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9168 |
|
9169 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9170 - * extent[rank-1]; |
|
9171 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9172 |
|
9173 if (alloc_size == 0) |
|
9174 { |
|
9175 @@ -495,7 +492,7 @@ |
|
9176 return; |
|
9177 } |
|
9178 else |
|
9179 - retarray->base_addr = xmalloc (alloc_size); |
|
9180 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
9181 } |
|
9182 else |
|
9183 { |
|
9184 Index: gcc-4.8_branch/libgfortran/generated/minloc0_16_r10.c |
|
9185 =================================================================== |
|
9186 --- gcc-4.8_branch/libgfortran/generated/minloc0_16_r10.c (revision 213312) |
|
9187 +++ gcc-4.8_branch/libgfortran/generated/minloc0_16_r10.c (revision 213313) |
|
9188 @@ -58,7 +58,7 @@ |
|
9189 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
9190 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
9191 retarray->offset = 0; |
|
9192 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
9193 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
9194 } |
|
9195 else |
|
9196 { |
|
9197 @@ -199,7 +199,7 @@ |
|
9198 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
9199 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
9200 retarray->offset = 0; |
|
9201 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
9202 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
9203 } |
|
9204 else |
|
9205 { |
|
9206 @@ -367,7 +367,7 @@ |
|
9207 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
9208 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
9209 retarray->offset = 0; |
|
9210 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
9211 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
9212 } |
|
9213 else if (unlikely (compile_options.bounds_check)) |
|
9214 { |
|
9215 Index: gcc-4.8_branch/libgfortran/generated/unpack_c4.c |
|
9216 =================================================================== |
|
9217 --- gcc-4.8_branch/libgfortran/generated/unpack_c4.c (revision 213312) |
|
9218 +++ gcc-4.8_branch/libgfortran/generated/unpack_c4.c (revision 213313) |
|
9219 @@ -99,7 +99,7 @@ |
|
9220 rs *= extent[n]; |
|
9221 } |
|
9222 ret->offset = 0; |
|
9223 - ret->base_addr = xmalloc (rs * sizeof (GFC_COMPLEX_4)); |
|
9224 + ret->base_addr = xmallocarray (rs, sizeof (GFC_COMPLEX_4)); |
|
9225 } |
|
9226 else |
|
9227 { |
|
9228 @@ -244,7 +244,7 @@ |
|
9229 rs *= extent[n]; |
|
9230 } |
|
9231 ret->offset = 0; |
|
9232 - ret->base_addr = xmalloc (rs * sizeof (GFC_COMPLEX_4)); |
|
9233 + ret->base_addr = xmallocarray (rs, sizeof (GFC_COMPLEX_4)); |
|
9234 } |
|
9235 else |
|
9236 { |
|
9237 Index: gcc-4.8_branch/libgfortran/generated/iparity_i1.c |
|
9238 =================================================================== |
|
9239 --- gcc-4.8_branch/libgfortran/generated/iparity_i1.c (revision 213312) |
|
9240 +++ gcc-4.8_branch/libgfortran/generated/iparity_i1.c (revision 213313) |
|
9241 @@ -97,10 +97,9 @@ |
|
9242 retarray->offset = 0; |
|
9243 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9244 |
|
9245 - alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9246 - * extent[rank-1]; |
|
9247 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9248 |
|
9249 - retarray->base_addr = xmalloc (alloc_size); |
|
9250 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); |
|
9251 if (alloc_size == 0) |
|
9252 { |
|
9253 /* Make sure we have a zero-sized array. */ |
|
9254 @@ -272,8 +271,7 @@ |
|
9255 |
|
9256 } |
|
9257 |
|
9258 - alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9259 - * extent[rank-1]; |
|
9260 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9261 |
|
9262 retarray->offset = 0; |
|
9263 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9264 @@ -285,7 +283,7 @@ |
|
9265 return; |
|
9266 } |
|
9267 else |
|
9268 - retarray->base_addr = xmalloc (alloc_size); |
|
9269 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); |
|
9270 |
|
9271 } |
|
9272 else |
|
9273 @@ -430,8 +428,7 @@ |
|
9274 retarray->offset = 0; |
|
9275 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9276 |
|
9277 - alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9278 - * extent[rank-1]; |
|
9279 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9280 |
|
9281 if (alloc_size == 0) |
|
9282 { |
|
9283 @@ -440,7 +437,7 @@ |
|
9284 return; |
|
9285 } |
|
9286 else |
|
9287 - retarray->base_addr = xmalloc (alloc_size); |
|
9288 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); |
|
9289 } |
|
9290 else |
|
9291 { |
|
9292 Index: gcc-4.8_branch/libgfortran/generated/product_c8.c |
|
9293 =================================================================== |
|
9294 --- gcc-4.8_branch/libgfortran/generated/product_c8.c (revision 213312) |
|
9295 +++ gcc-4.8_branch/libgfortran/generated/product_c8.c (revision 213313) |
|
9296 @@ -97,10 +97,9 @@ |
|
9297 retarray->offset = 0; |
|
9298 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9299 |
|
9300 - alloc_size = sizeof (GFC_COMPLEX_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9301 - * extent[rank-1]; |
|
9302 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9303 |
|
9304 - retarray->base_addr = xmalloc (alloc_size); |
|
9305 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_8)); |
|
9306 if (alloc_size == 0) |
|
9307 { |
|
9308 /* Make sure we have a zero-sized array. */ |
|
9309 @@ -272,8 +271,7 @@ |
|
9310 |
|
9311 } |
|
9312 |
|
9313 - alloc_size = sizeof (GFC_COMPLEX_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9314 - * extent[rank-1]; |
|
9315 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9316 |
|
9317 retarray->offset = 0; |
|
9318 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9319 @@ -285,7 +283,7 @@ |
|
9320 return; |
|
9321 } |
|
9322 else |
|
9323 - retarray->base_addr = xmalloc (alloc_size); |
|
9324 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_8)); |
|
9325 |
|
9326 } |
|
9327 else |
|
9328 @@ -430,8 +428,7 @@ |
|
9329 retarray->offset = 0; |
|
9330 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9331 |
|
9332 - alloc_size = sizeof (GFC_COMPLEX_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9333 - * extent[rank-1]; |
|
9334 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9335 |
|
9336 if (alloc_size == 0) |
|
9337 { |
|
9338 @@ -440,7 +437,7 @@ |
|
9339 return; |
|
9340 } |
|
9341 else |
|
9342 - retarray->base_addr = xmalloc (alloc_size); |
|
9343 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_8)); |
|
9344 } |
|
9345 else |
|
9346 { |
|
9347 Index: gcc-4.8_branch/libgfortran/generated/in_pack_i16.c |
|
9348 =================================================================== |
|
9349 --- gcc-4.8_branch/libgfortran/generated/in_pack_i16.c (revision 213312) |
|
9350 +++ gcc-4.8_branch/libgfortran/generated/in_pack_i16.c (revision 213313) |
|
9351 @@ -76,7 +76,7 @@ |
|
9352 return source->base_addr; |
|
9353 |
|
9354 /* Allocate storage for the destination. */ |
|
9355 - destptr = (GFC_INTEGER_16 *)xmalloc (ssize * sizeof (GFC_INTEGER_16)); |
|
9356 + destptr = xmallocarray (ssize, sizeof (GFC_INTEGER_16)); |
|
9357 dest = destptr; |
|
9358 src = source->base_addr; |
|
9359 stride0 = stride[0]; |
|
9360 Index: gcc-4.8_branch/libgfortran/generated/minloc0_8_i4.c |
|
9361 =================================================================== |
|
9362 --- gcc-4.8_branch/libgfortran/generated/minloc0_8_i4.c (revision 213312) |
|
9363 +++ gcc-4.8_branch/libgfortran/generated/minloc0_8_i4.c (revision 213313) |
|
9364 @@ -58,7 +58,7 @@ |
|
9365 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
9366 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
9367 retarray->offset = 0; |
|
9368 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
9369 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
9370 } |
|
9371 else |
|
9372 { |
|
9373 @@ -199,7 +199,7 @@ |
|
9374 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
9375 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
9376 retarray->offset = 0; |
|
9377 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
9378 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
9379 } |
|
9380 else |
|
9381 { |
|
9382 @@ -367,7 +367,7 @@ |
|
9383 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
9384 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
9385 retarray->offset = 0; |
|
9386 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
9387 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
9388 } |
|
9389 else if (unlikely (compile_options.bounds_check)) |
|
9390 { |
|
9391 Index: gcc-4.8_branch/libgfortran/generated/matmul_c4.c |
|
9392 =================================================================== |
|
9393 --- gcc-4.8_branch/libgfortran/generated/matmul_c4.c (revision 213312) |
|
9394 +++ gcc-4.8_branch/libgfortran/generated/matmul_c4.c (revision 213313) |
|
9395 @@ -124,7 +124,7 @@ |
|
9396 } |
|
9397 |
|
9398 retarray->base_addr |
|
9399 - = xmalloc (sizeof (GFC_COMPLEX_4) * size0 ((array_t *) retarray)); |
|
9400 + = xmallocarray (size0 ((array_t *) retarray), sizeof (GFC_COMPLEX_4)); |
|
9401 retarray->offset = 0; |
|
9402 } |
|
9403 else if (unlikely (compile_options.bounds_check)) |
|
9404 Index: gcc-4.8_branch/libgfortran/generated/reshape_i8.c |
|
9405 =================================================================== |
|
9406 --- gcc-4.8_branch/libgfortran/generated/reshape_i8.c (revision 213312) |
|
9407 +++ gcc-4.8_branch/libgfortran/generated/reshape_i8.c (revision 213313) |
|
9408 @@ -111,11 +111,11 @@ |
|
9409 ret->offset = 0; |
|
9410 |
|
9411 if (unlikely (rs < 1)) |
|
9412 - alloc_size = 1; |
|
9413 + alloc_size = 0; |
|
9414 else |
|
9415 - alloc_size = rs * sizeof (GFC_INTEGER_8); |
|
9416 + alloc_size = rs; |
|
9417 |
|
9418 - ret->base_addr = xmalloc (alloc_size); |
|
9419 + ret->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
9420 ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim; |
|
9421 } |
|
9422 |
|
9423 Index: gcc-4.8_branch/libgfortran/generated/in_pack_c8.c |
|
9424 =================================================================== |
|
9425 --- gcc-4.8_branch/libgfortran/generated/in_pack_c8.c (revision 213312) |
|
9426 +++ gcc-4.8_branch/libgfortran/generated/in_pack_c8.c (revision 213313) |
|
9427 @@ -76,7 +76,7 @@ |
|
9428 return source->base_addr; |
|
9429 |
|
9430 /* Allocate storage for the destination. */ |
|
9431 - destptr = (GFC_COMPLEX_8 *)xmalloc (ssize * sizeof (GFC_COMPLEX_8)); |
|
9432 + destptr = xmallocarray (ssize, sizeof (GFC_COMPLEX_8)); |
|
9433 dest = destptr; |
|
9434 src = source->base_addr; |
|
9435 stride0 = stride[0]; |
|
9436 Index: gcc-4.8_branch/libgfortran/generated/bessel_r10.c |
|
9437 =================================================================== |
|
9438 --- gcc-4.8_branch/libgfortran/generated/bessel_r10.c (revision 213312) |
|
9439 +++ gcc-4.8_branch/libgfortran/generated/bessel_r10.c (revision 213313) |
|
9440 @@ -55,7 +55,7 @@ |
|
9441 { |
|
9442 size_t size = n2 < n1 ? 0 : n2-n1+1; |
|
9443 GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1); |
|
9444 - ret->base_addr = xmalloc (sizeof (GFC_REAL_10) * size); |
|
9445 + ret->base_addr = xmallocarray (size, sizeof (GFC_REAL_10)); |
|
9446 ret->offset = 0; |
|
9447 } |
|
9448 |
|
9449 @@ -122,7 +122,7 @@ |
|
9450 { |
|
9451 size_t size = n2 < n1 ? 0 : n2-n1+1; |
|
9452 GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1); |
|
9453 - ret->base_addr = xmalloc (sizeof (GFC_REAL_10) * size); |
|
9454 + ret->base_addr = xmallocarray (size, sizeof (GFC_REAL_10)); |
|
9455 ret->offset = 0; |
|
9456 } |
|
9457 |
|
9458 Index: gcc-4.8_branch/libgfortran/generated/iall_i16.c |
|
9459 =================================================================== |
|
9460 --- gcc-4.8_branch/libgfortran/generated/iall_i16.c (revision 213312) |
|
9461 +++ gcc-4.8_branch/libgfortran/generated/iall_i16.c (revision 213313) |
|
9462 @@ -97,10 +97,9 @@ |
|
9463 retarray->offset = 0; |
|
9464 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9465 |
|
9466 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9467 - * extent[rank-1]; |
|
9468 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9469 |
|
9470 - retarray->base_addr = xmalloc (alloc_size); |
|
9471 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
9472 if (alloc_size == 0) |
|
9473 { |
|
9474 /* Make sure we have a zero-sized array. */ |
|
9475 @@ -272,8 +271,7 @@ |
|
9476 |
|
9477 } |
|
9478 |
|
9479 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9480 - * extent[rank-1]; |
|
9481 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9482 |
|
9483 retarray->offset = 0; |
|
9484 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9485 @@ -285,7 +283,7 @@ |
|
9486 return; |
|
9487 } |
|
9488 else |
|
9489 - retarray->base_addr = xmalloc (alloc_size); |
|
9490 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
9491 |
|
9492 } |
|
9493 else |
|
9494 @@ -430,8 +428,7 @@ |
|
9495 retarray->offset = 0; |
|
9496 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9497 |
|
9498 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9499 - * extent[rank-1]; |
|
9500 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9501 |
|
9502 if (alloc_size == 0) |
|
9503 { |
|
9504 @@ -440,7 +437,7 @@ |
|
9505 return; |
|
9506 } |
|
9507 else |
|
9508 - retarray->base_addr = xmalloc (alloc_size); |
|
9509 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
9510 } |
|
9511 else |
|
9512 { |
|
9513 Index: gcc-4.8_branch/libgfortran/generated/maxloc1_16_i1.c |
|
9514 =================================================================== |
|
9515 --- gcc-4.8_branch/libgfortran/generated/maxloc1_16_i1.c (revision 213312) |
|
9516 +++ gcc-4.8_branch/libgfortran/generated/maxloc1_16_i1.c (revision 213313) |
|
9517 @@ -98,10 +98,9 @@ |
|
9518 retarray->offset = 0; |
|
9519 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9520 |
|
9521 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9522 - * extent[rank-1]; |
|
9523 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9524 |
|
9525 - retarray->base_addr = xmalloc (alloc_size); |
|
9526 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
9527 if (alloc_size == 0) |
|
9528 { |
|
9529 /* Make sure we have a zero-sized array. */ |
|
9530 @@ -294,8 +293,7 @@ |
|
9531 |
|
9532 } |
|
9533 |
|
9534 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9535 - * extent[rank-1]; |
|
9536 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9537 |
|
9538 retarray->offset = 0; |
|
9539 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9540 @@ -307,7 +305,7 @@ |
|
9541 return; |
|
9542 } |
|
9543 else |
|
9544 - retarray->base_addr = xmalloc (alloc_size); |
|
9545 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
9546 |
|
9547 } |
|
9548 else |
|
9549 @@ -485,8 +483,7 @@ |
|
9550 retarray->offset = 0; |
|
9551 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9552 |
|
9553 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9554 - * extent[rank-1]; |
|
9555 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9556 |
|
9557 if (alloc_size == 0) |
|
9558 { |
|
9559 @@ -495,7 +492,7 @@ |
|
9560 return; |
|
9561 } |
|
9562 else |
|
9563 - retarray->base_addr = xmalloc (alloc_size); |
|
9564 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
9565 } |
|
9566 else |
|
9567 { |
|
9568 Index: gcc-4.8_branch/libgfortran/generated/reshape_i16.c |
|
9569 =================================================================== |
|
9570 --- gcc-4.8_branch/libgfortran/generated/reshape_i16.c (revision 213312) |
|
9571 +++ gcc-4.8_branch/libgfortran/generated/reshape_i16.c (revision 213313) |
|
9572 @@ -111,11 +111,11 @@ |
|
9573 ret->offset = 0; |
|
9574 |
|
9575 if (unlikely (rs < 1)) |
|
9576 - alloc_size = 1; |
|
9577 + alloc_size = 0; |
|
9578 else |
|
9579 - alloc_size = rs * sizeof (GFC_INTEGER_16); |
|
9580 + alloc_size = rs; |
|
9581 |
|
9582 - ret->base_addr = xmalloc (alloc_size); |
|
9583 + ret->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
9584 ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim; |
|
9585 } |
|
9586 |
|
9587 Index: gcc-4.8_branch/libgfortran/generated/count_16_l.c |
|
9588 =================================================================== |
|
9589 --- gcc-4.8_branch/libgfortran/generated/count_16_l.c (revision 213312) |
|
9590 +++ gcc-4.8_branch/libgfortran/generated/count_16_l.c (revision 213313) |
|
9591 @@ -101,8 +101,7 @@ |
|
9592 retarray->offset = 0; |
|
9593 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9594 |
|
9595 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9596 - * extent[rank-1]; |
|
9597 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9598 |
|
9599 if (alloc_size == 0) |
|
9600 { |
|
9601 @@ -111,7 +110,7 @@ |
|
9602 return; |
|
9603 } |
|
9604 else |
|
9605 - retarray->base_addr = xmalloc (alloc_size); |
|
9606 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
9607 } |
|
9608 else |
|
9609 { |
|
9610 Index: gcc-4.8_branch/libgfortran/generated/minloc1_8_i1.c |
|
9611 =================================================================== |
|
9612 --- gcc-4.8_branch/libgfortran/generated/minloc1_8_i1.c (revision 213312) |
|
9613 +++ gcc-4.8_branch/libgfortran/generated/minloc1_8_i1.c (revision 213313) |
|
9614 @@ -98,10 +98,9 @@ |
|
9615 retarray->offset = 0; |
|
9616 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9617 |
|
9618 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9619 - * extent[rank-1]; |
|
9620 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9621 |
|
9622 - retarray->base_addr = xmalloc (alloc_size); |
|
9623 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
9624 if (alloc_size == 0) |
|
9625 { |
|
9626 /* Make sure we have a zero-sized array. */ |
|
9627 @@ -294,8 +293,7 @@ |
|
9628 |
|
9629 } |
|
9630 |
|
9631 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9632 - * extent[rank-1]; |
|
9633 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9634 |
|
9635 retarray->offset = 0; |
|
9636 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9637 @@ -307,7 +305,7 @@ |
|
9638 return; |
|
9639 } |
|
9640 else |
|
9641 - retarray->base_addr = xmalloc (alloc_size); |
|
9642 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
9643 |
|
9644 } |
|
9645 else |
|
9646 @@ -485,8 +483,7 @@ |
|
9647 retarray->offset = 0; |
|
9648 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9649 |
|
9650 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9651 - * extent[rank-1]; |
|
9652 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9653 |
|
9654 if (alloc_size == 0) |
|
9655 { |
|
9656 @@ -495,7 +492,7 @@ |
|
9657 return; |
|
9658 } |
|
9659 else |
|
9660 - retarray->base_addr = xmalloc (alloc_size); |
|
9661 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
9662 } |
|
9663 else |
|
9664 { |
|
9665 Index: gcc-4.8_branch/libgfortran/generated/maxloc1_4_i4.c |
|
9666 =================================================================== |
|
9667 --- gcc-4.8_branch/libgfortran/generated/maxloc1_4_i4.c (revision 213312) |
|
9668 +++ gcc-4.8_branch/libgfortran/generated/maxloc1_4_i4.c (revision 213313) |
|
9669 @@ -98,10 +98,9 @@ |
|
9670 retarray->offset = 0; |
|
9671 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9672 |
|
9673 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9674 - * extent[rank-1]; |
|
9675 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9676 |
|
9677 - retarray->base_addr = xmalloc (alloc_size); |
|
9678 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
9679 if (alloc_size == 0) |
|
9680 { |
|
9681 /* Make sure we have a zero-sized array. */ |
|
9682 @@ -294,8 +293,7 @@ |
|
9683 |
|
9684 } |
|
9685 |
|
9686 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9687 - * extent[rank-1]; |
|
9688 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9689 |
|
9690 retarray->offset = 0; |
|
9691 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9692 @@ -307,7 +305,7 @@ |
|
9693 return; |
|
9694 } |
|
9695 else |
|
9696 - retarray->base_addr = xmalloc (alloc_size); |
|
9697 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
9698 |
|
9699 } |
|
9700 else |
|
9701 @@ -485,8 +483,7 @@ |
|
9702 retarray->offset = 0; |
|
9703 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9704 |
|
9705 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9706 - * extent[rank-1]; |
|
9707 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9708 |
|
9709 if (alloc_size == 0) |
|
9710 { |
|
9711 @@ -495,7 +492,7 @@ |
|
9712 return; |
|
9713 } |
|
9714 else |
|
9715 - retarray->base_addr = xmalloc (alloc_size); |
|
9716 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
9717 } |
|
9718 else |
|
9719 { |
|
9720 Index: gcc-4.8_branch/libgfortran/generated/maxval_i8.c |
|
9721 =================================================================== |
|
9722 --- gcc-4.8_branch/libgfortran/generated/maxval_i8.c (revision 213312) |
|
9723 +++ gcc-4.8_branch/libgfortran/generated/maxval_i8.c (revision 213313) |
|
9724 @@ -97,10 +97,9 @@ |
|
9725 retarray->offset = 0; |
|
9726 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9727 |
|
9728 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9729 - * extent[rank-1]; |
|
9730 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9731 |
|
9732 - retarray->base_addr = xmalloc (alloc_size); |
|
9733 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
9734 if (alloc_size == 0) |
|
9735 { |
|
9736 /* Make sure we have a zero-sized array. */ |
|
9737 @@ -286,8 +285,7 @@ |
|
9738 |
|
9739 } |
|
9740 |
|
9741 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9742 - * extent[rank-1]; |
|
9743 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9744 |
|
9745 retarray->offset = 0; |
|
9746 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9747 @@ -299,7 +297,7 @@ |
|
9748 return; |
|
9749 } |
|
9750 else |
|
9751 - retarray->base_addr = xmalloc (alloc_size); |
|
9752 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
9753 |
|
9754 } |
|
9755 else |
|
9756 @@ -472,8 +470,7 @@ |
|
9757 retarray->offset = 0; |
|
9758 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9759 |
|
9760 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9761 - * extent[rank-1]; |
|
9762 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9763 |
|
9764 if (alloc_size == 0) |
|
9765 { |
|
9766 @@ -482,7 +479,7 @@ |
|
9767 return; |
|
9768 } |
|
9769 else |
|
9770 - retarray->base_addr = xmalloc (alloc_size); |
|
9771 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
9772 } |
|
9773 else |
|
9774 { |
|
9775 Index: gcc-4.8_branch/libgfortran/generated/eoshift3_16.c |
|
9776 =================================================================== |
|
9777 --- gcc-4.8_branch/libgfortran/generated/eoshift3_16.c (revision 213312) |
|
9778 +++ gcc-4.8_branch/libgfortran/generated/eoshift3_16.c (revision 213313) |
|
9779 @@ -89,7 +89,7 @@ |
|
9780 { |
|
9781 int i; |
|
9782 |
|
9783 - ret->base_addr = xmalloc (size * arraysize); |
|
9784 + ret->base_addr = xmallocarray (arraysize, size); |
|
9785 ret->offset = 0; |
|
9786 ret->dtype = array->dtype; |
|
9787 for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++) |
|
9788 @@ -107,8 +107,8 @@ |
|
9789 GFC_DIMENSION_SET(ret->dim[i], 0, ub, str); |
|
9790 |
|
9791 } |
|
9792 - /* xmalloc allocates a single byte for zero size. */ |
|
9793 - ret->base_addr = xmalloc (size * arraysize); |
|
9794 + /* xmallocarray allocates a single byte for zero size. */ |
|
9795 + ret->base_addr = xmallocarray (arraysize, size); |
|
9796 |
|
9797 } |
|
9798 else if (unlikely (compile_options.bounds_check)) |
|
9799 Index: gcc-4.8_branch/libgfortran/generated/shape_i8.c |
|
9800 =================================================================== |
|
9801 --- gcc-4.8_branch/libgfortran/generated/shape_i8.c (revision 213312) |
|
9802 +++ gcc-4.8_branch/libgfortran/generated/shape_i8.c (revision 213313) |
|
9803 @@ -49,7 +49,7 @@ |
|
9804 { |
|
9805 GFC_DIMENSION_SET(ret->dim[0], 0, rank - 1, 1); |
|
9806 ret->offset = 0; |
|
9807 - ret->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
9808 + ret->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
9809 } |
|
9810 |
|
9811 stride = GFC_DESCRIPTOR_STRIDE(ret,0); |
|
9812 Index: gcc-4.8_branch/libgfortran/generated/maxloc0_4_i16.c |
|
9813 =================================================================== |
|
9814 --- gcc-4.8_branch/libgfortran/generated/maxloc0_4_i16.c (revision 213312) |
|
9815 +++ gcc-4.8_branch/libgfortran/generated/maxloc0_4_i16.c (revision 213313) |
|
9816 @@ -58,7 +58,7 @@ |
|
9817 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
9818 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
9819 retarray->offset = 0; |
|
9820 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
9821 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
9822 } |
|
9823 else |
|
9824 { |
|
9825 @@ -199,7 +199,7 @@ |
|
9826 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
9827 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
9828 retarray->offset = 0; |
|
9829 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
9830 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
9831 } |
|
9832 else |
|
9833 { |
|
9834 @@ -367,7 +367,7 @@ |
|
9835 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
9836 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
9837 retarray->offset = 0; |
|
9838 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
9839 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
9840 } |
|
9841 else if (unlikely (compile_options.bounds_check)) |
|
9842 { |
|
9843 Index: gcc-4.8_branch/libgfortran/generated/maxloc1_4_r10.c |
|
9844 =================================================================== |
|
9845 --- gcc-4.8_branch/libgfortran/generated/maxloc1_4_r10.c (revision 213312) |
|
9846 +++ gcc-4.8_branch/libgfortran/generated/maxloc1_4_r10.c (revision 213313) |
|
9847 @@ -98,10 +98,9 @@ |
|
9848 retarray->offset = 0; |
|
9849 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9850 |
|
9851 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9852 - * extent[rank-1]; |
|
9853 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9854 |
|
9855 - retarray->base_addr = xmalloc (alloc_size); |
|
9856 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
9857 if (alloc_size == 0) |
|
9858 { |
|
9859 /* Make sure we have a zero-sized array. */ |
|
9860 @@ -294,8 +293,7 @@ |
|
9861 |
|
9862 } |
|
9863 |
|
9864 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9865 - * extent[rank-1]; |
|
9866 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9867 |
|
9868 retarray->offset = 0; |
|
9869 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9870 @@ -307,7 +305,7 @@ |
|
9871 return; |
|
9872 } |
|
9873 else |
|
9874 - retarray->base_addr = xmalloc (alloc_size); |
|
9875 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
9876 |
|
9877 } |
|
9878 else |
|
9879 @@ -485,8 +483,7 @@ |
|
9880 retarray->offset = 0; |
|
9881 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9882 |
|
9883 - alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9884 - * extent[rank-1]; |
|
9885 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9886 |
|
9887 if (alloc_size == 0) |
|
9888 { |
|
9889 @@ -495,7 +492,7 @@ |
|
9890 return; |
|
9891 } |
|
9892 else |
|
9893 - retarray->base_addr = xmalloc (alloc_size); |
|
9894 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); |
|
9895 } |
|
9896 else |
|
9897 { |
|
9898 Index: gcc-4.8_branch/libgfortran/generated/maxloc1_8_i16.c |
|
9899 =================================================================== |
|
9900 --- gcc-4.8_branch/libgfortran/generated/maxloc1_8_i16.c (revision 213312) |
|
9901 +++ gcc-4.8_branch/libgfortran/generated/maxloc1_8_i16.c (revision 213313) |
|
9902 @@ -98,10 +98,9 @@ |
|
9903 retarray->offset = 0; |
|
9904 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9905 |
|
9906 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9907 - * extent[rank-1]; |
|
9908 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9909 |
|
9910 - retarray->base_addr = xmalloc (alloc_size); |
|
9911 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
9912 if (alloc_size == 0) |
|
9913 { |
|
9914 /* Make sure we have a zero-sized array. */ |
|
9915 @@ -294,8 +293,7 @@ |
|
9916 |
|
9917 } |
|
9918 |
|
9919 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9920 - * extent[rank-1]; |
|
9921 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9922 |
|
9923 retarray->offset = 0; |
|
9924 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9925 @@ -307,7 +305,7 @@ |
|
9926 return; |
|
9927 } |
|
9928 else |
|
9929 - retarray->base_addr = xmalloc (alloc_size); |
|
9930 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
9931 |
|
9932 } |
|
9933 else |
|
9934 @@ -485,8 +483,7 @@ |
|
9935 retarray->offset = 0; |
|
9936 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9937 |
|
9938 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9939 - * extent[rank-1]; |
|
9940 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9941 |
|
9942 if (alloc_size == 0) |
|
9943 { |
|
9944 @@ -495,7 +492,7 @@ |
|
9945 return; |
|
9946 } |
|
9947 else |
|
9948 - retarray->base_addr = xmalloc (alloc_size); |
|
9949 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
9950 } |
|
9951 else |
|
9952 { |
|
9953 Index: gcc-4.8_branch/libgfortran/generated/minloc0_8_r10.c |
|
9954 =================================================================== |
|
9955 --- gcc-4.8_branch/libgfortran/generated/minloc0_8_r10.c (revision 213312) |
|
9956 +++ gcc-4.8_branch/libgfortran/generated/minloc0_8_r10.c (revision 213313) |
|
9957 @@ -58,7 +58,7 @@ |
|
9958 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
9959 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
9960 retarray->offset = 0; |
|
9961 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
9962 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
9963 } |
|
9964 else |
|
9965 { |
|
9966 @@ -199,7 +199,7 @@ |
|
9967 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
9968 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
9969 retarray->offset = 0; |
|
9970 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
9971 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
9972 } |
|
9973 else |
|
9974 { |
|
9975 @@ -367,7 +367,7 @@ |
|
9976 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
9977 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
9978 retarray->offset = 0; |
|
9979 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
9980 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
9981 } |
|
9982 else if (unlikely (compile_options.bounds_check)) |
|
9983 { |
|
9984 Index: gcc-4.8_branch/libgfortran/generated/iparity_i2.c |
|
9985 =================================================================== |
|
9986 --- gcc-4.8_branch/libgfortran/generated/iparity_i2.c (revision 213312) |
|
9987 +++ gcc-4.8_branch/libgfortran/generated/iparity_i2.c (revision 213313) |
|
9988 @@ -97,10 +97,9 @@ |
|
9989 retarray->offset = 0; |
|
9990 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
9991 |
|
9992 - alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
9993 - * extent[rank-1]; |
|
9994 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
9995 |
|
9996 - retarray->base_addr = xmalloc (alloc_size); |
|
9997 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); |
|
9998 if (alloc_size == 0) |
|
9999 { |
|
10000 /* Make sure we have a zero-sized array. */ |
|
10001 @@ -272,8 +271,7 @@ |
|
10002 |
|
10003 } |
|
10004 |
|
10005 - alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10006 - * extent[rank-1]; |
|
10007 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10008 |
|
10009 retarray->offset = 0; |
|
10010 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10011 @@ -285,7 +283,7 @@ |
|
10012 return; |
|
10013 } |
|
10014 else |
|
10015 - retarray->base_addr = xmalloc (alloc_size); |
|
10016 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); |
|
10017 |
|
10018 } |
|
10019 else |
|
10020 @@ -430,8 +428,7 @@ |
|
10021 retarray->offset = 0; |
|
10022 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10023 |
|
10024 - alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10025 - * extent[rank-1]; |
|
10026 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10027 |
|
10028 if (alloc_size == 0) |
|
10029 { |
|
10030 @@ -440,7 +437,7 @@ |
|
10031 return; |
|
10032 } |
|
10033 else |
|
10034 - retarray->base_addr = xmalloc (alloc_size); |
|
10035 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); |
|
10036 } |
|
10037 else |
|
10038 { |
|
10039 Index: gcc-4.8_branch/libgfortran/generated/maxloc1_16_r4.c |
|
10040 =================================================================== |
|
10041 --- gcc-4.8_branch/libgfortran/generated/maxloc1_16_r4.c (revision 213312) |
|
10042 +++ gcc-4.8_branch/libgfortran/generated/maxloc1_16_r4.c (revision 213313) |
|
10043 @@ -98,10 +98,9 @@ |
|
10044 retarray->offset = 0; |
|
10045 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10046 |
|
10047 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10048 - * extent[rank-1]; |
|
10049 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10050 |
|
10051 - retarray->base_addr = xmalloc (alloc_size); |
|
10052 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
10053 if (alloc_size == 0) |
|
10054 { |
|
10055 /* Make sure we have a zero-sized array. */ |
|
10056 @@ -294,8 +293,7 @@ |
|
10057 |
|
10058 } |
|
10059 |
|
10060 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10061 - * extent[rank-1]; |
|
10062 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10063 |
|
10064 retarray->offset = 0; |
|
10065 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10066 @@ -307,7 +305,7 @@ |
|
10067 return; |
|
10068 } |
|
10069 else |
|
10070 - retarray->base_addr = xmalloc (alloc_size); |
|
10071 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
10072 |
|
10073 } |
|
10074 else |
|
10075 @@ -485,8 +483,7 @@ |
|
10076 retarray->offset = 0; |
|
10077 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10078 |
|
10079 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10080 - * extent[rank-1]; |
|
10081 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10082 |
|
10083 if (alloc_size == 0) |
|
10084 { |
|
10085 @@ -495,7 +492,7 @@ |
|
10086 return; |
|
10087 } |
|
10088 else |
|
10089 - retarray->base_addr = xmalloc (alloc_size); |
|
10090 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
10091 } |
|
10092 else |
|
10093 { |
|
10094 Index: gcc-4.8_branch/libgfortran/generated/maxloc0_16_r8.c |
|
10095 =================================================================== |
|
10096 --- gcc-4.8_branch/libgfortran/generated/maxloc0_16_r8.c (revision 213312) |
|
10097 +++ gcc-4.8_branch/libgfortran/generated/maxloc0_16_r8.c (revision 213313) |
|
10098 @@ -58,7 +58,7 @@ |
|
10099 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
10100 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
10101 retarray->offset = 0; |
|
10102 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
10103 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
10104 } |
|
10105 else |
|
10106 { |
|
10107 @@ -199,7 +199,7 @@ |
|
10108 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
10109 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
10110 retarray->offset = 0; |
|
10111 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
10112 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
10113 } |
|
10114 else |
|
10115 { |
|
10116 @@ -367,7 +367,7 @@ |
|
10117 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
10118 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
10119 retarray->offset = 0; |
|
10120 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank); |
|
10121 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_16)); |
|
10122 } |
|
10123 else if (unlikely (compile_options.bounds_check)) |
|
10124 { |
|
10125 Index: gcc-4.8_branch/libgfortran/generated/sum_i16.c |
|
10126 =================================================================== |
|
10127 --- gcc-4.8_branch/libgfortran/generated/sum_i16.c (revision 213312) |
|
10128 +++ gcc-4.8_branch/libgfortran/generated/sum_i16.c (revision 213313) |
|
10129 @@ -97,10 +97,9 @@ |
|
10130 retarray->offset = 0; |
|
10131 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10132 |
|
10133 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10134 - * extent[rank-1]; |
|
10135 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10136 |
|
10137 - retarray->base_addr = xmalloc (alloc_size); |
|
10138 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
10139 if (alloc_size == 0) |
|
10140 { |
|
10141 /* Make sure we have a zero-sized array. */ |
|
10142 @@ -272,8 +271,7 @@ |
|
10143 |
|
10144 } |
|
10145 |
|
10146 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10147 - * extent[rank-1]; |
|
10148 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10149 |
|
10150 retarray->offset = 0; |
|
10151 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10152 @@ -285,7 +283,7 @@ |
|
10153 return; |
|
10154 } |
|
10155 else |
|
10156 - retarray->base_addr = xmalloc (alloc_size); |
|
10157 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
10158 |
|
10159 } |
|
10160 else |
|
10161 @@ -430,8 +428,7 @@ |
|
10162 retarray->offset = 0; |
|
10163 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10164 |
|
10165 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10166 - * extent[rank-1]; |
|
10167 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10168 |
|
10169 if (alloc_size == 0) |
|
10170 { |
|
10171 @@ -440,7 +437,7 @@ |
|
10172 return; |
|
10173 } |
|
10174 else |
|
10175 - retarray->base_addr = xmalloc (alloc_size); |
|
10176 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
10177 } |
|
10178 else |
|
10179 { |
|
10180 Index: gcc-4.8_branch/libgfortran/generated/maxloc0_4_i8.c |
|
10181 =================================================================== |
|
10182 --- gcc-4.8_branch/libgfortran/generated/maxloc0_4_i8.c (revision 213312) |
|
10183 +++ gcc-4.8_branch/libgfortran/generated/maxloc0_4_i8.c (revision 213313) |
|
10184 @@ -58,7 +58,7 @@ |
|
10185 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
10186 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
10187 retarray->offset = 0; |
|
10188 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
10189 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
10190 } |
|
10191 else |
|
10192 { |
|
10193 @@ -199,7 +199,7 @@ |
|
10194 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
10195 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
10196 retarray->offset = 0; |
|
10197 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
10198 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
10199 } |
|
10200 else |
|
10201 { |
|
10202 @@ -367,7 +367,7 @@ |
|
10203 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
10204 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
10205 retarray->offset = 0; |
|
10206 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank); |
|
10207 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4)); |
|
10208 } |
|
10209 else if (unlikely (compile_options.bounds_check)) |
|
10210 { |
|
10211 Index: gcc-4.8_branch/libgfortran/generated/pack_c16.c |
|
10212 =================================================================== |
|
10213 --- gcc-4.8_branch/libgfortran/generated/pack_c16.c (revision 213312) |
|
10214 +++ gcc-4.8_branch/libgfortran/generated/pack_c16.c (revision 213313) |
|
10215 @@ -167,8 +167,8 @@ |
|
10216 |
|
10217 ret->offset = 0; |
|
10218 |
|
10219 - /* xmalloc allocates a single byte for zero size. */ |
|
10220 - ret->base_addr = xmalloc (sizeof (GFC_COMPLEX_16) * total); |
|
10221 + /* xmallocarray allocates a single byte for zero size. */ |
|
10222 + ret->base_addr = xmallocarray (total, sizeof (GFC_COMPLEX_16)); |
|
10223 |
|
10224 if (total == 0) |
|
10225 return; |
|
10226 Index: gcc-4.8_branch/libgfortran/generated/maxloc1_16_i16.c |
|
10227 =================================================================== |
|
10228 --- gcc-4.8_branch/libgfortran/generated/maxloc1_16_i16.c (revision 213312) |
|
10229 +++ gcc-4.8_branch/libgfortran/generated/maxloc1_16_i16.c (revision 213313) |
|
10230 @@ -98,10 +98,9 @@ |
|
10231 retarray->offset = 0; |
|
10232 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10233 |
|
10234 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10235 - * extent[rank-1]; |
|
10236 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10237 |
|
10238 - retarray->base_addr = xmalloc (alloc_size); |
|
10239 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
10240 if (alloc_size == 0) |
|
10241 { |
|
10242 /* Make sure we have a zero-sized array. */ |
|
10243 @@ -294,8 +293,7 @@ |
|
10244 |
|
10245 } |
|
10246 |
|
10247 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10248 - * extent[rank-1]; |
|
10249 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10250 |
|
10251 retarray->offset = 0; |
|
10252 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10253 @@ -307,7 +305,7 @@ |
|
10254 return; |
|
10255 } |
|
10256 else |
|
10257 - retarray->base_addr = xmalloc (alloc_size); |
|
10258 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
10259 |
|
10260 } |
|
10261 else |
|
10262 @@ -485,8 +483,7 @@ |
|
10263 retarray->offset = 0; |
|
10264 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10265 |
|
10266 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10267 - * extent[rank-1]; |
|
10268 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10269 |
|
10270 if (alloc_size == 0) |
|
10271 { |
|
10272 @@ -495,7 +492,7 @@ |
|
10273 return; |
|
10274 } |
|
10275 else |
|
10276 - retarray->base_addr = xmalloc (alloc_size); |
|
10277 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
10278 } |
|
10279 else |
|
10280 { |
|
10281 Index: gcc-4.8_branch/libgfortran/generated/minloc1_8_r4.c |
|
10282 =================================================================== |
|
10283 --- gcc-4.8_branch/libgfortran/generated/minloc1_8_r4.c (revision 213312) |
|
10284 +++ gcc-4.8_branch/libgfortran/generated/minloc1_8_r4.c (revision 213313) |
|
10285 @@ -98,10 +98,9 @@ |
|
10286 retarray->offset = 0; |
|
10287 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10288 |
|
10289 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10290 - * extent[rank-1]; |
|
10291 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10292 |
|
10293 - retarray->base_addr = xmalloc (alloc_size); |
|
10294 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
10295 if (alloc_size == 0) |
|
10296 { |
|
10297 /* Make sure we have a zero-sized array. */ |
|
10298 @@ -294,8 +293,7 @@ |
|
10299 |
|
10300 } |
|
10301 |
|
10302 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10303 - * extent[rank-1]; |
|
10304 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10305 |
|
10306 retarray->offset = 0; |
|
10307 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10308 @@ -307,7 +305,7 @@ |
|
10309 return; |
|
10310 } |
|
10311 else |
|
10312 - retarray->base_addr = xmalloc (alloc_size); |
|
10313 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
10314 |
|
10315 } |
|
10316 else |
|
10317 @@ -485,8 +483,7 @@ |
|
10318 retarray->offset = 0; |
|
10319 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10320 |
|
10321 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10322 - * extent[rank-1]; |
|
10323 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10324 |
|
10325 if (alloc_size == 0) |
|
10326 { |
|
10327 @@ -495,7 +492,7 @@ |
|
10328 return; |
|
10329 } |
|
10330 else |
|
10331 - retarray->base_addr = xmalloc (alloc_size); |
|
10332 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
10333 } |
|
10334 else |
|
10335 { |
|
10336 Index: gcc-4.8_branch/libgfortran/generated/sum_c8.c |
|
10337 =================================================================== |
|
10338 --- gcc-4.8_branch/libgfortran/generated/sum_c8.c (revision 213312) |
|
10339 +++ gcc-4.8_branch/libgfortran/generated/sum_c8.c (revision 213313) |
|
10340 @@ -97,10 +97,9 @@ |
|
10341 retarray->offset = 0; |
|
10342 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10343 |
|
10344 - alloc_size = sizeof (GFC_COMPLEX_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10345 - * extent[rank-1]; |
|
10346 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10347 |
|
10348 - retarray->base_addr = xmalloc (alloc_size); |
|
10349 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_8)); |
|
10350 if (alloc_size == 0) |
|
10351 { |
|
10352 /* Make sure we have a zero-sized array. */ |
|
10353 @@ -272,8 +271,7 @@ |
|
10354 |
|
10355 } |
|
10356 |
|
10357 - alloc_size = sizeof (GFC_COMPLEX_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10358 - * extent[rank-1]; |
|
10359 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10360 |
|
10361 retarray->offset = 0; |
|
10362 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10363 @@ -285,7 +283,7 @@ |
|
10364 return; |
|
10365 } |
|
10366 else |
|
10367 - retarray->base_addr = xmalloc (alloc_size); |
|
10368 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_8)); |
|
10369 |
|
10370 } |
|
10371 else |
|
10372 @@ -430,8 +428,7 @@ |
|
10373 retarray->offset = 0; |
|
10374 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10375 |
|
10376 - alloc_size = sizeof (GFC_COMPLEX_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10377 - * extent[rank-1]; |
|
10378 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10379 |
|
10380 if (alloc_size == 0) |
|
10381 { |
|
10382 @@ -440,7 +437,7 @@ |
|
10383 return; |
|
10384 } |
|
10385 else |
|
10386 - retarray->base_addr = xmalloc (alloc_size); |
|
10387 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_COMPLEX_8)); |
|
10388 } |
|
10389 else |
|
10390 { |
|
10391 Index: gcc-4.8_branch/libgfortran/generated/maxloc1_16_i2.c |
|
10392 =================================================================== |
|
10393 --- gcc-4.8_branch/libgfortran/generated/maxloc1_16_i2.c (revision 213312) |
|
10394 +++ gcc-4.8_branch/libgfortran/generated/maxloc1_16_i2.c (revision 213313) |
|
10395 @@ -98,10 +98,9 @@ |
|
10396 retarray->offset = 0; |
|
10397 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10398 |
|
10399 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10400 - * extent[rank-1]; |
|
10401 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10402 |
|
10403 - retarray->base_addr = xmalloc (alloc_size); |
|
10404 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
10405 if (alloc_size == 0) |
|
10406 { |
|
10407 /* Make sure we have a zero-sized array. */ |
|
10408 @@ -294,8 +293,7 @@ |
|
10409 |
|
10410 } |
|
10411 |
|
10412 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10413 - * extent[rank-1]; |
|
10414 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10415 |
|
10416 retarray->offset = 0; |
|
10417 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10418 @@ -307,7 +305,7 @@ |
|
10419 return; |
|
10420 } |
|
10421 else |
|
10422 - retarray->base_addr = xmalloc (alloc_size); |
|
10423 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
10424 |
|
10425 } |
|
10426 else |
|
10427 @@ -485,8 +483,7 @@ |
|
10428 retarray->offset = 0; |
|
10429 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10430 |
|
10431 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10432 - * extent[rank-1]; |
|
10433 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10434 |
|
10435 if (alloc_size == 0) |
|
10436 { |
|
10437 @@ -495,7 +492,7 @@ |
|
10438 return; |
|
10439 } |
|
10440 else |
|
10441 - retarray->base_addr = xmalloc (alloc_size); |
|
10442 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
10443 } |
|
10444 else |
|
10445 { |
|
10446 Index: gcc-4.8_branch/libgfortran/generated/parity_l1.c |
|
10447 =================================================================== |
|
10448 --- gcc-4.8_branch/libgfortran/generated/parity_l1.c (revision 213312) |
|
10449 +++ gcc-4.8_branch/libgfortran/generated/parity_l1.c (revision 213313) |
|
10450 @@ -98,10 +98,9 @@ |
|
10451 retarray->offset = 0; |
|
10452 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10453 |
|
10454 - alloc_size = sizeof (GFC_LOGICAL_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10455 - * extent[rank-1]; |
|
10456 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10457 |
|
10458 - retarray->base_addr = xmalloc (alloc_size); |
|
10459 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_LOGICAL_1)); |
|
10460 if (alloc_size == 0) |
|
10461 { |
|
10462 /* Make sure we have a zero-sized array. */ |
|
10463 Index: gcc-4.8_branch/libgfortran/generated/maxval_i16.c |
|
10464 =================================================================== |
|
10465 --- gcc-4.8_branch/libgfortran/generated/maxval_i16.c (revision 213312) |
|
10466 +++ gcc-4.8_branch/libgfortran/generated/maxval_i16.c (revision 213313) |
|
10467 @@ -97,10 +97,9 @@ |
|
10468 retarray->offset = 0; |
|
10469 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10470 |
|
10471 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10472 - * extent[rank-1]; |
|
10473 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10474 |
|
10475 - retarray->base_addr = xmalloc (alloc_size); |
|
10476 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
10477 if (alloc_size == 0) |
|
10478 { |
|
10479 /* Make sure we have a zero-sized array. */ |
|
10480 @@ -286,8 +285,7 @@ |
|
10481 |
|
10482 } |
|
10483 |
|
10484 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10485 - * extent[rank-1]; |
|
10486 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10487 |
|
10488 retarray->offset = 0; |
|
10489 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10490 @@ -299,7 +297,7 @@ |
|
10491 return; |
|
10492 } |
|
10493 else |
|
10494 - retarray->base_addr = xmalloc (alloc_size); |
|
10495 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
10496 |
|
10497 } |
|
10498 else |
|
10499 @@ -472,8 +470,7 @@ |
|
10500 retarray->offset = 0; |
|
10501 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10502 |
|
10503 - alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10504 - * extent[rank-1]; |
|
10505 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10506 |
|
10507 if (alloc_size == 0) |
|
10508 { |
|
10509 @@ -482,7 +479,7 @@ |
|
10510 return; |
|
10511 } |
|
10512 else |
|
10513 - retarray->base_addr = xmalloc (alloc_size); |
|
10514 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); |
|
10515 } |
|
10516 else |
|
10517 { |
|
10518 Index: gcc-4.8_branch/libgfortran/generated/spread_c8.c |
|
10519 =================================================================== |
|
10520 --- gcc-4.8_branch/libgfortran/generated/spread_c8.c (revision 213312) |
|
10521 +++ gcc-4.8_branch/libgfortran/generated/spread_c8.c (revision 213313) |
|
10522 @@ -101,8 +101,8 @@ |
|
10523 } |
|
10524 ret->offset = 0; |
|
10525 |
|
10526 - /* xmalloc allocates a single byte for zero size. */ |
|
10527 - ret->base_addr = xmalloc (rs * sizeof(GFC_COMPLEX_8)); |
|
10528 + /* xmallocarray allocates a single byte for zero size. */ |
|
10529 + ret->base_addr = xmallocarray (rs, sizeof(GFC_COMPLEX_8)); |
|
10530 if (rs <= 0) |
|
10531 return; |
|
10532 } |
|
10533 @@ -244,7 +244,7 @@ |
|
10534 |
|
10535 if (ret->base_addr == NULL) |
|
10536 { |
|
10537 - ret->base_addr = xmalloc (ncopies * sizeof (GFC_COMPLEX_8)); |
|
10538 + ret->base_addr = xmallocarray (ncopies, sizeof (GFC_COMPLEX_8)); |
|
10539 ret->offset = 0; |
|
10540 GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1); |
|
10541 } |
|
10542 Index: gcc-4.8_branch/libgfortran/generated/matmul_i16.c |
|
10543 =================================================================== |
|
10544 --- gcc-4.8_branch/libgfortran/generated/matmul_i16.c (revision 213312) |
|
10545 +++ gcc-4.8_branch/libgfortran/generated/matmul_i16.c (revision 213313) |
|
10546 @@ -124,7 +124,7 @@ |
|
10547 } |
|
10548 |
|
10549 retarray->base_addr |
|
10550 - = xmalloc (sizeof (GFC_INTEGER_16) * size0 ((array_t *) retarray)); |
|
10551 + = xmallocarray (size0 ((array_t *) retarray), sizeof (GFC_INTEGER_16)); |
|
10552 retarray->offset = 0; |
|
10553 } |
|
10554 else if (unlikely (compile_options.bounds_check)) |
|
10555 Index: gcc-4.8_branch/libgfortran/generated/pack_i8.c |
|
10556 =================================================================== |
|
10557 --- gcc-4.8_branch/libgfortran/generated/pack_i8.c (revision 213312) |
|
10558 +++ gcc-4.8_branch/libgfortran/generated/pack_i8.c (revision 213313) |
|
10559 @@ -167,8 +167,8 @@ |
|
10560 |
|
10561 ret->offset = 0; |
|
10562 |
|
10563 - /* xmalloc allocates a single byte for zero size. */ |
|
10564 - ret->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * total); |
|
10565 + /* xmallocarray allocates a single byte for zero size. */ |
|
10566 + ret->base_addr = xmallocarray (total, sizeof (GFC_INTEGER_8)); |
|
10567 |
|
10568 if (total == 0) |
|
10569 return; |
|
10570 Index: gcc-4.8_branch/libgfortran/generated/any_l1.c |
|
10571 =================================================================== |
|
10572 --- gcc-4.8_branch/libgfortran/generated/any_l1.c (revision 213312) |
|
10573 +++ gcc-4.8_branch/libgfortran/generated/any_l1.c (revision 213313) |
|
10574 @@ -101,8 +101,7 @@ |
|
10575 retarray->offset = 0; |
|
10576 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10577 |
|
10578 - alloc_size = sizeof (GFC_LOGICAL_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10579 - * extent[rank-1]; |
|
10580 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10581 |
|
10582 if (alloc_size == 0) |
|
10583 { |
|
10584 @@ -111,7 +110,7 @@ |
|
10585 return; |
|
10586 } |
|
10587 else |
|
10588 - retarray->base_addr = xmalloc (alloc_size); |
|
10589 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_LOGICAL_1)); |
|
10590 } |
|
10591 else |
|
10592 { |
|
10593 Index: gcc-4.8_branch/libgfortran/generated/minloc1_8_i2.c |
|
10594 =================================================================== |
|
10595 --- gcc-4.8_branch/libgfortran/generated/minloc1_8_i2.c (revision 213312) |
|
10596 +++ gcc-4.8_branch/libgfortran/generated/minloc1_8_i2.c (revision 213313) |
|
10597 @@ -98,10 +98,9 @@ |
|
10598 retarray->offset = 0; |
|
10599 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10600 |
|
10601 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10602 - * extent[rank-1]; |
|
10603 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10604 |
|
10605 - retarray->base_addr = xmalloc (alloc_size); |
|
10606 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
10607 if (alloc_size == 0) |
|
10608 { |
|
10609 /* Make sure we have a zero-sized array. */ |
|
10610 @@ -294,8 +293,7 @@ |
|
10611 |
|
10612 } |
|
10613 |
|
10614 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10615 - * extent[rank-1]; |
|
10616 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10617 |
|
10618 retarray->offset = 0; |
|
10619 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10620 @@ -307,7 +305,7 @@ |
|
10621 return; |
|
10622 } |
|
10623 else |
|
10624 - retarray->base_addr = xmalloc (alloc_size); |
|
10625 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
10626 |
|
10627 } |
|
10628 else |
|
10629 @@ -485,8 +483,7 @@ |
|
10630 retarray->offset = 0; |
|
10631 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10632 |
|
10633 - alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10634 - * extent[rank-1]; |
|
10635 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10636 |
|
10637 if (alloc_size == 0) |
|
10638 { |
|
10639 @@ -495,7 +492,7 @@ |
|
10640 return; |
|
10641 } |
|
10642 else |
|
10643 - retarray->base_addr = xmalloc (alloc_size); |
|
10644 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); |
|
10645 } |
|
10646 else |
|
10647 { |
|
10648 Index: gcc-4.8_branch/libgfortran/generated/minloc0_8_r8.c |
|
10649 =================================================================== |
|
10650 --- gcc-4.8_branch/libgfortran/generated/minloc0_8_r8.c (revision 213312) |
|
10651 +++ gcc-4.8_branch/libgfortran/generated/minloc0_8_r8.c (revision 213313) |
|
10652 @@ -58,7 +58,7 @@ |
|
10653 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
10654 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
10655 retarray->offset = 0; |
|
10656 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
10657 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
10658 } |
|
10659 else |
|
10660 { |
|
10661 @@ -199,7 +199,7 @@ |
|
10662 GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1); |
|
10663 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
10664 retarray->offset = 0; |
|
10665 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
10666 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
10667 } |
|
10668 else |
|
10669 { |
|
10670 @@ -367,7 +367,7 @@ |
|
10671 GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1); |
|
10672 retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1; |
|
10673 retarray->offset = 0; |
|
10674 - retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank); |
|
10675 + retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_8)); |
|
10676 } |
|
10677 else if (unlikely (compile_options.bounds_check)) |
|
10678 { |
|
10679 Index: gcc-4.8_branch/libgfortran/generated/matmul_l8.c |
|
10680 =================================================================== |
|
10681 --- gcc-4.8_branch/libgfortran/generated/matmul_l8.c (revision 213312) |
|
10682 +++ gcc-4.8_branch/libgfortran/generated/matmul_l8.c (revision 213313) |
|
10683 @@ -88,7 +88,7 @@ |
|
10684 } |
|
10685 |
|
10686 retarray->base_addr |
|
10687 - = xmalloc (sizeof (GFC_LOGICAL_8) * size0 ((array_t *) retarray)); |
|
10688 + = xmallocarray (size0 ((array_t *) retarray), sizeof (GFC_LOGICAL_8)); |
|
10689 retarray->offset = 0; |
|
10690 } |
|
10691 else if (unlikely (compile_options.bounds_check)) |
|
10692 Index: gcc-4.8_branch/libgfortran/generated/product_r10.c |
|
10693 =================================================================== |
|
10694 --- gcc-4.8_branch/libgfortran/generated/product_r10.c (revision 213312) |
|
10695 +++ gcc-4.8_branch/libgfortran/generated/product_r10.c (revision 213313) |
|
10696 @@ -97,10 +97,9 @@ |
|
10697 retarray->offset = 0; |
|
10698 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10699 |
|
10700 - alloc_size = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10701 - * extent[rank-1]; |
|
10702 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10703 |
|
10704 - retarray->base_addr = xmalloc (alloc_size); |
|
10705 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_10)); |
|
10706 if (alloc_size == 0) |
|
10707 { |
|
10708 /* Make sure we have a zero-sized array. */ |
|
10709 @@ -272,8 +271,7 @@ |
|
10710 |
|
10711 } |
|
10712 |
|
10713 - alloc_size = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10714 - * extent[rank-1]; |
|
10715 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10716 |
|
10717 retarray->offset = 0; |
|
10718 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10719 @@ -285,7 +283,7 @@ |
|
10720 return; |
|
10721 } |
|
10722 else |
|
10723 - retarray->base_addr = xmalloc (alloc_size); |
|
10724 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_10)); |
|
10725 |
|
10726 } |
|
10727 else |
|
10728 @@ -430,8 +428,7 @@ |
|
10729 retarray->offset = 0; |
|
10730 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10731 |
|
10732 - alloc_size = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10733 - * extent[rank-1]; |
|
10734 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10735 |
|
10736 if (alloc_size == 0) |
|
10737 { |
|
10738 @@ -440,7 +437,7 @@ |
|
10739 return; |
|
10740 } |
|
10741 else |
|
10742 - retarray->base_addr = xmalloc (alloc_size); |
|
10743 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_10)); |
|
10744 } |
|
10745 else |
|
10746 { |
|
10747 Index: gcc-4.8_branch/libgfortran/generated/product_i1.c |
|
10748 =================================================================== |
|
10749 --- gcc-4.8_branch/libgfortran/generated/product_i1.c (revision 213312) |
|
10750 +++ gcc-4.8_branch/libgfortran/generated/product_i1.c (revision 213313) |
|
10751 @@ -97,10 +97,9 @@ |
|
10752 retarray->offset = 0; |
|
10753 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10754 |
|
10755 - alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10756 - * extent[rank-1]; |
|
10757 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10758 |
|
10759 - retarray->base_addr = xmalloc (alloc_size); |
|
10760 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); |
|
10761 if (alloc_size == 0) |
|
10762 { |
|
10763 /* Make sure we have a zero-sized array. */ |
|
10764 @@ -272,8 +271,7 @@ |
|
10765 |
|
10766 } |
|
10767 |
|
10768 - alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10769 - * extent[rank-1]; |
|
10770 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10771 |
|
10772 retarray->offset = 0; |
|
10773 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10774 @@ -285,7 +283,7 @@ |
|
10775 return; |
|
10776 } |
|
10777 else |
|
10778 - retarray->base_addr = xmalloc (alloc_size); |
|
10779 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); |
|
10780 |
|
10781 } |
|
10782 else |
|
10783 @@ -430,8 +428,7 @@ |
|
10784 retarray->offset = 0; |
|
10785 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10786 |
|
10787 - alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10788 - * extent[rank-1]; |
|
10789 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10790 |
|
10791 if (alloc_size == 0) |
|
10792 { |
|
10793 @@ -440,7 +437,7 @@ |
|
10794 return; |
|
10795 } |
|
10796 else |
|
10797 - retarray->base_addr = xmalloc (alloc_size); |
|
10798 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); |
|
10799 } |
|
10800 else |
|
10801 { |
|
10802 Index: gcc-4.8_branch/libgfortran/generated/all_l8.c |
|
10803 =================================================================== |
|
10804 --- gcc-4.8_branch/libgfortran/generated/all_l8.c (revision 213312) |
|
10805 +++ gcc-4.8_branch/libgfortran/generated/all_l8.c (revision 213313) |
|
10806 @@ -101,8 +101,7 @@ |
|
10807 retarray->offset = 0; |
|
10808 retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; |
|
10809 |
|
10810 - alloc_size = sizeof (GFC_LOGICAL_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) |
|
10811 - * extent[rank-1]; |
|
10812 + alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; |
|
10813 |
|
10814 if (alloc_size == 0) |
|
10815 { |
|
10816 @@ -111,7 +110,7 @@ |
|
10817 return; |
|
10818 } |
|
10819 else |
|
10820 - retarray->base_addr = xmalloc (alloc_size); |
|
10821 + retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_LOGICAL_8)); |
|
10822 } |
|
10823 else |
|
10824 { |
|
10825 Index: gcc-4.8_branch/libgfortran/generated/in_pack_r16.c |
|
10826 =================================================================== |
|
10827 --- gcc-4.8_branch/libgfortran/generated/in_pack_r16.c (revision 213312) |
|
10828 +++ gcc-4.8_branch/libgfortran/generated/in_pack_r16.c (revision 213313) |
|
10829 @@ -76,7 +76,7 @@ |
|
10830 return source->base_addr; |
|
10831 |
|
10832 /* Allocate storage for the destination. */ |
|
10833 - destptr = (GFC_REAL_16 *)xmalloc (ssize * sizeof (GFC_REAL_16)); |
|
10834 + destptr = xmallocarray (ssize, sizeof (GFC_REAL_16)); |
|
10835 dest = destptr; |
|
10836 src = source->base_addr; |
|
10837 stride0 = stride[0]; |
|
10838 Index: gcc-4.8_branch/libgfortran/generated/in_pack_i1.c |
|
10839 =================================================================== |
|
10840 --- gcc-4.8_branch/libgfortran/generated/in_pack_i1.c (revision 213312) |
|
10841 +++ gcc-4.8_branch/libgfortran/generated/in_pack_i1.c (revision 213313) |
|
10842 @@ -76,7 +76,7 @@ |
|
10843 return source->base_addr; |
|
10844 |
|
10845 /* Allocate storage for the destination. */ |
|
10846 - destptr = (GFC_INTEGER_1 *)xmalloc (ssize * sizeof (GFC_INTEGER_1)); |
|
10847 + destptr = xmallocarray (ssize, sizeof (GFC_INTEGER_1)); |
|
10848 dest = destptr; |
|
10849 src = source->base_addr; |
|
10850 stride0 = stride[0]; |
|
10851 Index: gcc-4.8_branch/libgfortran/libgfortran.h |
|
10852 =================================================================== |
|
10853 --- gcc-4.8_branch/libgfortran/libgfortran.h (revision 213312) |
|
10854 +++ gcc-4.8_branch/libgfortran/libgfortran.h (revision 213313) |
|
10855 @@ -751,6 +751,9 @@ |
|
10856 extern void *xmalloc (size_t) __attribute__ ((malloc)); |
|
10857 internal_proto(xmalloc); |
|
10858 |
|
10859 +extern void *xmallocarray (size_t, size_t) __attribute__ ((malloc)); |
|
10860 +internal_proto(xmallocarray); |
|
10861 + |
|
10862 extern void *xcalloc (size_t, size_t) __attribute__ ((malloc)); |
|
10863 internal_proto(xcalloc); |
|
10864 |
|
10865 Index: gcc-4.8_branch/libgfortran/io/list_read.c |
|
10866 =================================================================== |
|
10867 --- gcc-4.8_branch/libgfortran/io/list_read.c (revision 213312) |
|
10868 +++ gcc-4.8_branch/libgfortran/io/list_read.c (revision 213313) |
|
10869 @@ -2343,7 +2343,7 @@ |
|
10870 { |
|
10871 index_type len = strlen (nl->var_name) + 1; |
|
10872 int dim; |
|
10873 - char * ext_name = (char*)xmalloc (len + 1); |
|
10874 + char * ext_name = xmalloc (len + 1); |
|
10875 memcpy (ext_name, nl->var_name, len-1); |
|
10876 memcpy (ext_name + len - 1, "%", 2); |
|
10877 for (nl = nl->next; nl; nl = nl->next) |
|
10878 Index: gcc-4.8_branch/libgfortran/io/unit.c |
|
10879 =================================================================== |
|
10880 --- gcc-4.8_branch/libgfortran/io/unit.c (revision 213312) |
|
10881 +++ gcc-4.8_branch/libgfortran/io/unit.c (revision 213313) |
|
10882 @@ -408,7 +408,7 @@ |
|
10883 { |
|
10884 iunit->rank = GFC_DESCRIPTOR_RANK (dtp->internal_unit_desc); |
|
10885 iunit->ls = (array_loop_spec *) |
|
10886 - xmalloc (iunit->rank * sizeof (array_loop_spec)); |
|
10887 + xmallocarray (iunit->rank, sizeof (array_loop_spec)); |
|
10888 dtp->internal_unit_len *= |
|
10889 init_loop_spec (dtp->internal_unit_desc, iunit->ls, &start_record); |
|
10890 |
|
10891 Index: gcc-4.8_branch/libgfortran/io/transfer.c |
|
10892 =================================================================== |
|
10893 --- gcc-4.8_branch/libgfortran/io/transfer.c (revision 213312) |
|
10894 +++ gcc-4.8_branch/libgfortran/io/transfer.c (revision 213313) |
|
10895 @@ -3776,9 +3776,9 @@ |
|
10896 if (nml->var_rank > 0) |
|
10897 { |
|
10898 nml->dim = (descriptor_dimension*) |
|
10899 - xmalloc (nml->var_rank * sizeof (descriptor_dimension)); |
|
10900 + xmallocarray (nml->var_rank, sizeof (descriptor_dimension)); |
|
10901 nml->ls = (array_loop_spec*) |
|
10902 - xmalloc (nml->var_rank * sizeof (array_loop_spec)); |
|
10903 + xmallocarray (nml->var_rank, sizeof (array_loop_spec)); |
|
10904 } |
|
10905 else |
|
10906 { |
|
10907 Index: gcc-4.8_branch/libgfortran/io/write.c |
|
10908 =================================================================== |
|
10909 --- gcc-4.8_branch/libgfortran/io/write.c (revision 213312) |
|
10910 +++ gcc-4.8_branch/libgfortran/io/write.c (revision 213313) |
|
10911 @@ -1863,7 +1863,7 @@ |
|
10912 base_var_name_len = base ? strlen (base->var_name) : 0; |
|
10913 ext_name_len = base_name_len + base_var_name_len |
|
10914 + strlen (obj->var_name) + obj->var_rank * NML_DIGITS + 1; |
|
10915 - ext_name = (char*)xmalloc (ext_name_len); |
|
10916 + ext_name = xmalloc (ext_name_len); |
|
10917 |
|
10918 memcpy (ext_name, base_name, base_name_len); |
|
10919 clen = strlen (obj->var_name + base_var_name_len); |
|
10920 @@ -1892,7 +1892,7 @@ |
|
10921 /* Now obj_name. */ |
|
10922 |
|
10923 obj_name_len = strlen (obj->var_name) + 1; |
|
10924 - obj_name = xmalloc (obj_name_len+1); |
|
10925 + obj_name = xmalloc (obj_name_len + 1); |
|
10926 memcpy (obj_name, obj->var_name, obj_name_len-1); |
|
10927 memcpy (obj_name + obj_name_len-1, "%", 2); |
|
10928 |
|