+2009-08-30 Thomas Koenig <tkoenig@gcc.gnu.org>
+
+ * m4/pack.m4 (pack_'rtype_code`): Use count_0 for counting true
+ values in a logical array. Mark bounds checking tests as
+ unlikely.
+ * intrinsics/pack_generic.c (pack_internal): Likewise.
+ * runtime/bounds.c (count_0): Fix off-by-one error in detecting
+ empty arrays.
+ * generated/pack_c4.c: Regenerated.
+ * generated/pack_c8.c: Regenerated.
+ * generated/pack_c10.c: Regenerated.
+ * generated/pack_c16.c: Regenerated.
+ * generated/pack_i1.c: Regenerated.
+ * generated/pack_i16.c: Regenerated.
+ * generated/pack_i2.c: Regenerated.
+ * generated/pack_i4.c: Regenerated.
+ * generated/pack_i8.c: Regenerated.
+ * generated/pack_r4.c: Regenerated.
+ * generated/pack_r8.c: Regenerated.
+ * generated/pack_r10.c: Regenerated.
+ * generated/pack_r16.c: Regenerated.
+
2009-08-25 Thomas Koenig <tkoenig@gcc.gnu.org>
PR libfortran/34670
else
sptr = array->data;
- if (ret->data == NULL || compile_options.bounds_check)
+ if (ret->data == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
}
}
else
- {
- /* We have to count the true elements in MASK. */
-
- /* TODO: We could speed up pack easily in the case of only
- few .TRUE. entries in MASK, by keeping track of where we
- would be in the source array during the initial traversal
- of MASK, and caching the pointers to those elements. Then,
- supposed the number of elements is small enough, we would
- only have to traverse the list, and copy those elements
- into the result array. In the case of datatypes which fit
- in one of the integer types we could also cache the
- value instead of a pointer to it.
- This approach might be bad from the point of view of
- cache behavior in the case where our cache is not big
- enough to hold all elements that have to be copied. */
-
- const GFC_LOGICAL_1 *m = mptr;
-
- total = 0;
- if (zero_sized)
- m = NULL;
-
- while (m)
- {
- /* Test this element. */
- if (*m)
- total++;
-
- /* Advance to the next element. */
- m += mstride[0];
- count[0]++;
- n = 0;
- while (count[n] == extent[n])
- {
- /* When we get to the end of a dimension, reset it
- and increment the next dimension. */
- count[n] = 0;
- /* We could precalculate this product, but this is a
- less frequently used path so probably not worth
- it. */
- m -= mstride[n] * extent[n];
- n++;
- if (n >= dim)
- {
- /* Break out of the loop. */
- m = NULL;
- break;
- }
- else
- {
- count[n]++;
- m += mstride[n];
- }
- }
- }
- }
+ {
+ /* We have to count the true elements in MASK. */
+ total = count_0 (mask);
+ }
if (ret->data == NULL)
{
else
sptr = array->data;
- if (ret->data == NULL || compile_options.bounds_check)
+ if (ret->data == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
}
}
else
- {
- /* We have to count the true elements in MASK. */
-
- /* TODO: We could speed up pack easily in the case of only
- few .TRUE. entries in MASK, by keeping track of where we
- would be in the source array during the initial traversal
- of MASK, and caching the pointers to those elements. Then,
- supposed the number of elements is small enough, we would
- only have to traverse the list, and copy those elements
- into the result array. In the case of datatypes which fit
- in one of the integer types we could also cache the
- value instead of a pointer to it.
- This approach might be bad from the point of view of
- cache behavior in the case where our cache is not big
- enough to hold all elements that have to be copied. */
-
- const GFC_LOGICAL_1 *m = mptr;
-
- total = 0;
- if (zero_sized)
- m = NULL;
-
- while (m)
- {
- /* Test this element. */
- if (*m)
- total++;
-
- /* Advance to the next element. */
- m += mstride[0];
- count[0]++;
- n = 0;
- while (count[n] == extent[n])
- {
- /* When we get to the end of a dimension, reset it
- and increment the next dimension. */
- count[n] = 0;
- /* We could precalculate this product, but this is a
- less frequently used path so probably not worth
- it. */
- m -= mstride[n] * extent[n];
- n++;
- if (n >= dim)
- {
- /* Break out of the loop. */
- m = NULL;
- break;
- }
- else
- {
- count[n]++;
- m += mstride[n];
- }
- }
- }
- }
+ {
+ /* We have to count the true elements in MASK. */
+ total = count_0 (mask);
+ }
if (ret->data == NULL)
{
else
sptr = array->data;
- if (ret->data == NULL || compile_options.bounds_check)
+ if (ret->data == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
}
}
else
- {
- /* We have to count the true elements in MASK. */
-
- /* TODO: We could speed up pack easily in the case of only
- few .TRUE. entries in MASK, by keeping track of where we
- would be in the source array during the initial traversal
- of MASK, and caching the pointers to those elements. Then,
- supposed the number of elements is small enough, we would
- only have to traverse the list, and copy those elements
- into the result array. In the case of datatypes which fit
- in one of the integer types we could also cache the
- value instead of a pointer to it.
- This approach might be bad from the point of view of
- cache behavior in the case where our cache is not big
- enough to hold all elements that have to be copied. */
-
- const GFC_LOGICAL_1 *m = mptr;
-
- total = 0;
- if (zero_sized)
- m = NULL;
-
- while (m)
- {
- /* Test this element. */
- if (*m)
- total++;
-
- /* Advance to the next element. */
- m += mstride[0];
- count[0]++;
- n = 0;
- while (count[n] == extent[n])
- {
- /* When we get to the end of a dimension, reset it
- and increment the next dimension. */
- count[n] = 0;
- /* We could precalculate this product, but this is a
- less frequently used path so probably not worth
- it. */
- m -= mstride[n] * extent[n];
- n++;
- if (n >= dim)
- {
- /* Break out of the loop. */
- m = NULL;
- break;
- }
- else
- {
- count[n]++;
- m += mstride[n];
- }
- }
- }
- }
+ {
+ /* We have to count the true elements in MASK. */
+ total = count_0 (mask);
+ }
if (ret->data == NULL)
{
else
sptr = array->data;
- if (ret->data == NULL || compile_options.bounds_check)
+ if (ret->data == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
}
}
else
- {
- /* We have to count the true elements in MASK. */
-
- /* TODO: We could speed up pack easily in the case of only
- few .TRUE. entries in MASK, by keeping track of where we
- would be in the source array during the initial traversal
- of MASK, and caching the pointers to those elements. Then,
- supposed the number of elements is small enough, we would
- only have to traverse the list, and copy those elements
- into the result array. In the case of datatypes which fit
- in one of the integer types we could also cache the
- value instead of a pointer to it.
- This approach might be bad from the point of view of
- cache behavior in the case where our cache is not big
- enough to hold all elements that have to be copied. */
-
- const GFC_LOGICAL_1 *m = mptr;
-
- total = 0;
- if (zero_sized)
- m = NULL;
-
- while (m)
- {
- /* Test this element. */
- if (*m)
- total++;
-
- /* Advance to the next element. */
- m += mstride[0];
- count[0]++;
- n = 0;
- while (count[n] == extent[n])
- {
- /* When we get to the end of a dimension, reset it
- and increment the next dimension. */
- count[n] = 0;
- /* We could precalculate this product, but this is a
- less frequently used path so probably not worth
- it. */
- m -= mstride[n] * extent[n];
- n++;
- if (n >= dim)
- {
- /* Break out of the loop. */
- m = NULL;
- break;
- }
- else
- {
- count[n]++;
- m += mstride[n];
- }
- }
- }
- }
+ {
+ /* We have to count the true elements in MASK. */
+ total = count_0 (mask);
+ }
if (ret->data == NULL)
{
else
sptr = array->data;
- if (ret->data == NULL || compile_options.bounds_check)
+ if (ret->data == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
}
}
else
- {
- /* We have to count the true elements in MASK. */
-
- /* TODO: We could speed up pack easily in the case of only
- few .TRUE. entries in MASK, by keeping track of where we
- would be in the source array during the initial traversal
- of MASK, and caching the pointers to those elements. Then,
- supposed the number of elements is small enough, we would
- only have to traverse the list, and copy those elements
- into the result array. In the case of datatypes which fit
- in one of the integer types we could also cache the
- value instead of a pointer to it.
- This approach might be bad from the point of view of
- cache behavior in the case where our cache is not big
- enough to hold all elements that have to be copied. */
-
- const GFC_LOGICAL_1 *m = mptr;
-
- total = 0;
- if (zero_sized)
- m = NULL;
-
- while (m)
- {
- /* Test this element. */
- if (*m)
- total++;
-
- /* Advance to the next element. */
- m += mstride[0];
- count[0]++;
- n = 0;
- while (count[n] == extent[n])
- {
- /* When we get to the end of a dimension, reset it
- and increment the next dimension. */
- count[n] = 0;
- /* We could precalculate this product, but this is a
- less frequently used path so probably not worth
- it. */
- m -= mstride[n] * extent[n];
- n++;
- if (n >= dim)
- {
- /* Break out of the loop. */
- m = NULL;
- break;
- }
- else
- {
- count[n]++;
- m += mstride[n];
- }
- }
- }
- }
+ {
+ /* We have to count the true elements in MASK. */
+ total = count_0 (mask);
+ }
if (ret->data == NULL)
{
else
sptr = array->data;
- if (ret->data == NULL || compile_options.bounds_check)
+ if (ret->data == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
}
}
else
- {
- /* We have to count the true elements in MASK. */
-
- /* TODO: We could speed up pack easily in the case of only
- few .TRUE. entries in MASK, by keeping track of where we
- would be in the source array during the initial traversal
- of MASK, and caching the pointers to those elements. Then,
- supposed the number of elements is small enough, we would
- only have to traverse the list, and copy those elements
- into the result array. In the case of datatypes which fit
- in one of the integer types we could also cache the
- value instead of a pointer to it.
- This approach might be bad from the point of view of
- cache behavior in the case where our cache is not big
- enough to hold all elements that have to be copied. */
-
- const GFC_LOGICAL_1 *m = mptr;
-
- total = 0;
- if (zero_sized)
- m = NULL;
-
- while (m)
- {
- /* Test this element. */
- if (*m)
- total++;
-
- /* Advance to the next element. */
- m += mstride[0];
- count[0]++;
- n = 0;
- while (count[n] == extent[n])
- {
- /* When we get to the end of a dimension, reset it
- and increment the next dimension. */
- count[n] = 0;
- /* We could precalculate this product, but this is a
- less frequently used path so probably not worth
- it. */
- m -= mstride[n] * extent[n];
- n++;
- if (n >= dim)
- {
- /* Break out of the loop. */
- m = NULL;
- break;
- }
- else
- {
- count[n]++;
- m += mstride[n];
- }
- }
- }
- }
+ {
+ /* We have to count the true elements in MASK. */
+ total = count_0 (mask);
+ }
if (ret->data == NULL)
{
else
sptr = array->data;
- if (ret->data == NULL || compile_options.bounds_check)
+ if (ret->data == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
}
}
else
- {
- /* We have to count the true elements in MASK. */
-
- /* TODO: We could speed up pack easily in the case of only
- few .TRUE. entries in MASK, by keeping track of where we
- would be in the source array during the initial traversal
- of MASK, and caching the pointers to those elements. Then,
- supposed the number of elements is small enough, we would
- only have to traverse the list, and copy those elements
- into the result array. In the case of datatypes which fit
- in one of the integer types we could also cache the
- value instead of a pointer to it.
- This approach might be bad from the point of view of
- cache behavior in the case where our cache is not big
- enough to hold all elements that have to be copied. */
-
- const GFC_LOGICAL_1 *m = mptr;
-
- total = 0;
- if (zero_sized)
- m = NULL;
-
- while (m)
- {
- /* Test this element. */
- if (*m)
- total++;
-
- /* Advance to the next element. */
- m += mstride[0];
- count[0]++;
- n = 0;
- while (count[n] == extent[n])
- {
- /* When we get to the end of a dimension, reset it
- and increment the next dimension. */
- count[n] = 0;
- /* We could precalculate this product, but this is a
- less frequently used path so probably not worth
- it. */
- m -= mstride[n] * extent[n];
- n++;
- if (n >= dim)
- {
- /* Break out of the loop. */
- m = NULL;
- break;
- }
- else
- {
- count[n]++;
- m += mstride[n];
- }
- }
- }
- }
+ {
+ /* We have to count the true elements in MASK. */
+ total = count_0 (mask);
+ }
if (ret->data == NULL)
{
else
sptr = array->data;
- if (ret->data == NULL || compile_options.bounds_check)
+ if (ret->data == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
}
}
else
- {
- /* We have to count the true elements in MASK. */
-
- /* TODO: We could speed up pack easily in the case of only
- few .TRUE. entries in MASK, by keeping track of where we
- would be in the source array during the initial traversal
- of MASK, and caching the pointers to those elements. Then,
- supposed the number of elements is small enough, we would
- only have to traverse the list, and copy those elements
- into the result array. In the case of datatypes which fit
- in one of the integer types we could also cache the
- value instead of a pointer to it.
- This approach might be bad from the point of view of
- cache behavior in the case where our cache is not big
- enough to hold all elements that have to be copied. */
-
- const GFC_LOGICAL_1 *m = mptr;
-
- total = 0;
- if (zero_sized)
- m = NULL;
-
- while (m)
- {
- /* Test this element. */
- if (*m)
- total++;
-
- /* Advance to the next element. */
- m += mstride[0];
- count[0]++;
- n = 0;
- while (count[n] == extent[n])
- {
- /* When we get to the end of a dimension, reset it
- and increment the next dimension. */
- count[n] = 0;
- /* We could precalculate this product, but this is a
- less frequently used path so probably not worth
- it. */
- m -= mstride[n] * extent[n];
- n++;
- if (n >= dim)
- {
- /* Break out of the loop. */
- m = NULL;
- break;
- }
- else
- {
- count[n]++;
- m += mstride[n];
- }
- }
- }
- }
+ {
+ /* We have to count the true elements in MASK. */
+ total = count_0 (mask);
+ }
if (ret->data == NULL)
{
else
sptr = array->data;
- if (ret->data == NULL || compile_options.bounds_check)
+ if (ret->data == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
}
}
else
- {
- /* We have to count the true elements in MASK. */
-
- /* TODO: We could speed up pack easily in the case of only
- few .TRUE. entries in MASK, by keeping track of where we
- would be in the source array during the initial traversal
- of MASK, and caching the pointers to those elements. Then,
- supposed the number of elements is small enough, we would
- only have to traverse the list, and copy those elements
- into the result array. In the case of datatypes which fit
- in one of the integer types we could also cache the
- value instead of a pointer to it.
- This approach might be bad from the point of view of
- cache behavior in the case where our cache is not big
- enough to hold all elements that have to be copied. */
-
- const GFC_LOGICAL_1 *m = mptr;
-
- total = 0;
- if (zero_sized)
- m = NULL;
-
- while (m)
- {
- /* Test this element. */
- if (*m)
- total++;
-
- /* Advance to the next element. */
- m += mstride[0];
- count[0]++;
- n = 0;
- while (count[n] == extent[n])
- {
- /* When we get to the end of a dimension, reset it
- and increment the next dimension. */
- count[n] = 0;
- /* We could precalculate this product, but this is a
- less frequently used path so probably not worth
- it. */
- m -= mstride[n] * extent[n];
- n++;
- if (n >= dim)
- {
- /* Break out of the loop. */
- m = NULL;
- break;
- }
- else
- {
- count[n]++;
- m += mstride[n];
- }
- }
- }
- }
+ {
+ /* We have to count the true elements in MASK. */
+ total = count_0 (mask);
+ }
if (ret->data == NULL)
{
else
sptr = array->data;
- if (ret->data == NULL || compile_options.bounds_check)
+ if (ret->data == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
}
}
else
- {
- /* We have to count the true elements in MASK. */
-
- /* TODO: We could speed up pack easily in the case of only
- few .TRUE. entries in MASK, by keeping track of where we
- would be in the source array during the initial traversal
- of MASK, and caching the pointers to those elements. Then,
- supposed the number of elements is small enough, we would
- only have to traverse the list, and copy those elements
- into the result array. In the case of datatypes which fit
- in one of the integer types we could also cache the
- value instead of a pointer to it.
- This approach might be bad from the point of view of
- cache behavior in the case where our cache is not big
- enough to hold all elements that have to be copied. */
-
- const GFC_LOGICAL_1 *m = mptr;
-
- total = 0;
- if (zero_sized)
- m = NULL;
-
- while (m)
- {
- /* Test this element. */
- if (*m)
- total++;
-
- /* Advance to the next element. */
- m += mstride[0];
- count[0]++;
- n = 0;
- while (count[n] == extent[n])
- {
- /* When we get to the end of a dimension, reset it
- and increment the next dimension. */
- count[n] = 0;
- /* We could precalculate this product, but this is a
- less frequently used path so probably not worth
- it. */
- m -= mstride[n] * extent[n];
- n++;
- if (n >= dim)
- {
- /* Break out of the loop. */
- m = NULL;
- break;
- }
- else
- {
- count[n]++;
- m += mstride[n];
- }
- }
- }
- }
+ {
+ /* We have to count the true elements in MASK. */
+ total = count_0 (mask);
+ }
if (ret->data == NULL)
{
else
sptr = array->data;
- if (ret->data == NULL || compile_options.bounds_check)
+ if (ret->data == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
}
}
else
- {
- /* We have to count the true elements in MASK. */
-
- /* TODO: We could speed up pack easily in the case of only
- few .TRUE. entries in MASK, by keeping track of where we
- would be in the source array during the initial traversal
- of MASK, and caching the pointers to those elements. Then,
- supposed the number of elements is small enough, we would
- only have to traverse the list, and copy those elements
- into the result array. In the case of datatypes which fit
- in one of the integer types we could also cache the
- value instead of a pointer to it.
- This approach might be bad from the point of view of
- cache behavior in the case where our cache is not big
- enough to hold all elements that have to be copied. */
-
- const GFC_LOGICAL_1 *m = mptr;
-
- total = 0;
- if (zero_sized)
- m = NULL;
-
- while (m)
- {
- /* Test this element. */
- if (*m)
- total++;
-
- /* Advance to the next element. */
- m += mstride[0];
- count[0]++;
- n = 0;
- while (count[n] == extent[n])
- {
- /* When we get to the end of a dimension, reset it
- and increment the next dimension. */
- count[n] = 0;
- /* We could precalculate this product, but this is a
- less frequently used path so probably not worth
- it. */
- m -= mstride[n] * extent[n];
- n++;
- if (n >= dim)
- {
- /* Break out of the loop. */
- m = NULL;
- break;
- }
- else
- {
- count[n]++;
- m += mstride[n];
- }
- }
- }
- }
+ {
+ /* We have to count the true elements in MASK. */
+ total = count_0 (mask);
+ }
if (ret->data == NULL)
{
else
sptr = array->data;
- if (ret->data == NULL || compile_options.bounds_check)
+ if (ret->data == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
}
}
else
- {
- /* We have to count the true elements in MASK. */
-
- /* TODO: We could speed up pack easily in the case of only
- few .TRUE. entries in MASK, by keeping track of where we
- would be in the source array during the initial traversal
- of MASK, and caching the pointers to those elements. Then,
- supposed the number of elements is small enough, we would
- only have to traverse the list, and copy those elements
- into the result array. In the case of datatypes which fit
- in one of the integer types we could also cache the
- value instead of a pointer to it.
- This approach might be bad from the point of view of
- cache behavior in the case where our cache is not big
- enough to hold all elements that have to be copied. */
-
- const GFC_LOGICAL_1 *m = mptr;
-
- total = 0;
- if (zero_sized)
- m = NULL;
-
- while (m)
- {
- /* Test this element. */
- if (*m)
- total++;
-
- /* Advance to the next element. */
- m += mstride[0];
- count[0]++;
- n = 0;
- while (count[n] == extent[n])
- {
- /* When we get to the end of a dimension, reset it
- and increment the next dimension. */
- count[n] = 0;
- /* We could precalculate this product, but this is a
- less frequently used path so probably not worth
- it. */
- m -= mstride[n] * extent[n];
- n++;
- if (n >= dim)
- {
- /* Break out of the loop. */
- m = NULL;
- break;
- }
- else
- {
- count[n]++;
- m += mstride[n];
- }
- }
- }
- }
+ {
+ /* We have to count the true elements in MASK. */
+ total = count_0 (mask);
+ }
if (ret->data == NULL)
{
else
sptr = array->data;
- if (ret->data == NULL || compile_options.bounds_check)
+ if (ret->data == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
}
}
else
- {
- /* We have to count the true elements in MASK. */
-
- /* TODO: We could speed up pack easily in the case of only
- few .TRUE. entries in MASK, by keeping track of where we
- would be in the source array during the initial traversal
- of MASK, and caching the pointers to those elements. Then,
- supposed the number of elements is small enough, we would
- only have to traverse the list, and copy those elements
- into the result array. In the case of datatypes which fit
- in one of the integer types we could also cache the
- value instead of a pointer to it.
- This approach might be bad from the point of view of
- cache behavior in the case where our cache is not big
- enough to hold all elements that have to be copied. */
-
- const GFC_LOGICAL_1 *m = mptr;
-
- total = 0;
- if (zero_sized)
- m = NULL;
-
- while (m)
- {
- /* Test this element. */
- if (*m)
- total++;
-
- /* Advance to the next element. */
- m += mstride[0];
- count[0]++;
- n = 0;
- while (count[n] == extent[n])
- {
- /* When we get to the end of a dimension, reset it
- and increment the next dimension. */
- count[n] = 0;
- /* We could precalculate this product, but this is a
- less frequently used path so probably not worth
- it. */
- m -= mstride[n] * extent[n];
- n++;
- if (n >= dim)
- {
- /* Break out of the loop. */
- m = NULL;
- break;
- }
- else
- {
- count[n]++;
- m += mstride[n];
- }
- }
- }
- }
+ {
+ /* We have to count the true elements in MASK. */
+ total = count_0 (mask);
+ }
if (ret->data == NULL)
{
if (mstride[0] == 0)
mstride[0] = mask_kind;
- if (ret->data == NULL || compile_options.bounds_check)
+ if (ret->data == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
{
/* We have to count the true elements in MASK. */
- /* TODO: We could speed up pack easily in the case of only
- few .TRUE. entries in MASK, by keeping track of where we
- would be in the source array during the initial traversal
- of MASK, and caching the pointers to those elements. Then,
- supposed the number of elements is small enough, we would
- only have to traverse the list, and copy those elements
- into the result array. In the case of datatypes which fit
- in one of the integer types we could also cache the
- value instead of a pointer to it.
- This approach might be bad from the point of view of
- cache behavior in the case where our cache is not big
- enough to hold all elements that have to be copied. */
-
- const GFC_LOGICAL_1 *m = mptr;
-
- total = 0;
- if (zero_sized)
- m = NULL;
-
- while (m)
- {
- /* Test this element. */
- if (*m)
- total++;
-
- /* Advance to the next element. */
- m += mstride[0];
- count[0]++;
- n = 0;
- while (count[n] == extent[n])
- {
- /* When we get to the end of a dimension, reset it
- and increment the next dimension. */
- count[n] = 0;
- /* We could precalculate this product, but this is a
- less frequently used path so probably not worth
- it. */
- m -= mstride[n] * extent[n];
- n++;
- if (n >= dim)
- {
- /* Break out of the loop. */
- m = NULL;
- break;
- }
- else
- {
- count[n]++;
- m += mstride[n];
- }
- }
- }
+ total = count_0 (mask);
}
if (ret->data == NULL)
else
sptr = array->data;
- if (ret->data == NULL || compile_options.bounds_check)
+ if (ret->data == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
}
}
else
- {
- /* We have to count the true elements in MASK. */
-
- /* TODO: We could speed up pack easily in the case of only
- few .TRUE. entries in MASK, by keeping track of where we
- would be in the source array during the initial traversal
- of MASK, and caching the pointers to those elements. Then,
- supposed the number of elements is small enough, we would
- only have to traverse the list, and copy those elements
- into the result array. In the case of datatypes which fit
- in one of the integer types we could also cache the
- value instead of a pointer to it.
- This approach might be bad from the point of view of
- cache behavior in the case where our cache is not big
- enough to hold all elements that have to be copied. */
-
- const GFC_LOGICAL_1 *m = mptr;
-
- total = 0;
- if (zero_sized)
- m = NULL;
-
- while (m)
- {
- /* Test this element. */
- if (*m)
- total++;
-
- /* Advance to the next element. */
- m += mstride[0];
- count[0]++;
- n = 0;
- while (count[n] == extent[n])
- {
- /* When we get to the end of a dimension, reset it
- and increment the next dimension. */
- count[n] = 0;
- /* We could precalculate this product, but this is a
- less frequently used path so probably not worth
- it. */
- m -= mstride[n] * extent[n];
- n++;
- if (n >= dim)
- {
- /* Break out of the loop. */
- m = NULL;
- break;
- }
- else
- {
- count[n]++;
- m += mstride[n];
- }
- }
- }
- }
+ {
+ /* We have to count the true elements in MASK. */
+ total = count_0 (mask);
+ }
if (ret->data == NULL)
{
extent[n] = GFC_DESCRIPTOR_EXTENT(array,n);
count[n] = 0;
- if (extent[n] < 0)
+ if (extent[n] <= 0)
return 0;
}
OSDN Git Service
