429 lines
14 KiB
C
429 lines
14 KiB
C
/* PR tree-optimization/83671 - fix for false positive reported by
|
|
-Wstringop-overflow does not work with inlining
|
|
{ dg-do compile }
|
|
{ dg-options "-O1 -fdump-tree-optimized" } */
|
|
|
|
#include "strlenopt.h"
|
|
|
|
#define DIFF_MAX __PTRDIFF_MAX__
|
|
|
|
#define CAT(x, y) x ## y
|
|
#define CONCAT(x, y) CAT (x, y)
|
|
#define FAILNAME(name) CONCAT (call_ ## name ##_on_line_, __LINE__)
|
|
|
|
#define FAIL(name) do { \
|
|
extern void FAILNAME (name) (void); \
|
|
FAILNAME (name)(); \
|
|
} while (0)
|
|
|
|
/* Macros to emit a call to funcation named
|
|
call_in_{true,false}_branch_not_eliminated_on_line_NNN()
|
|
for each call that's expected to be eliminated. The dg-final
|
|
scan-tree-dump-time directive at the bottom of the test verifies
|
|
that no such call appears in output. */
|
|
#define ELIM_TRUE(expr) \
|
|
if (!(expr)) FAIL (in_true_branch_not_eliminated); else (void)0
|
|
|
|
#define ELIM_FALSE(expr) \
|
|
if (!!(expr)) FAIL (in_false_branch_not_eliminated); else (void)0
|
|
|
|
/* Macro to emit a call to a function named
|
|
call_made_in_{true,false}_branch_on_line_NNN()
|
|
for each call that's expected to be retained. The dg-final
|
|
scan-tree-dump-time directive at the bottom of the test verifies
|
|
that the expected number of both kinds of calls appears in output
|
|
(a pair for each line with the invocation of the KEEP() macro. */
|
|
#define KEEP(expr) \
|
|
if (expr) \
|
|
FAIL (made_in_true_branch); \
|
|
else \
|
|
FAIL (made_in_false_branch)
|
|
|
|
typedef char A3[3], A5[5], A7[7], AX[];
|
|
|
|
typedef A3 A7_3[7];
|
|
typedef A3 AX_3[];
|
|
typedef A5 A7_5[7];
|
|
typedef A7 A5_7[5];
|
|
|
|
extern A7_3 a7_3;
|
|
extern A5_7 a5_7;
|
|
extern AX_3 ax_3;
|
|
|
|
extern A3 a3;
|
|
extern A7 a5;
|
|
extern A7 a7;
|
|
extern AX ax;
|
|
|
|
extern A3 *pa3;
|
|
extern A5 *pa5;
|
|
extern A7 *pa7;
|
|
|
|
extern A7_3 *pa7_3;
|
|
extern AX_3 *pax_3;
|
|
extern A5_7 *pa5_7;
|
|
extern A7_5 *pa7_5;
|
|
|
|
extern char *ptr;
|
|
|
|
struct MemArrays0 {
|
|
A7_3 a7_3;
|
|
A5_7 a5_7;
|
|
char a3[3], a5[5], a0[0];
|
|
};
|
|
struct MemArraysX { char a3[3], a5[5], ax[]; };
|
|
struct MemArrays7 { char a3[3], a5[5], a7[7]; };
|
|
|
|
struct MemArrays0 ma0_3_5_7[3][5][7];
|
|
|
|
void elim_strings (int i)
|
|
{
|
|
ELIM_TRUE (strlen (i < 0 ? "123" : "321") == 3);
|
|
ELIM_FALSE (strlen (i < 0 ? "123" : "321") > 3);
|
|
ELIM_FALSE (strlen (i < 0 ? "123" : "321") < 3);
|
|
|
|
ELIM_TRUE (strlen (i < 0 ? "123" : "4321") >= 3);
|
|
ELIM_FALSE (strlen (i < 0 ? "123" : "4321") > 4);
|
|
ELIM_FALSE (strlen (i < 0 ? "123" : "4321") < 3);
|
|
|
|
ELIM_TRUE (strlen (i < 0 ? "1234" : "321") >= 3);
|
|
ELIM_FALSE (strlen (i < 0 ? "1234" : "321") < 3);
|
|
ELIM_FALSE (strlen (i < 0 ? "1234" : "321") > 4);
|
|
|
|
ELIM_TRUE (strlen (i < 0 ? "123" : "4321") <= 4);
|
|
ELIM_TRUE (strlen (i < 0 ? "1234" : "321") <= 4);
|
|
|
|
ELIM_TRUE (strlen (i < 0 ? "1" : "123456789") <= 9);
|
|
ELIM_TRUE (strlen (i < 0 ? "1" : "123456789") >= 1);
|
|
}
|
|
|
|
/* Verify that strlen calls involving uninitialized global arrays
|
|
of known size are eliminated when they appear in expressions
|
|
that test for results that must be true. */
|
|
void elim_global_arrays (int i)
|
|
{
|
|
/* Verify that the expression involving the strlen call as well
|
|
as whatever depends on it is eliminated from the test output.
|
|
All these expressions must be trivially true. */
|
|
ELIM_TRUE (strlen (a7_3[0]) < sizeof a7_3);
|
|
ELIM_TRUE (strlen (a7_3[1]) < sizeof a7_3 - sizeof *a7_3);
|
|
ELIM_TRUE (strlen (a7_3[6]) < sizeof a7_3 - 5 * sizeof *a7_3);
|
|
ELIM_TRUE (strlen (a7_3[i]) < sizeof a7_3);
|
|
|
|
ELIM_TRUE (strlen (a5_7[0]) < sizeof a5_7);
|
|
ELIM_TRUE (strlen (a5_7[1]) < sizeof a5_7 - sizeof *a5_7);
|
|
ELIM_TRUE (strlen (a5_7[4]) < sizeof a5_7 - 3 * sizeof *a5_7);
|
|
ELIM_TRUE (strlen (a5_7[i]) < sizeof a5_7);
|
|
|
|
/* Even when treating a multi-dimensional array as a single string
|
|
the length must be less DIFF_MAX - (ax_3[i] - ax_3[0]) but GCC
|
|
doesn't do that computation yet so avoid testing it. */
|
|
ELIM_TRUE (strlen (ax_3[0]) < DIFF_MAX);
|
|
ELIM_TRUE (strlen (ax_3[1]) < DIFF_MAX);
|
|
ELIM_TRUE (strlen (ax_3[9]) < DIFF_MAX);
|
|
ELIM_TRUE (strlen (ax_3[i]) < DIFF_MAX);
|
|
|
|
ELIM_TRUE (strlen (a3) < sizeof a3);
|
|
ELIM_TRUE (strlen (a7) < sizeof a7);
|
|
|
|
ELIM_TRUE (strlen (ax) != DIFF_MAX);
|
|
/* ELIM_TRUE (strlen (ax) != DIFF_MAX - 1); */
|
|
/* ELIM_TRUE (strlen (ax) < DIFF_MAX - 1); */
|
|
}
|
|
|
|
void elim_pointer_to_arrays (void)
|
|
{
|
|
/* Unfortunately, GCC cannot be trusted not to misuse a pointer
|
|
to a smaller array to point to an object of a bigger type so
|
|
the strlen range optimization must assume each array pointer
|
|
points effectively to an array of an unknown bound. */
|
|
ELIM_TRUE (strlen (*pa7) < DIFF_MAX);
|
|
ELIM_TRUE (strlen (*pa5) < DIFF_MAX);
|
|
ELIM_TRUE (strlen (*pa3) < DIFF_MAX);
|
|
|
|
ELIM_TRUE (strlen ((*pa7_3)[0]) < DIFF_MAX);
|
|
ELIM_TRUE (strlen ((*pa7_3)[1]) < DIFF_MAX);
|
|
ELIM_TRUE (strlen ((*pa7_3)[6]) < DIFF_MAX);
|
|
|
|
ELIM_TRUE (strlen ((*pax_3)[0]) < DIFF_MAX);
|
|
ELIM_TRUE (strlen ((*pax_3)[1]) < DIFF_MAX);
|
|
ELIM_TRUE (strlen ((*pax_3)[9]) < DIFF_MAX);
|
|
|
|
ELIM_TRUE (strlen ((*pa5_7)[0]) < DIFF_MAX);
|
|
ELIM_TRUE (strlen ((*pa5_7)[1]) < DIFF_MAX);
|
|
ELIM_TRUE (strlen ((*pa5_7)[4]) < DIFF_MAX);
|
|
}
|
|
|
|
void elim_global_arrays_and_strings (int i)
|
|
{
|
|
ELIM_TRUE (strlen (i < 0 ? a3 : "") < 3);
|
|
ELIM_TRUE (strlen (i < 0 ? a3 : "1") < 3);
|
|
ELIM_TRUE (strlen (i < 0 ? a3 : "12") < 3);
|
|
ELIM_TRUE (strlen (i < 0 ? a3 : "123") < 4);
|
|
|
|
ELIM_FALSE (strlen (i < 0 ? a3 : "") > 3);
|
|
ELIM_FALSE (strlen (i < 0 ? a3 : "1") > 3);
|
|
ELIM_FALSE (strlen (i < 0 ? a3 : "12") > 3);
|
|
ELIM_FALSE (strlen (i < 0 ? a3 : "123") > 4);
|
|
|
|
ELIM_TRUE (strlen (i < 0 ? a7 : "") < 7);
|
|
ELIM_TRUE (strlen (i < 0 ? a7 : "1") < 7);
|
|
ELIM_TRUE (strlen (i < 0 ? a7 : "12") < 7);
|
|
ELIM_TRUE (strlen (i < 0 ? a7 : "123") < 7);
|
|
ELIM_TRUE (strlen (i < 0 ? a7 : "123456") < 7);
|
|
ELIM_TRUE (strlen (i < 0 ? a7 : "1234567") < 8);
|
|
|
|
ELIM_FALSE (strlen (i < 0 ? a7 : "") > 6);
|
|
ELIM_FALSE (strlen (i < 0 ? a7 : "1") > 6);
|
|
ELIM_FALSE (strlen (i < 0 ? a7 : "12") > 6);
|
|
ELIM_FALSE (strlen (i < 0 ? a7 : "123") > 6);
|
|
ELIM_FALSE (strlen (i < 0 ? a7 : "123456") > 7);
|
|
ELIM_FALSE (strlen (i < 0 ? a7 : "1234567") > 8);
|
|
}
|
|
|
|
void elim_member_arrays_obj (int i)
|
|
{
|
|
ELIM_TRUE (strlen (ma0_3_5_7[0][0][0].a3) < sizeof ma0_3_5_7);
|
|
ELIM_TRUE (strlen (ma0_3_5_7[0][0][1].a3) < sizeof ma0_3_5_7);
|
|
ELIM_TRUE (strlen (ma0_3_5_7[0][0][2].a3) < sizeof ma0_3_5_7);
|
|
ELIM_TRUE (strlen (ma0_3_5_7[0][0][6].a3) < sizeof ma0_3_5_7);
|
|
|
|
ELIM_TRUE (strlen (ma0_3_5_7[1][0][0].a3) < sizeof ma0_3_5_7);
|
|
ELIM_TRUE (strlen (ma0_3_5_7[2][0][1].a3) < sizeof ma0_3_5_7);
|
|
|
|
ELIM_TRUE (strlen (ma0_3_5_7[1][1][0].a3) < sizeof ma0_3_5_7);
|
|
ELIM_TRUE (strlen (ma0_3_5_7[2][4][6].a3) < sizeof ma0_3_5_7);
|
|
|
|
ELIM_TRUE (strlen (ma0_3_5_7[0][0][0].a5) < sizeof ma0_3_5_7);
|
|
ELIM_TRUE (strlen (ma0_3_5_7[0][0][1].a5) < sizeof ma0_3_5_7);
|
|
ELIM_TRUE (strlen (ma0_3_5_7[0][0][2].a5) < sizeof ma0_3_5_7);
|
|
ELIM_TRUE (strlen (ma0_3_5_7[0][0][6].a5) < sizeof ma0_3_5_7);
|
|
|
|
ELIM_TRUE (strlen (ma0_3_5_7[1][0][0].a5) < sizeof ma0_3_5_7);
|
|
ELIM_TRUE (strlen (ma0_3_5_7[2][0][1].a5) < sizeof ma0_3_5_7);
|
|
|
|
ELIM_TRUE (strlen (ma0_3_5_7[1][1][0].a5) < sizeof ma0_3_5_7);
|
|
ELIM_TRUE (strlen (ma0_3_5_7[2][4][6].a5) < sizeof ma0_3_5_7);
|
|
|
|
ELIM_TRUE (strlen (ma0_3_5_7[0][0][0].a7_3[0]) < sizeof ma0_3_5_7);
|
|
ELIM_TRUE (strlen (ma0_3_5_7[2][4][6].a7_3[2]) < sizeof ma0_3_5_7);
|
|
|
|
ELIM_TRUE (strlen (ma0_3_5_7[0][0][0].a5_7[0]) < sizeof ma0_3_5_7);
|
|
ELIM_TRUE (strlen (ma0_3_5_7[2][4][6].a5_7[4]) < sizeof ma0_3_5_7);
|
|
}
|
|
|
|
|
|
#line 1000
|
|
|
|
/* Verify that strlen calls involving uninitialized global arrays
|
|
of unknown size are not eliminated when they appear in expressions
|
|
that test for results that need not be true. */
|
|
void keep_global_arrays (int i)
|
|
{
|
|
KEEP (strlen (a7_3[0]) < 2);
|
|
KEEP (strlen (a7_3[1]) < 2);
|
|
KEEP (strlen (a7_3[6]) < 2);
|
|
KEEP (strlen (a7_3[i]) < 2);
|
|
|
|
KEEP (strlen (a5_7[0]) < 6);
|
|
KEEP (strlen (a5_7[1]) < 6);
|
|
KEEP (strlen (a5_7[4]) < 6);
|
|
KEEP (strlen (a5_7[i]) < 6);
|
|
|
|
/* Verify also that tests (and strlen calls) are not eliminated
|
|
for results greater than what would the size of the innermost
|
|
array suggest might be possible (in case the element array is
|
|
not nul-terminated), even though such calls are undefined. */
|
|
KEEP (strlen (a5_7[0]) > sizeof a5_7 - 2);
|
|
KEEP (strlen (a5_7[1]) > sizeof a5_7 - sizeof a5_7[1] - 2);
|
|
KEEP (strlen (a5_7[i]) > sizeof a5_7 - 2);
|
|
|
|
KEEP (strlen (ax_3[0]) < 2);
|
|
KEEP (strlen (ax_3[1]) < 2);
|
|
KEEP (strlen (ax_3[2]) < 2);
|
|
KEEP (strlen (ax_3[i]) < 2);
|
|
|
|
/* Here again, verify that the ax_3 matrix is treated essentially
|
|
as a flat array of unknown bound for the benefit of all the
|
|
undefined code out there that might rely on it. */
|
|
KEEP (strlen (ax_3[0]) > 3);
|
|
KEEP (strlen (ax_3[1]) > 9);
|
|
KEEP (strlen (ax_3[2]) > 99);
|
|
KEEP (strlen (ax_3[i]) > 999);
|
|
|
|
KEEP (strlen (a3) < 2);
|
|
KEEP (strlen (a7) < 6);
|
|
|
|
KEEP (strlen (a3 + i) < 2);
|
|
KEEP (strlen (a7 + i) < 2);
|
|
|
|
/* The length of an array of unknown size may be as large as
|
|
DIFF_MAX - 2. */
|
|
KEEP (strlen (ax) != DIFF_MAX - 2);
|
|
KEEP (strlen (ax) < DIFF_MAX - 2);
|
|
KEEP (strlen (ax) < 999);
|
|
KEEP (strlen (ax) < 1);
|
|
}
|
|
|
|
void keep_pointer_to_arrays (int i)
|
|
{
|
|
KEEP (strlen (*pa7) < 6);
|
|
KEEP (strlen (*pa5) < 4);
|
|
KEEP (strlen (*pa3) < 2);
|
|
|
|
/* Since GCC cannot be trusted not to misuse a pointer to a smaller
|
|
array to point to an object of a larger type verify that the bound
|
|
in a pointer to an array of a known bound isn't relied on for
|
|
the strlen range optimization. If GCC is fixed to avoid these
|
|
misuses these tests can be removed. */
|
|
KEEP (strlen (*pa7) > sizeof *pa7);
|
|
KEEP (strlen (*pa5) > sizeof *pa5);
|
|
KEEP (strlen (*pa3) > sizeof *pa3);
|
|
|
|
KEEP (strlen ((*pa7_3)[0]) < 2);
|
|
KEEP (strlen ((*pa7_3)[1]) < 2);
|
|
KEEP (strlen ((*pa7_3)[6]) < 2);
|
|
KEEP (strlen ((*pa7_3)[i]) < 2);
|
|
|
|
/* Same as above. */
|
|
KEEP (strlen ((*pa7_3)[0]) > sizeof *pa7_3);
|
|
KEEP (strlen ((*pa7_3)[i]) > sizeof *pa7_3);
|
|
|
|
KEEP (strlen ((*pax_3)[0]) < 2);
|
|
KEEP (strlen ((*pax_3)[1]) < 2);
|
|
KEEP (strlen ((*pax_3)[9]) < 2);
|
|
KEEP (strlen ((*pax_3)[i]) < 2);
|
|
|
|
/* Same as above. */
|
|
KEEP (strlen ((*pax_3)[0]) > 3);
|
|
KEEP (strlen ((*pax_3)[i]) > 333);
|
|
|
|
KEEP (strlen ((*pa5_7)[0]) < 6);
|
|
KEEP (strlen ((*pa5_7)[1]) < 6);
|
|
KEEP (strlen ((*pa5_7)[4]) < 6);
|
|
KEEP (strlen ((*pa5_7)[i]) < 6);
|
|
|
|
/* Same as above. */
|
|
KEEP (strlen ((*pa5_7)[0]) > sizeof *pa5_7);
|
|
KEEP (strlen ((*pa5_7)[i]) > sizeof *pa5_7);
|
|
}
|
|
|
|
void keep_global_arrays_and_strings (int i)
|
|
{
|
|
KEEP (strlen (i < 0 ? a3 : "") < 2);
|
|
KEEP (strlen (i < 0 ? a3 : "1") < 2);
|
|
KEEP (strlen (i < 0 ? a3 : "12") < 2);
|
|
KEEP (strlen (i < 0 ? a3 : "123") < 3);
|
|
|
|
KEEP (strlen (i < 0 ? a7 : "") < 5);
|
|
KEEP (strlen (i < 0 ? a7 : "1") < 5);
|
|
KEEP (strlen (i < 0 ? a7 : "12") < 5);
|
|
KEEP (strlen (i < 0 ? a7 : "123") < 5);
|
|
KEEP (strlen (i < 0 ? a7 : "123456") < 6);
|
|
KEEP (strlen (i < 0 ? a7 : "1234567") < 6);
|
|
|
|
/* Verify that a matrix is treated as a flat array even in a conditional
|
|
expression (i.e., don't assume that a7_3[0] is nul-terminated, even
|
|
though calling strlen() on such an array is undefined). */
|
|
KEEP (strlen (i < 0 ? a7_3[0] : "") > 7);
|
|
KEEP (strlen (i < 0 ? a7_3[i] : "") > 7);
|
|
}
|
|
|
|
void keep_member_arrays_obj (int i)
|
|
{
|
|
KEEP (strlen (ma0_3_5_7[0][0][0].a3) < 2);
|
|
KEEP (strlen (ma0_3_5_7[0][0][1].a3) < 2);
|
|
KEEP (strlen (ma0_3_5_7[0][0][2].a3) < 2);
|
|
KEEP (strlen (ma0_3_5_7[0][0][6].a3) < 2);
|
|
|
|
KEEP (strlen (ma0_3_5_7[1][0][0].a3) < 2);
|
|
KEEP (strlen (ma0_3_5_7[2][0][1].a3) < 2);
|
|
|
|
KEEP (strlen (ma0_3_5_7[1][1][0].a3) < 2);
|
|
KEEP (strlen (ma0_3_5_7[2][4][6].a3) < 2);
|
|
|
|
KEEP (strlen (ma0_3_5_7[0][0][0].a5) < 4);
|
|
KEEP (strlen (ma0_3_5_7[0][0][1].a5) < 4);
|
|
KEEP (strlen (ma0_3_5_7[0][0][2].a5) < 4);
|
|
KEEP (strlen (ma0_3_5_7[0][0][6].a5) < 4);
|
|
|
|
KEEP (strlen (ma0_3_5_7[1][0][0].a5) < 4);
|
|
KEEP (strlen (ma0_3_5_7[2][0][1].a5) < 4);
|
|
|
|
KEEP (strlen (ma0_3_5_7[1][1][0].a5) < 4);
|
|
KEEP (strlen (ma0_3_5_7[2][4][6].a5) < 4);
|
|
|
|
KEEP (strlen (ma0_3_5_7[0][0][0].a7_3[0]) < 2);
|
|
KEEP (strlen (ma0_3_5_7[2][4][6].a7_3[2]) < 2);
|
|
|
|
KEEP (strlen (ma0_3_5_7[0][0][0].a5_7[0]) < 6);
|
|
KEEP (strlen (ma0_3_5_7[2][4][6].a5_7[4]) < 6);
|
|
|
|
/* Again, verify that the .a3 array isn't assumed to necessarily
|
|
be nul-terminated. */
|
|
KEEP (strlen (ma0_3_5_7[0][0][0].a3) > 2);
|
|
KEEP (strlen (ma0_3_5_7[0][0][6].a3) > 2);
|
|
KEEP (strlen (ma0_3_5_7[0][0][i].a3) > 2);
|
|
}
|
|
|
|
void keep_member_arrays_ptr (struct MemArrays0 *ma0,
|
|
struct MemArraysX *max,
|
|
struct MemArrays7 *ma7,
|
|
int i)
|
|
{
|
|
KEEP (strlen (ma0->a7_3[0]) > 0);
|
|
KEEP (strlen (ma0->a7_3[0]) < 2);
|
|
KEEP (strlen (ma0->a7_3[1]) < 2);
|
|
KEEP (strlen (ma0->a7_3[6]) < 2);
|
|
KEEP (strlen (ma0->a7_3[6]) < 2);
|
|
KEEP (strlen (ma0->a7_3[i]) > 0);
|
|
KEEP (strlen (ma0->a7_3[i]) < 2);
|
|
KEEP (strlen (ma0->a7_3[i]) < 2);
|
|
|
|
/* Again, verify that the member array isn't assumed to necessarily
|
|
be nul-terminated. */
|
|
KEEP (strlen (ma0->a7_3[0]) > sizeof ma0->a7_3);
|
|
KEEP (strlen (ma0->a7_3[i]) > sizeof ma0->a7_3);
|
|
|
|
KEEP (strlen (ma0->a5_7[0]) < 5);
|
|
KEEP (strlen (ma0[0].a5_7[0]) < 5);
|
|
KEEP (strlen (ma0[1].a5_7[0]) < 5);
|
|
KEEP (strlen (ma0[9].a5_7[0]) < 5);
|
|
KEEP (strlen (ma0[9].a5_7[4]) < 5);
|
|
KEEP (strlen (ma0[i].a5_7[4]) < 5);
|
|
KEEP (strlen (ma0[i].a5_7[i]) < 5);
|
|
|
|
/* Same as above. */
|
|
KEEP (strlen (ma0[i].a5_7[i]) > sizeof ma0[i].a5_7);
|
|
|
|
KEEP (strlen (ma0->a0) < DIFF_MAX - 2);
|
|
KEEP (strlen (ma0->a0) < 999);
|
|
KEEP (strlen (ma0->a0) < 1);
|
|
|
|
KEEP (strlen (max->ax) < DIFF_MAX - 2);
|
|
KEEP (strlen (max->ax) < 999);
|
|
KEEP (strlen (max->ax) < 1);
|
|
|
|
KEEP (strlen (ma7->a7) < DIFF_MAX - 2);
|
|
KEEP (strlen (ma7->a7) < 999);
|
|
KEEP (strlen (ma7->a7) < 1);
|
|
}
|
|
|
|
void keep_pointers (const char *s)
|
|
{
|
|
KEEP (strlen (ptr) < DIFF_MAX - 2);
|
|
KEEP (strlen (ptr) < 999);
|
|
KEEP (strlen (ptr) < 1);
|
|
|
|
KEEP (strlen (s) < DIFF_MAX - 2);
|
|
KEEP (strlen (s) < 999);
|
|
KEEP (strlen (s) < 1);
|
|
}
|
|
|
|
|
|
/* { dg-final { scan-tree-dump-times "call_in_true_branch_not_eliminated_" 0 "optimized" } }
|
|
{ dg-final { scan-tree-dump-times "call_in_false_branch_not_eliminated_" 0 "optimized" } }
|
|
|
|
{ dg-final { scan-tree-dump-times "call_made_in_true_branch_on_line_1\[0-9\]\[0-9\]\[0-9\]" 119 "optimized" } }
|
|
{ dg-final { scan-tree-dump-times "call_made_in_false_branch_on_line_1\[0-9\]\[0-9\]\[0-9\]" 119 "optimized" } } */
|