URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
Compare Revisions
- This comparison shows the changes necessary to convert path
/openrisc/trunk/gnu-dev/or1k-gcc/gcc/testsuite/gcc.misc-tests
- from Rev 685 to Rev 690
- ↔ Reverse comparison
Rev 685 → Rev 690
/gcov-3.c
0,0 → 1,48
/* Test Gcov with computed gotos. |
This is the same as test gcc.c-torture/execute/980526-1.c */ |
|
/* { dg-options "-fprofile-arcs -ftest-coverage" } */ |
/* { dg-do run { target native } } */ |
|
extern void abort (void); |
extern void exit (int); |
|
int expect_do1 = 1, expect_do2 = 2; |
|
static int doit(int x){ |
__label__ lbl1; |
__label__ lbl2; |
static int jtab_init = 0; |
static void *jtab[2]; |
|
if(!jtab_init) { |
jtab[0] = &&lbl1; |
jtab[1] = &&lbl2; |
jtab_init = 1; |
} |
goto *jtab[x]; |
lbl1: |
return 1; |
lbl2: |
return 2; |
} |
|
static void do1(void) { |
if (doit(0) != expect_do1) |
abort (); |
} |
|
static void do2(void){ |
if (doit(1) != expect_do2) |
abort (); |
} |
|
int main(void){ /* count(1) */ |
#ifndef NO_LABEL_VALUES |
do1(); |
do2(); |
#endif |
exit(0); /* count(1) */ |
} |
|
/* { dg-final { run-gcov gcov-3.c } } */ |
/gcov-4.c
0,0 → 1,273
/* Check that execution counts for various C constructs are reported |
correctly by gcov. */ |
|
/* { dg-options "-fprofile-arcs -ftest-coverage" } */ |
/* { dg-do run { target native } } */ |
|
extern void abort (void); |
|
int do_something (int i) |
{ |
return i; |
} |
|
/* Check static inline functions. */ |
|
int unref_val; |
|
static inline int |
unreferenced (int i, int j) |
{ |
return i - j; |
} |
|
static inline int |
uncalled (int i, int j) |
{ |
return i * j; |
} |
|
static inline int |
called (int i, int j) |
{ |
return i + j; /* count(1) */ |
} |
|
void |
call_unref () |
{ |
if (unref_val) /* count(1) */ |
unref_val = uncalled (1, 2); |
unref_val = called (unref_val, 4); /* count(1) */ |
} |
|
|
/* Check for loops. */ |
|
int for_val1; |
int for_val2; |
int for_temp; |
|
int |
test_for1 (int n) |
{ |
int i; |
for_temp = 1; /* count(3) */ |
for (i = 0; i < n; i++) |
for_temp++; /* count(9) */ |
return for_temp; /* count(3) */ |
} |
|
int |
test_for2 (int m, int n, int o) |
{ |
int i, j, k; |
for_temp = 1; /* count(6) */ |
for (i = 0; i < n; i++) |
for (j = 0; j < m; j++) |
for (k = 0; k < o; k++) |
for_temp++; /* count(81) */ |
return for_temp; /* count(6) */ |
} |
|
void |
call_for () |
{ |
for_val1 += test_for1 (0); |
for_val1 += test_for1 (2); |
for_val1 += test_for1 (7); |
|
for_val2 += test_for2 (0, 0, 0); |
for_val2 += test_for2 (1, 0, 0); |
for_val2 += test_for2 (1, 3, 0); |
for_val2 += test_for2 (1, 3, 1); |
for_val2 += test_for2 (3, 1, 5); |
for_val2 += test_for2 (3, 7, 3); |
} |
|
/* Check the use of goto. */ |
|
int goto_val; |
|
int |
test_goto1 (int f) |
{ |
if (f) /* count(2) */ |
goto lab1; /* count(1) */ |
return 1; /* count(1) */ |
lab1: |
return 2; /* count(1) */ |
} |
|
int |
test_goto2 (int f) |
{ |
int i; |
for (i = 0; i < 10; i++) /* count(15) */ |
if (i == f) goto lab2; /* count(14) */ |
return 4; /* count(1) */ |
lab2: |
return 8; /* count(1) */ |
} |
|
void |
call_goto () |
{ |
goto_val += test_goto1 (0); |
goto_val += test_goto1 (1); |
goto_val += test_goto2 (3); |
goto_val += test_goto2 (30); |
} |
|
/* Check nested if-then-else statements. */ |
|
int ifelse_val1; |
int ifelse_val2; |
int ifelse_val3; |
|
int |
test_ifelse1 (int i, int j) |
{ |
int result = 0; |
if (i) /* count(5) */ |
if (j) /* count(3) */ |
result = do_something (4); /* count(3) */ |
else |
result = do_something (1024); |
else |
if (j) /* count(2) */ |
result = do_something (1); /* count(1) */ |
else |
result = do_something (2); /* count(1) */ |
if (i > j) /* count(5) */ |
result = do_something (result*2); /* count(1) */ |
if (i > 10) /* count(5) */ |
if (j > 10) /* count(1) */ |
result = do_something (result*4); /* count(1) */ |
return result; /* count(5) */ |
} |
|
int |
test_ifelse2 (int i) |
{ |
int result = 0; |
if (!i) /* count(6) */ |
result = do_something (1); /* count(1) */ |
if (i == 1) /* count(6) */ |
result = do_something (1024); |
if (i == 2) /* count(6) */ |
result = do_something (2); /* count(3) */ |
if (i == 3) /* count(6) */ |
return do_something (8); /* count(2) */ |
if (i == 4) /* count(4) */ |
return do_something (2048); |
return result; /* count(4) */ |
} |
|
int |
test_ifelse3 (int i, int j) |
{ |
int result = 1; |
if (i > 10 && j > i && j < 20) /* count(11) */ |
result = do_something (16); /* count(1) */ |
if (i > 20) /* count(11) */ |
if (j > i) /* count(5) */ |
if (j < 30) /* count(2) */ |
result = do_something (32); /* count(1) */ |
if (i == 3 || j == 47 || i == j) /* count(11) */ |
result = do_something (64); /* count(3) */ |
return result; /* count(11) */ |
} |
|
void |
call_ifelse () |
{ |
ifelse_val1 += test_ifelse1 (0, 2); |
ifelse_val1 += test_ifelse1 (0, 0); |
ifelse_val1 += test_ifelse1 (1, 2); |
ifelse_val1 += test_ifelse1 (10, 2); |
ifelse_val1 += test_ifelse1 (11, 11); |
|
ifelse_val2 += test_ifelse2 (0); |
ifelse_val2 += test_ifelse2 (2); |
ifelse_val2 += test_ifelse2 (2); |
ifelse_val2 += test_ifelse2 (2); |
ifelse_val2 += test_ifelse2 (3); |
ifelse_val2 += test_ifelse2 (3); |
|
ifelse_val3 += test_ifelse3 (11, 19); |
ifelse_val3 += test_ifelse3 (25, 27); |
ifelse_val3 += test_ifelse3 (11, 22); |
ifelse_val3 += test_ifelse3 (11, 10); |
ifelse_val3 += test_ifelse3 (21, 32); |
ifelse_val3 += test_ifelse3 (21, 20); |
ifelse_val3 += test_ifelse3 (1, 2); |
ifelse_val3 += test_ifelse3 (32, 31); |
ifelse_val3 += test_ifelse3 (3, 0); |
ifelse_val3 += test_ifelse3 (0, 47); |
ifelse_val3 += test_ifelse3 (65, 65); |
} |
|
/* Check switch statements. */ |
|
int switch_val, switch_m; |
|
int |
test_switch (int i, int j) |
{ |
int result = 0; /* count(5) */ |
|
switch (i) /* count(5) */ |
{ |
case 1: |
result = do_something (2); /* count(1) */ |
break; |
case 2: |
result = do_something (1024); |
break; |
case 3: |
case 4: |
if (j == 2) /* count(3) */ |
return do_something (4); /* count(1) */ |
result = do_something (8); /* count(2) */ |
break; |
default: |
result = do_something (32); /* count(1) */ |
switch_m++; /* count(1) */ |
break; |
} |
return result; /* count(4) */ |
} |
|
void |
call_switch () |
{ |
switch_val += test_switch (1, 0); |
switch_val += test_switch (3, 0); |
switch_val += test_switch (3, 2); |
switch_val += test_switch (4, 0); |
switch_val += test_switch (16, 0); |
switch_val += switch_m; |
} |
|
int |
main() |
{ |
call_for (); |
call_goto (); |
call_ifelse (); |
call_switch (); |
call_unref (); |
if ((for_val1 != 12) |
|| (for_val2 != 87) |
|| (goto_val != 15) |
|| (ifelse_val1 != 31) |
|| (ifelse_val2 != 23) |
|| (ifelse_val3 != 246) |
|| (switch_val != 55) |
|| (unref_val != 4)) |
abort (); |
return 0; |
} |
|
/* { dg-final { run-gcov gcov-4.c } } */ |
/gcov-6.c
0,0 → 1,39
/* Check that call return percentages are reported correctly by gcov, |
along with line counts and branch percentages. This test case is |
meant to be simple, as it was added at the same time that checking |
for call return percentages was added. */ |
|
/* { dg-options "-fprofile-arcs -ftest-coverage" } */ |
/* { dg-do run { target native } } */ |
|
extern void exit (int); |
|
int val; |
|
void |
foo (int i) |
{ |
/* branch(80) */ |
if (i < 0) /* count(5) */ |
/* branch(end) */ |
/* returns(0) */ |
exit (0); /* count(1) */ |
/* returns(end) */ |
val += i; /* count(4) */ |
} |
|
int |
main() |
{ |
int i; |
|
/* returns(100) */ |
foo (100); /* count(1) */ |
/* returns(end) */ |
for (i = 2; i > -10; i--) |
/* returns(75) */ |
foo (i); /* count(4) */ |
/* returns(end) */ |
} |
|
/* { dg-final { run-gcov branches calls { -b gcov-6.c } } } */ |
/i386-prefetch.exp
0,0 → 1,114
# Copyright (C) 2002, 2004, 2007, 2008 Free Software Foundation, Inc. |
|
# This program is free software; you can redistribute it and/or modify |
# it under the terms of the GNU General Public License as published by |
# the Free Software Foundation; either version 3 of the License, or |
# (at your option) any later version. |
# |
# This program is distributed in the hope that it will be useful, |
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
# GNU General Public License for more details. |
# |
# You should have received a copy of the GNU General Public License |
# along with GCC; see the file COPYING3. If not see |
# <http://www.gnu.org/licenses/>. |
|
# Test that the correct data prefetch instructions (SSE or 3DNow! variant, |
# or none) are used for various i386 cpu-type and instruction set |
# extension options for __builtin_prefetch. When using -mtune, specify |
# the minimum supported architecture in case the compiler was configured |
# with a different default. |
|
# Failure reports do not include the compile option that was used; that |
# information can be seen in the compile line in the log file. |
|
# Do not generate prefetch instructions for the following options. |
|
set PREFETCH_NONE [list \ |
{ -march=i386 -mtune=i386 } \ |
{ -march=i386 -mtune=i486 } \ |
{ -march=i386 -mtune=i586 } \ |
{ -march=i386 -mtune=i686 } \ |
{ -march=i386 -mtune=pentium2 } \ |
{ -march=i386 -mtune=k6 } \ |
{ -march=i386 -mtune=k6-2 } \ |
{ -march=i386 -mtune=k6-3 } \ |
{ -march=i386 } \ |
{ -march=i486 } \ |
{ -march=i586 } \ |
{ -march=i686 } \ |
{ -march=pentium2 } \ |
{ -march=k6 } ] |
|
# For options in PREFETCH_SSE, generate SSE prefetch instructions for |
# __builtin_prefetch. This includes -mtune for targets that treat prefetch |
# instructions as nops. |
|
set PREFETCH_SSE [list \ |
{ -march=i686 -mtune=pentium3 } \ |
{ -march=i686 -mtune=pentium3m } \ |
{ -march=i686 -mtune=pentium-m } \ |
{ -march=i686 -mtune=pentium4 } \ |
{ -march=i686 -mtune=pentium4m } \ |
{ -march=i686 -mtune=prescott } \ |
{ -march=i686 -mtune=athlon } \ |
{ -march=i686 -mtune=athlon-4 } \ |
{ -march=i686 -mtune=c3-2 } \ |
{ -march=pentium3 } \ |
{ -march=pentium3m } \ |
{ -march=pentium-m } \ |
{ -march=pentium4 } \ |
{ -march=pentium4m } \ |
{ -march=prescott } \ |
{ -march=c3-2 } ] |
|
# Generate 3DNow! prefetch instructions for the following. |
|
set PREFETCH_3DNOW [list \ |
{ -march=c3 } \ |
{ -march=k6-2 } \ |
{ -march=k6-3 } ] |
|
# Athlon supports both 3DNow! and SSE prefetch instructions. For |
# __builtin_prefetch, generate the 3DNow! instruction for write |
# prefetches but SSE prefetch instructions for read prefetches. |
|
set PREFETCH_ATHLON [list \ |
{ -march=athlon } \ |
{ -march=athlon-4 } ] |
|
if $tracelevel then { |
strace $tracelevel |
} |
|
# Load support procs. |
load_lib gcc-dg.exp |
load_lib torture-options.exp |
|
# Initialize harness. |
dg-init |
torture-init |
|
if { [board_info target exists multilib_flags] |
&& [string match "* -march=*" " [board_info target multilib_flags] "] } { |
# Multilib flags come after the -march flags we pass and override |
# them, so skip these tests when such flags are passed. |
return |
} |
|
set-torture-options $PREFETCH_NONE |
gcc-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/i386-pf-none-*.c]] "" |
|
set-torture-options $PREFETCH_SSE |
gcc-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/i386-pf-sse-*.c]] "" |
|
set-torture-options $PREFETCH_3DNOW |
gcc-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/i386-pf-3dnow-*.c]] "" |
|
set-torture-options $PREFETCH_ATHLON |
gcc-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/i386-pf-athlon-*.c]] "" |
|
torture-finish |
dg-finish |
|
/gcov-7.c
0,0 → 1,87
/* Check that gcov correctly reports line counts, branch percentages, |
* and call return percentages for functions that call longjmp. */ |
|
/* { dg-options "-fprofile-arcs -ftest-coverage" } */ |
/* { dg-do run { target native } } */ |
|
#include <setjmp.h> |
|
extern void abort (void); |
extern void exit (int); |
|
jmp_buf env; |
int val; |
int longjmp_taken; |
int bar_enter, bar_exit; |
int foo_enter, foo_exit; |
|
void bar (int i) |
{ |
bar_enter++; /* count(3) */ |
/* branch(67) */ |
if (i == 0) { |
/* branch(end) */ |
longjmp_taken++; /* count(1) */ |
longjmp (env, 1); |
} |
val += i+1; |
bar_exit++; /* count(2) */ |
} |
|
void foo (int i) |
{ |
foo_enter++; /* count(3) */ |
/* branch(67) */ |
if (i == 1) { |
/* branch(end) */ |
longjmp_taken++; /* count(1) */ |
longjmp (env, 2); |
} |
/* returns(50) */ |
bar (i); /* count(2) */ |
/* returns(100) */ |
bar (7); /* count(1) */ |
/* returns(end) */ |
val += 16; |
foo_exit++; /* count(1) */ |
} |
|
int |
passed () |
{ |
return (val == 31 && |
longjmp_taken == 2 && |
foo_enter == 3 && |
foo_exit == 1 && |
bar_enter == 3 && |
bar_exit == 2); |
|
} |
|
void |
leave (int i) |
{ |
if (i == 0) { |
abort (); |
} |
exit (0); |
} |
|
int |
main() |
{ |
int retval; |
|
/* branch(33) */ |
if ((retval = setjmp (env))) { |
/* branch(end) */ |
val += retval; /* count(2) */ |
} |
/* returns(33) */ |
foo (val); /* count(3) */ |
/* returns(0) */ |
leave (passed()); /* count(1) */ |
/* returns(end) */ |
} |
|
/* { dg-final { run-gcov calls branches { -b gcov-7.c } } } */ |
/gcov-5b.c
0,0 → 1,34
/* Check that branch percentages are calculated in variables |
that are large enough to hold the count. */ |
|
/* { dg-options "-fprofile-arcs -ftest-coverage" } */ |
/* { dg-do run { target native } } */ |
|
#define LIMIT1 7000 |
#define LIMIT2 7000 |
|
int count; |
|
void incr_count () |
{ |
count++; |
} |
|
void doit (int i, int j) |
{ |
if (i > j) |
incr_count (); |
} |
|
int main () |
{ |
int i, j; |
|
for (i = 0; i < LIMIT1; i++) |
for (j = 0; j < LIMIT2; j++) |
doit (i, j); |
|
return 0; |
} |
|
/* { dg-final { run-gcov branches { -b gcov-5b.c } } } */ |
/bprob-1.c
0,0 → 1,271
/* Check that various C constructs are handled correctly by profile-directed |
block ordering. |
|
This test is the same as gcov-4.c. The "count" comments are left in to |
make comparisons easier; they are ignored for this test. */ |
|
extern void abort (void); |
|
int do_something (int i) |
{ |
return i; |
} |
|
/* Check static inline functions. */ |
|
int unref_val; |
|
static inline int |
unreferenced (int i, int j) |
{ |
return i - j; |
} |
|
static inline int |
uncalled (int i, int j) |
{ |
return i * j; |
} |
|
static inline int |
called (int i, int j) |
{ |
return i + j; /* count(1) */ |
} |
|
void |
call_unref () |
{ |
if (unref_val) /* count(1) */ |
unref_val = uncalled (1, 2); |
unref_val = called (unref_val, 4); /* count(1) */ |
} |
|
|
/* Check for loops. */ |
|
int for_val1; |
int for_val2; |
int for_temp; |
|
int |
test_for1 (int n) |
{ |
int i; |
for_temp = 1; /* count(3) */ |
for (i = 0; i < n; i++) |
for_temp++; /* count(9) */ |
return for_temp; /* count(3) */ |
} |
|
int |
test_for2 (int m, int n, int o) |
{ |
int i, j, k; |
for_temp = 1; /* count(6) */ |
for (i = 0; i < n; i++) |
for (j = 0; j < m; j++) |
for (k = 0; k < o; k++) |
for_temp++; /* count(81) */ |
return for_temp; /* count(6) */ |
} |
|
void |
call_for () |
{ |
for_val1 += test_for1 (0); |
for_val1 += test_for1 (2); |
for_val1 += test_for1 (7); |
|
for_val2 += test_for2 (0, 0, 0); |
for_val2 += test_for2 (1, 0, 0); |
for_val2 += test_for2 (1, 3, 0); |
for_val2 += test_for2 (1, 3, 1); |
for_val2 += test_for2 (3, 1, 5); |
for_val2 += test_for2 (3, 7, 3); |
} |
|
/* Check the use of goto. */ |
|
int goto_val; |
|
int |
test_goto1 (int f) |
{ |
if (f) /* count(2) */ |
goto lab1; /* count(1) */ |
return 1; /* count(1) */ |
lab1: |
return 2; /* count(1) */ |
} |
|
int |
test_goto2 (int f) |
{ |
int i; |
for (i = 0; i < 10; i++) /* count(15) */ |
if (i == f) goto lab2; /* count(14) */ |
return 4; /* count(1) */ |
lab2: |
return 8; /* count(1) */ |
} |
|
void |
call_goto () |
{ |
goto_val += test_goto1 (0); |
goto_val += test_goto1 (1); |
goto_val += test_goto2 (3); |
goto_val += test_goto2 (30); |
} |
|
/* Check nested if-then-else statements. */ |
|
int ifelse_val1; |
int ifelse_val2; |
int ifelse_val3; |
|
int |
test_ifelse1 (int i, int j) |
{ |
int result = 0; |
if (i) /* count(5) */ |
if (j) /* count(3) */ |
result = do_something (4); /* count(3) */ |
else |
result = do_something (1024); |
else |
if (j) /* count(2) */ |
result = do_something (1); /* count(1) */ |
else |
result = do_something (2); /* count(1) */ |
if (i > j) /* count(5) */ |
result = do_something (result*2); /* count(1) */ |
if (i > 10) /* count(5) */ |
if (j > 10) /* count(1) */ |
result = do_something (result*4); /* count(1) */ |
return result; /* count(5) */ |
} |
|
int |
test_ifelse2 (int i) |
{ |
int result = 0; |
if (!i) /* count(6) */ |
result = do_something (1); /* count(1) */ |
if (i == 1) /* count(6) */ |
result = do_something (1024); |
if (i == 2) /* count(6) */ |
result = do_something (2); /* count(3) */ |
if (i == 3) /* count(6) */ |
return do_something (8); /* count(2) */ |
if (i == 4) /* count(4) */ |
return do_something (2048); |
return result; /* count(4) */ |
} |
|
int |
test_ifelse3 (int i, int j) |
{ |
int result = 1; |
if (i > 10 && j > i && j < 20) /* count(11) */ |
result = do_something (16); /* count(1) */ |
if (i > 20) /* count(11) */ |
if (j > i) /* count(5) */ |
if (j < 30) /* count(2) */ |
result = do_something (32); /* count(1) */ |
if (i == 3 || j == 47 || i == j) /* count(11) */ |
result = do_something (64); /* count(3) */ |
return result; /* count(11) */ |
} |
|
void |
call_ifelse () |
{ |
ifelse_val1 += test_ifelse1 (0, 2); |
ifelse_val1 += test_ifelse1 (0, 0); |
ifelse_val1 += test_ifelse1 (1, 2); |
ifelse_val1 += test_ifelse1 (10, 2); |
ifelse_val1 += test_ifelse1 (11, 11); |
|
ifelse_val2 += test_ifelse2 (0); |
ifelse_val2 += test_ifelse2 (2); |
ifelse_val2 += test_ifelse2 (2); |
ifelse_val2 += test_ifelse2 (2); |
ifelse_val2 += test_ifelse2 (3); |
ifelse_val2 += test_ifelse2 (3); |
|
ifelse_val3 += test_ifelse3 (11, 19); |
ifelse_val3 += test_ifelse3 (25, 27); |
ifelse_val3 += test_ifelse3 (11, 22); |
ifelse_val3 += test_ifelse3 (11, 10); |
ifelse_val3 += test_ifelse3 (21, 32); |
ifelse_val3 += test_ifelse3 (21, 20); |
ifelse_val3 += test_ifelse3 (1, 2); |
ifelse_val3 += test_ifelse3 (32, 31); |
ifelse_val3 += test_ifelse3 (3, 0); |
ifelse_val3 += test_ifelse3 (0, 47); |
ifelse_val3 += test_ifelse3 (65, 65); |
} |
|
/* Check switch statements. */ |
|
int switch_val, switch_m; |
|
int |
test_switch (int i, int j) |
{ |
int result = 0; /* count(5) */ |
|
switch (i) /* count(5) */ |
{ |
case 1: |
result = do_something (2); /* count(1) */ |
break; |
case 2: |
result = do_something (1024); |
break; |
case 3: |
case 4: |
if (j == 2) /* count(3) */ |
return do_something (4); /* count(1) */ |
result = do_something (8); /* count(2) */ |
break; |
default: |
result = do_something (32); /* count(1) */ |
switch_m++; /* count(1) */ |
break; |
} |
return result; /* count(4) */ |
} |
|
void |
call_switch () |
{ |
switch_val += test_switch (1, 0); |
switch_val += test_switch (3, 0); |
switch_val += test_switch (3, 2); |
switch_val += test_switch (4, 0); |
switch_val += test_switch (16, 0); |
switch_val += switch_m; |
} |
|
int |
main() |
{ |
call_for (); |
call_goto (); |
call_ifelse (); |
call_switch (); |
call_unref (); |
if ((for_val1 != 12) |
|| (for_val2 != 87) |
|| (goto_val != 15) |
|| (ifelse_val1 != 31) |
|| (ifelse_val2 != 23) |
|| (ifelse_val3 != 246) |
|| (switch_val != 55) |
|| (unref_val != 4)) |
abort (); |
return 0; |
} |
/mg-2.c
0,0 → 1,9
/* PR 15220 */ |
|
#include <nonexist0.h> |
#include "nonexist.h" |
int |
main () |
{ |
return 0; |
} |
/gcov-8.c
0,0 → 1,47
/* Check that gcov correctly rounds nearly zero to nonzero and nearly |
100 to not-100. |
|
Copyright (C) 2002 Free Software Foundation, Inc. |
Contributed by Nathan Sidwell <nathan@codesourcery.com> |
*/ |
|
/* { dg-options "-fprofile-arcs -ftest-coverage" } */ |
/* { dg-do run { target native } } */ |
|
int proxy (int i) |
{ |
return i; |
} |
|
int foo (int i) |
{ |
if (i > 0) /* branch(1) */ |
return proxy (1); |
else if (i < 0) /* branch(100) */ |
return proxy (-1); |
else |
return proxy (0); |
} |
|
int baz (int i) |
{ |
if (i == 0) /* branch(99) */ |
return proxy (0); |
else if (i > 0) /* branch(0)*/ |
return proxy (1); |
else |
return proxy (-1); |
} |
|
int main () |
{ |
int t = 0; |
int ix; |
|
for (ix = 0; ix != 1000; ix++) |
t += foo (ix) + baz (ix); |
|
return t == 0; |
} |
|
/* { dg-final { run-gcov branches {-b gcov-8.c } } } */ |
/bprob-2.c
0,0 → 1,45
/* Test profile-directed block ordering with computed gotos. |
* |
This is the same as test gcc.c-torture/execute/980526-1.c and |
gcc.misc-tests/gcov-3.c */ |
|
extern void abort (void); |
extern void exit (int); |
|
int expect_do1 = 1, expect_do2 = 2; |
|
static int doit(int x){ |
__label__ lbl1; |
__label__ lbl2; |
static int jtab_init = 0; |
static void *jtab[2]; |
|
if(!jtab_init) { |
jtab[0] = &&lbl1; |
jtab[1] = &&lbl2; |
jtab_init = 1; |
} |
goto *jtab[x]; |
lbl1: |
return 1; |
lbl2: |
return 2; |
} |
|
static void do1(void) { |
if (doit(0) != expect_do1) |
abort (); |
} |
|
static void do2(void){ |
if (doit(1) != expect_do2) |
abort (); |
} |
|
int main(void){ |
#ifndef NO_LABEL_VALUES |
do1(); |
do2(); |
#endif |
exit(0); |
} |
/mg.c
0,0 → 1,8
/* PR 2981 */ |
|
#include "nonexist.h" |
int |
main () |
{ |
return 0; |
} |
/gcov-9.c
0,0 → 1,15
/* Test gcov block mode. */ |
|
/* { dg-options "-fprofile-arcs -ftest-coverage" } */ |
/* { dg-do run { target native } } */ |
|
int main () |
{ |
unsigned ix; |
|
for (ix = 10; ix--;); /* count(11) */ |
|
return 0; |
} |
|
/* { dg-final { run-gcov { -a gcov-9.c } } } */ |
/acker1.c
0,0 → 1,23
#include <stdio.h> |
|
int acker(int, int); |
|
int |
main(void) |
{ |
int n = acker(3,6); |
if (n != 509) |
printf("acker(3,6) = %d != 509\n", n); |
return(0); |
} |
|
int |
acker(int x,int y) |
{ |
if (x==0) |
return(y+1); |
else if (y==0) |
return(acker(x-1,1)); |
else |
return(acker(x-1, acker(x, y-1))); |
} |
/dhry.c
0,0 → 1,602
/* |
**************************************************************************** |
* |
* "DHRYSTONE" Benchmark Program |
* ----------------------------- |
* |
* Version: C, Version 2.1 |
* |
* File: dhry_1.c (part 2 of 3) |
* |
* Date: May 25, 1988 |
* |
* Author: Reinhold P. Weicker |
* |
**************************************************************************** |
*/ |
|
#include "dhry.h" |
|
/* Global Variables: */ |
|
Rec_Pointer Ptr_Glob, |
Next_Ptr_Glob; |
int Int_Glob; |
Boolean Bool_Glob; |
char Ch_1_Glob, |
Ch_2_Glob; |
int Arr_1_Glob [50]; |
int Arr_2_Glob [50] [50]; |
|
extern char *malloc (); |
Enumeration Func_1 (); |
/* forward declaration necessary since Enumeration may not simply be int */ |
|
#ifndef REG |
Boolean Reg = false; |
#define REG |
/* REG becomes defined as empty */ |
/* i.e. no register variables */ |
#else |
Boolean Reg = true; |
#endif |
|
/* variables for time measurement: */ |
|
/* |
#ifdef TIMES |
struct tms time_info; |
extern int times (); |
#endif |
*/ |
/* |
#ifdef TIME |
extern long time(); |
#endif |
*/ |
#define Too_Small_Time 2 |
/* Measurements should last at least 2 seconds */ |
|
long Begin_Time, |
End_Time, |
User_Time; |
float Microseconds, |
Dhrystones_Per_Second; |
|
/* end of variables for time measurement */ |
|
|
main () |
/*****/ |
|
/* main program, corresponds to procedures */ |
/* Main and Proc_0 in the Ada version */ |
{ |
One_Fifty Int_1_Loc; |
REG One_Fifty Int_2_Loc; |
One_Fifty Int_3_Loc; |
REG char Ch_Index; |
Enumeration Enum_Loc; |
Str_30 Str_1_Loc; |
Str_30 Str_2_Loc; |
REG int Run_Index; |
REG int Number_Of_Runs; |
|
/* Initializations */ |
|
Next_Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type)); |
Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type)); |
|
Ptr_Glob->Ptr_Comp = Next_Ptr_Glob; |
Ptr_Glob->Discr = Ident_1; |
Ptr_Glob->variant.var_1.Enum_Comp = Ident_3; |
Ptr_Glob->variant.var_1.Int_Comp = 40; |
strcpy (Ptr_Glob->variant.var_1.Str_Comp, |
"DHRYSTONE PROGRAM, SOME STRING"); |
strcpy (Str_1_Loc, "DHRYSTONE PROGRAM, 1'ST STRING"); |
|
Arr_2_Glob [8][7] = 10; |
/* Was missing in published program. Without this statement, */ |
/* Arr_2_Glob [8][7] would have an undefined value. */ |
/* Warning: With 16-Bit processors and Number_Of_Runs > 32000, */ |
/* overflow may occur for this array element. */ |
|
/* |
printf ("\n"); |
printf ("Dhrystone Benchmark, Version 2.1 (Language: C)\n"); |
printf ("\n"); |
*/ |
if (Reg) |
{ |
/* |
printf ("Program compiled with 'register' attribute\n"); |
printf ("\n"); |
*/ |
} |
else |
{ |
/* |
printf ("Program compiled without 'register' attribute\n"); |
printf ("\n"); |
*/ |
} |
/* |
printf ("Please give the number of runs through the benchmark: "); |
*/ |
{ |
int n; |
/* |
scanf ("%d", &n); |
*/ |
Number_Of_Runs = n=1000; |
} |
/* |
printf ("\n"); |
|
printf ("Execution starts, %d runs through Dhrystone\n", Number_Of_Runs); |
*/ |
|
/***************/ |
/* Start timer */ |
/***************/ |
|
/* |
#ifdef TIMES |
times (&time_info); |
Begin_Time = (long) time_info.tms_utime; |
#endif |
#ifdef TIME |
Begin_Time = time ( (long *) 0); |
#endif |
*/ |
|
for (Run_Index = 1; Run_Index <= Number_Of_Runs; ++Run_Index) |
{ |
|
Proc_5(); |
Proc_4(); |
/* Ch_1_Glob == 'A', Ch_2_Glob == 'B', Bool_Glob == true */ |
Int_1_Loc = 2; |
Int_2_Loc = 3; |
strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 2'ND STRING"); |
Enum_Loc = Ident_2; |
Bool_Glob = ! Func_2 (Str_1_Loc, Str_2_Loc); |
/* Bool_Glob == 1 */ |
while (Int_1_Loc < Int_2_Loc) /* loop body executed once */ |
{ |
Int_3_Loc = 5 * Int_1_Loc - Int_2_Loc; |
/* Int_3_Loc == 7 */ |
Proc_7 (Int_1_Loc, Int_2_Loc, &Int_3_Loc); |
/* Int_3_Loc == 7 */ |
Int_1_Loc += 1; |
} /* while */ |
/* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */ |
Proc_8 (Arr_1_Glob, Arr_2_Glob, Int_1_Loc, Int_3_Loc); |
/* Int_Glob == 5 */ |
Proc_1 (Ptr_Glob); |
for (Ch_Index = 'A'; Ch_Index <= Ch_2_Glob; ++Ch_Index) |
/* loop body executed twice */ |
{ |
if (Enum_Loc == Func_1 (Ch_Index, 'C')) |
/* then, not executed */ |
{ |
Proc_6 (Ident_1, &Enum_Loc); |
strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 3'RD STRING"); |
Int_2_Loc = Run_Index; |
Int_Glob = Run_Index; |
} |
} |
/* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */ |
Int_2_Loc = Int_2_Loc * Int_1_Loc; |
Int_1_Loc = Int_2_Loc / Int_3_Loc; |
Int_2_Loc = 7 * (Int_2_Loc - Int_3_Loc) - Int_1_Loc; |
/* Int_1_Loc == 1, Int_2_Loc == 13, Int_3_Loc == 7 */ |
Proc_2 (&Int_1_Loc); |
/* Int_1_Loc == 5 */ |
|
} /* loop "for Run_Index" */ |
|
/**************/ |
/* Stop timer */ |
/**************/ |
|
/* |
#ifdef TIMES |
times (&time_info); |
End_Time = (long) time_info.tms_utime; |
#endif |
#ifdef TIME |
End_Time = time ( (long *) 0); |
#endif |
*/ |
|
/* |
printf ("Execution ends\n"); |
printf ("\n"); |
printf ("Final values of the variables used in the benchmark:\n"); |
printf ("\n"); |
printf ("Int_Glob: %d\n", Int_Glob); |
printf (" should be: %d\n", 5); |
printf ("Bool_Glob: %d\n", Bool_Glob); |
printf (" should be: %d\n", 1); |
printf ("Ch_1_Glob: %c\n", Ch_1_Glob); |
printf (" should be: %c\n", 'A'); |
printf ("Ch_2_Glob: %c\n", Ch_2_Glob); |
printf (" should be: %c\n", 'B'); |
printf ("Arr_1_Glob[8]: %d\n", Arr_1_Glob[8]); |
printf (" should be: %d\n", 7); |
printf ("Arr_2_Glob[8][7]: %d\n", Arr_2_Glob[8][7]); |
printf (" should be: Number_Of_Runs + 10\n"); |
printf ("Ptr_Glob->\n"); |
printf (" Ptr_Comp: %d\n", (int) Ptr_Glob->Ptr_Comp); |
printf (" should be: (implementation-dependent)\n"); |
printf (" Discr: %d\n", Ptr_Glob->Discr); |
printf (" should be: %d\n", 0); |
printf (" Enum_Comp: %d\n", Ptr_Glob->variant.var_1.Enum_Comp); |
printf (" should be: %d\n", 2); |
printf (" Int_Comp: %d\n", Ptr_Glob->variant.var_1.Int_Comp); |
printf (" should be: %d\n", 17); |
printf (" Str_Comp: %s\n", Ptr_Glob->variant.var_1.Str_Comp); |
printf (" should be: DHRYSTONE PROGRAM, SOME STRING\n"); |
printf ("Next_Ptr_Glob->\n"); |
printf (" Ptr_Comp: %d\n", (int) Next_Ptr_Glob->Ptr_Comp); |
printf (" should be: (implementation-dependent), same as above\n"); |
printf (" Discr: %d\n", Next_Ptr_Glob->Discr); |
printf (" should be: %d\n", 0); |
printf (" Enum_Comp: %d\n", Next_Ptr_Glob->variant.var_1.Enum_Comp); |
printf (" should be: %d\n", 1); |
printf (" Int_Comp: %d\n", Next_Ptr_Glob->variant.var_1.Int_Comp); |
printf (" should be: %d\n", 18); |
printf (" Str_Comp: %s\n", |
Next_Ptr_Glob->variant.var_1.Str_Comp); |
printf (" should be: DHRYSTONE PROGRAM, SOME STRING\n"); |
printf ("Int_1_Loc: %d\n", Int_1_Loc); |
printf (" should be: %d\n", 5); |
printf ("Int_2_Loc: %d\n", Int_2_Loc); |
printf (" should be: %d\n", 13); |
printf ("Int_3_Loc: %d\n", Int_3_Loc); |
printf (" should be: %d\n", 7); |
printf ("Enum_Loc: %d\n", Enum_Loc); |
printf (" should be: %d\n", 1); |
printf ("Str_1_Loc: %s\n", Str_1_Loc); |
printf (" should be: DHRYSTONE PROGRAM, 1'ST STRING\n"); |
printf ("Str_2_Loc: %s\n", Str_2_Loc); |
printf (" should be: DHRYSTONE PROGRAM, 2'ND STRING\n"); |
printf ("\n"); |
*/ |
|
User_Time = End_Time - Begin_Time; |
|
if (User_Time < Too_Small_Time) |
{ |
/* |
printf ("Measured time too small to obtain meaningful results\n"); |
printf ("Please increase number of runs\n"); |
printf ("\n"); |
*/ |
} |
else |
{ |
#ifdef TIME |
/* |
Microseconds = (float) User_Time * Mic_secs_Per_Second |
/ (float) Number_Of_Runs; |
Dhrystones_Per_Second = (float) Number_Of_Runs / (float) User_Time; |
*/ |
#else |
/* |
Microseconds = (float) User_Time * Mic_secs_Per_Second |
/ ((float) HZ * ((float) Number_Of_Runs)); |
Dhrystones_Per_Second = ((float) HZ * (float) Number_Of_Runs) |
/ (float) User_Time; |
*/ |
#endif |
/* |
printf ("Microseconds for one run through Dhrystone: "); |
printf ("%6.1f \n", Microseconds); |
printf ("Dhrystones per Second: "); |
printf ("%6.1f \n", Dhrystones_Per_Second); |
printf ("\n"); |
*/ |
} |
|
exit (0); |
} |
|
|
Proc_1 (Ptr_Val_Par) |
/******************/ |
|
REG Rec_Pointer Ptr_Val_Par; |
/* executed once */ |
{ |
REG Rec_Pointer Next_Record = Ptr_Val_Par->Ptr_Comp; |
/* == Ptr_Glob_Next */ |
/* Local variable, initialized with Ptr_Val_Par->Ptr_Comp, */ |
/* corresponds to "rename" in Ada, "with" in Pascal */ |
|
structassign (*Ptr_Val_Par->Ptr_Comp, *Ptr_Glob); |
Ptr_Val_Par->variant.var_1.Int_Comp = 5; |
Next_Record->variant.var_1.Int_Comp |
= Ptr_Val_Par->variant.var_1.Int_Comp; |
Next_Record->Ptr_Comp = Ptr_Val_Par->Ptr_Comp; |
Proc_3 (&Next_Record->Ptr_Comp); |
/* Ptr_Val_Par->Ptr_Comp->Ptr_Comp |
== Ptr_Glob->Ptr_Comp */ |
if (Next_Record->Discr == Ident_1) |
/* then, executed */ |
{ |
Next_Record->variant.var_1.Int_Comp = 6; |
Proc_6 (Ptr_Val_Par->variant.var_1.Enum_Comp, |
&Next_Record->variant.var_1.Enum_Comp); |
Next_Record->Ptr_Comp = Ptr_Glob->Ptr_Comp; |
Proc_7 (Next_Record->variant.var_1.Int_Comp, 10, |
&Next_Record->variant.var_1.Int_Comp); |
} |
else /* not executed */ |
structassign (*Ptr_Val_Par, *Ptr_Val_Par->Ptr_Comp); |
} /* Proc_1 */ |
|
|
Proc_2 (Int_Par_Ref) |
/******************/ |
/* executed once */ |
/* *Int_Par_Ref == 1, becomes 4 */ |
|
One_Fifty *Int_Par_Ref; |
{ |
One_Fifty Int_Loc; |
Enumeration Enum_Loc; |
|
Int_Loc = *Int_Par_Ref + 10; |
do /* executed once */ |
if (Ch_1_Glob == 'A') |
/* then, executed */ |
{ |
Int_Loc -= 1; |
*Int_Par_Ref = Int_Loc - Int_Glob; |
Enum_Loc = Ident_1; |
} /* if */ |
while (Enum_Loc != Ident_1); /* true */ |
} /* Proc_2 */ |
|
|
Proc_3 (Ptr_Ref_Par) |
/******************/ |
/* executed once */ |
/* Ptr_Ref_Par becomes Ptr_Glob */ |
|
Rec_Pointer *Ptr_Ref_Par; |
|
{ |
if (Ptr_Glob != Null) |
/* then, executed */ |
*Ptr_Ref_Par = Ptr_Glob->Ptr_Comp; |
Proc_7 (10, Int_Glob, &Ptr_Glob->variant.var_1.Int_Comp); |
} /* Proc_3 */ |
|
|
Proc_4 () /* without parameters */ |
/*******/ |
/* executed once */ |
{ |
Boolean Bool_Loc; |
|
Bool_Loc = Ch_1_Glob == 'A'; |
Bool_Glob = Bool_Loc | Bool_Glob; |
Ch_2_Glob = 'B'; |
} /* Proc_4 */ |
|
|
Proc_5 () /* without parameters */ |
/*******/ |
/* executed once */ |
{ |
Ch_1_Glob = 'A'; |
Bool_Glob = false; |
} /* Proc_5 */ |
|
|
/* Procedure for the assignment of structures, */ |
/* if the C compiler doesn't support this feature */ |
#ifdef NOSTRUCTASSIGN |
memcpy (d, s, l) |
register char *d; |
register char *s; |
register int l; |
{ |
while (l--) *d++ = *s++; |
} |
#endif |
|
|
/* |
**************************************************************************** |
* |
* "DHRYSTONE" Benchmark Program |
* ----------------------------- |
* |
* Version: C, Version 2.1 |
* |
* File: dhry_2.c (part 3 of 3) |
* |
* Date: May 25, 1988 |
* |
* Author: Reinhold P. Weicker |
* |
**************************************************************************** |
*/ |
|
#ifndef REG |
#define REG |
/* REG becomes defined as empty */ |
/* i.e. no register variables */ |
#endif |
|
extern int Int_Glob; |
extern char Ch_1_Glob; |
|
|
Proc_6 (Enum_Val_Par, Enum_Ref_Par) |
/*********************************/ |
/* executed once */ |
/* Enum_Val_Par == Ident_3, Enum_Ref_Par becomes Ident_2 */ |
|
Enumeration Enum_Val_Par; |
Enumeration *Enum_Ref_Par; |
{ |
*Enum_Ref_Par = Enum_Val_Par; |
if (! Func_3 (Enum_Val_Par)) |
/* then, not executed */ |
*Enum_Ref_Par = Ident_4; |
switch (Enum_Val_Par) |
{ |
case Ident_1: |
*Enum_Ref_Par = Ident_1; |
break; |
case Ident_2: |
if (Int_Glob > 100) |
/* then */ |
*Enum_Ref_Par = Ident_1; |
else *Enum_Ref_Par = Ident_4; |
break; |
case Ident_3: /* executed */ |
*Enum_Ref_Par = Ident_2; |
break; |
case Ident_4: break; |
case Ident_5: |
*Enum_Ref_Par = Ident_3; |
break; |
} /* switch */ |
} /* Proc_6 */ |
|
|
Proc_7 (Int_1_Par_Val, Int_2_Par_Val, Int_Par_Ref) |
/**********************************************/ |
/* executed three times */ |
/* first call: Int_1_Par_Val == 2, Int_2_Par_Val == 3, */ |
/* Int_Par_Ref becomes 7 */ |
/* second call: Int_1_Par_Val == 10, Int_2_Par_Val == 5, */ |
/* Int_Par_Ref becomes 17 */ |
/* third call: Int_1_Par_Val == 6, Int_2_Par_Val == 10, */ |
/* Int_Par_Ref becomes 18 */ |
One_Fifty Int_1_Par_Val; |
One_Fifty Int_2_Par_Val; |
One_Fifty *Int_Par_Ref; |
{ |
One_Fifty Int_Loc; |
|
Int_Loc = Int_1_Par_Val + 2; |
*Int_Par_Ref = Int_2_Par_Val + Int_Loc; |
} /* Proc_7 */ |
|
|
Proc_8 (Arr_1_Par_Ref, Arr_2_Par_Ref, Int_1_Par_Val, Int_2_Par_Val) |
/*********************************************************************/ |
/* executed once */ |
/* Int_Par_Val_1 == 3 */ |
/* Int_Par_Val_2 == 7 */ |
Arr_1_Dim Arr_1_Par_Ref; |
Arr_2_Dim Arr_2_Par_Ref; |
int Int_1_Par_Val; |
int Int_2_Par_Val; |
{ |
REG One_Fifty Int_Index; |
REG One_Fifty Int_Loc; |
|
Int_Loc = Int_1_Par_Val + 5; |
Arr_1_Par_Ref [Int_Loc] = Int_2_Par_Val; |
Arr_1_Par_Ref [Int_Loc+1] = Arr_1_Par_Ref [Int_Loc]; |
Arr_1_Par_Ref [Int_Loc+30] = Int_Loc; |
for (Int_Index = Int_Loc; Int_Index <= Int_Loc+1; ++Int_Index) |
Arr_2_Par_Ref [Int_Loc] [Int_Index] = Int_Loc; |
Arr_2_Par_Ref [Int_Loc] [Int_Loc-1] += 1; |
Arr_2_Par_Ref [Int_Loc+20] [Int_Loc] = Arr_1_Par_Ref [Int_Loc]; |
Int_Glob = 5; |
} /* Proc_8 */ |
|
|
Enumeration Func_1 (Ch_1_Par_Val, Ch_2_Par_Val) |
/*************************************************/ |
/* executed three times */ |
/* first call: Ch_1_Par_Val == 'H', Ch_2_Par_Val == 'R' */ |
/* second call: Ch_1_Par_Val == 'A', Ch_2_Par_Val == 'C' */ |
/* third call: Ch_1_Par_Val == 'B', Ch_2_Par_Val == 'C' */ |
|
Capital_Letter Ch_1_Par_Val; |
Capital_Letter Ch_2_Par_Val; |
{ |
Capital_Letter Ch_1_Loc; |
Capital_Letter Ch_2_Loc; |
|
Ch_1_Loc = Ch_1_Par_Val; |
Ch_2_Loc = Ch_1_Loc; |
if (Ch_2_Loc != Ch_2_Par_Val) |
/* then, executed */ |
return (Ident_1); |
else /* not executed */ |
{ |
Ch_1_Glob = Ch_1_Loc; |
return (Ident_2); |
} |
} /* Func_1 */ |
|
|
Boolean Func_2 (Str_1_Par_Ref, Str_2_Par_Ref) |
/*************************************************/ |
/* executed once */ |
/* Str_1_Par_Ref == "DHRYSTONE PROGRAM, 1'ST STRING" */ |
/* Str_2_Par_Ref == "DHRYSTONE PROGRAM, 2'ND STRING" */ |
|
Str_30 Str_1_Par_Ref; |
Str_30 Str_2_Par_Ref; |
{ |
REG One_Thirty Int_Loc; |
Capital_Letter Ch_Loc; |
|
Int_Loc = 2; |
while (Int_Loc <= 2) /* loop body executed once */ |
if (Func_1 (Str_1_Par_Ref[Int_Loc], |
Str_2_Par_Ref[Int_Loc+1]) == Ident_1) |
/* then, executed */ |
{ |
Ch_Loc = 'A'; |
Int_Loc += 1; |
} /* if, while */ |
if (Ch_Loc >= 'W' && Ch_Loc < 'Z') |
/* then, not executed */ |
Int_Loc = 7; |
if (Ch_Loc == 'R') |
/* then, not executed */ |
return (true); |
else /* executed */ |
{ |
if (strcmp (Str_1_Par_Ref, Str_2_Par_Ref) > 0) |
/* then, not executed */ |
{ |
Int_Loc += 7; |
Int_Glob = Int_Loc; |
return (true); |
} |
else /* executed */ |
return (false); |
} /* if Ch_Loc */ |
} /* Func_2 */ |
|
|
Boolean Func_3 (Enum_Par_Val) |
/***************************/ |
/* executed once */ |
/* Enum_Par_Val == Ident_3 */ |
Enumeration Enum_Par_Val; |
{ |
Enumeration Enum_Loc; |
|
Enum_Loc = Enum_Par_Val; |
if (Enum_Loc == Ident_3) |
/* then, executed */ |
return (true); |
else /* not executed */ |
return (false); |
} /* Func_3 */ |
|
/arm-isr.c
0,0 → 1,51
extern void abort (); |
extern void exit (int); |
|
#ifndef __thumb__ |
/* There used to be a couple of bugs in the ARM's prologue and epilogue |
generation for ISR routines. The wrong epilogue instruction would be |
generated to restore the IP register if it had to be pushed onto the |
stack, and the wrong offset was being computed for local variables if |
r0 - r3 had to be saved. This tests for both of these cases. */ |
|
int z = 9; |
|
int |
bar (void) |
{ |
return z; |
} |
|
int |
foo (int a, int b, int c, int d, int e, int f, int g, int h) |
{ |
volatile int i = (a + b) - (g + h) + bar (); |
volatile int j = (e + f) - (c + d); |
|
return a + b + c + d + e + f + g + h + i + j; |
} |
|
int foo1 (int a, int b, int c, int d, int e, int f, int g, int h) __attribute__ ((interrupt ("IRQ"))); |
|
int |
foo1 (int a, int b, int c, int d, int e, int f, int g, int h) |
{ |
volatile int i = (a + b) - (g + h) + bar (); |
volatile int j = (e + f) - (c + d); |
|
return a + b + c + d + e + f + g + h + i + j; |
} |
#endif |
|
int |
main (void) |
{ |
#ifndef __thumb__ |
if (foo (1, 2, 3, 4, 5, 6, 7, 8) != 32) |
abort (); |
|
if (foo1 (1, 2, 3, 4, 5, 6, 7, 8) != 32) |
abort (); |
#endif |
exit (0); |
} |
/dhry.h
0,0 → 1,433
/* |
**************************************************************************** |
* |
* "DHRYSTONE" Benchmark Program |
* ----------------------------- |
* |
* Version: C, Version 2.1 |
* |
* File: dhry.h (part 1 of 3) |
* |
* Date: May 25, 1988 |
* |
* Author: Reinhold P. Weicker |
* Siemens AG, AUT E 51 |
* Postfach 3220 |
* 8520 Erlangen |
* Germany (West) |
* Phone: [+49]-9131-7-20330 |
* (8-17 Central European Time) |
* Usenet: ..!mcsun!unido!estevax!weicker |
* |
* Original Version (in Ada) published in |
* "Communications of the ACM" vol. 27., no. 10 (Oct. 1984), |
* pp. 1013 - 1030, together with the statistics |
* on which the distribution of statements etc. is based. |
* |
* In this C version, the following C library functions are used: |
* - strcpy, strcmp (inside the measurement loop) |
* - printf, scanf (outside the measurement loop) |
* In addition, Berkeley UNIX system calls "times ()" or "time ()" |
* are used for execution time measurement. For measurements |
* on other systems, these calls have to be changed. |
* |
* Collection of Results: |
* Reinhold Weicker (address see above) and |
* |
* Rick Richardson |
* PC Research. Inc. |
* 94 Apple Orchard Drive |
* Tinton Falls, NJ 07724 |
* Phone: (201) 389-8963 (9-17 EST) |
* Usenet: ...!uunet!pcrat!rick |
* |
* Please send results to Rick Richardson and/or Reinhold Weicker. |
* Complete information should be given on hardware and software used. |
* Hardware information includes: Machine type, CPU, type and size |
* of caches; for microprocessors: clock frequency, memory speed |
* (number of wait states). |
* Software information includes: Compiler (and runtime library) |
* manufacturer and version, compilation switches, OS version. |
* The Operating System version may give an indication about the |
* compiler; Dhrystone itself performs no OS calls in the measurement loop. |
* |
* The complete output generated by the program should be mailed |
* such that at least some checks for correctness can be made. |
* |
*************************************************************************** |
* |
* History: This version C/2.1 has been made for two reasons: |
* |
* 1) There is an obvious need for a common C version of |
* Dhrystone, since C is at present the most popular system |
* programming language for the class of processors |
* (microcomputers, minicomputers) where Dhrystone is used most. |
* There should be, as far as possible, only one C version of |
* Dhrystone such that results can be compared without |
* restrictions. In the past, the C versions distributed |
* by Rick Richardson (Version 1.1) and by Reinhold Weicker |
* had small (though not significant) differences. |
* |
* 2) As far as it is possible without changes to the Dhrystone |
* statistics, optimizing compilers should be prevented from |
* removing significant statements. |
* |
* This C version has been developed in cooperation with |
* Rick Richardson (Tinton Falls, NJ), it incorporates many |
* ideas from the "Version 1.1" distributed previously by |
* him over the UNIX network Usenet. |
* I also thank Chaim Benedelac (National Semiconductor), |
* David Ditzel (SUN), Earl Killian and John Mashey (MIPS), |
* Alan Smith and Rafael Saavedra-Barrera (UC at Berkeley) |
* for their help with comments on earlier versions of the |
* benchmark. |
* |
* Changes: In the initialization part, this version follows mostly |
* Rick Richardson's version distributed via Usenet, not the |
* version distributed earlier via floppy disk by Reinhold Weicker. |
* As a concession to older compilers, names have been made |
* unique within the first 8 characters. |
* Inside the measurement loop, this version follows the |
* version previously distributed by Reinhold Weicker. |
* |
* At several places in the benchmark, code has been added, |
* but within the measurement loop only in branches that |
* are not executed. The intention is that optimizing compilers |
* should be prevented from moving code out of the measurement |
* loop, or from removing code altogether. Since the statements |
* that are executed within the measurement loop have NOT been |
* changed, the numbers defining the "Dhrystone distribution" |
* (distribution of statements, operand types and locality) |
* still hold. Except for sophisticated optimizing compilers, |
* execution times for this version should be the same as |
* for previous versions. |
* |
* Since it has proven difficult to subtract the time for the |
* measurement loop overhead in a correct way, the loop check |
* has been made a part of the benchmark. This does have |
* an impact - though a very minor one - on the distribution |
* statistics which have been updated for this version. |
* |
* All changes within the measurement loop are described |
* and discussed in the companion paper "Rationale for |
* Dhrystone version 2". |
* |
* Because of the self-imposed limitation that the order and |
* distribution of the executed statements should not be |
* changed, there are still cases where optimizing compilers |
* may not generate code for some statements. To a certain |
* degree, this is unavoidable for small synthetic benchmarks. |
* Users of the benchmark are advised to check code listings |
* whether code is generated for all statements of Dhrystone. |
* |
* Version 2.1 is identical to version 2.0 distributed via |
* the UNIX network Usenet in March 1988 except that it corrects |
* some minor deficiencies that were found by users of version 2.0. |
* The only change within the measurement loop is that a |
* non-executed "else" part was added to the "if" statement in |
* Func_3, and a non-executed "else" part removed from Proc_3. |
* |
*************************************************************************** |
* |
* Defines: The following "Defines" are possible: |
* -DREG=register (default: Not defined) |
* As an approximation to what an average C programmer |
* might do, the "register" storage class is applied |
* (if enabled by -DREG=register) |
* - for local variables, if they are used (dynamically) |
* five or more times |
* - for parameters if they are used (dynamically) |
* six or more times |
* Note that an optimal "register" strategy is |
* compiler-dependent, and that "register" declarations |
* do not necessarily lead to faster execution. |
* -DNOSTRUCTASSIGN (default: Not defined) |
* Define if the C compiler does not support |
* assignment of structures. |
* -DNOENUMS (default: Not defined) |
* Define if the C compiler does not support |
* enumeration types. |
* -DTIMES (default) |
* -DTIME |
* The "times" function of UNIX (returning process times) |
* or the "time" function (returning wallclock time) |
* is used for measurement. |
* For single user machines, "time ()" is adequate. For |
* multi-user machines where you cannot get single-user |
* access, use the "times ()" function. If you have |
* neither, use a stopwatch in the dead of night. |
* "printf"s are provided marking the points "Start Timer" |
* and "Stop Timer". DO NOT use the UNIX "time(1)" |
* command, as this will measure the total time to |
* run this program, which will (erroneously) include |
* the time to allocate storage (malloc) and to perform |
* the initialization. |
* -DHZ=nnn |
* In Berkeley UNIX, the function "times" returns process |
* time in 1/HZ seconds, with HZ = 60 for most systems. |
* CHECK YOUR SYSTEM DESCRIPTION BEFORE YOU JUST APPLY |
* A VALUE. |
* |
*************************************************************************** |
* |
* Compilation model and measurement (IMPORTANT): |
* |
* This C version of Dhrystone consists of three files: |
* - dhry.h (this file, containing global definitions and comments) |
* - dhry_1.c (containing the code corresponding to Ada package Pack_1) |
* - dhry_2.c (containing the code corresponding to Ada package Pack_2) |
* |
* The following "ground rules" apply for measurements: |
* - Separate compilation |
* - No procedure merging |
* - Otherwise, compiler optimizations are allowed but should be indicated |
* - Default results are those without register declarations |
* See the companion paper "Rationale for Dhrystone Version 2" for a more |
* detailed discussion of these ground rules. |
* |
* For 16-Bit processors (e.g. 80186, 80286), times for all compilation |
* models ("small", "medium", "large" etc.) should be given if possible, |
* together with a definition of these models for the compiler system used. |
* |
************************************************************************** |
* |
* Dhrystone (C version) statistics: |
* |
* [Comment from the first distribution, updated for version 2. |
* Note that because of language differences, the numbers are slightly |
* different from the Ada version.] |
* |
* The following program contains statements of a high level programming |
* language (here: C) in a distribution considered representative: |
* |
* assignments 52 (51.0 %) |
* control statements 33 (32.4 %) |
* procedure, function calls 17 (16.7 %) |
* |
* 103 statements are dynamically executed. The program is balanced with |
* respect to the three aspects: |
* |
* - statement type |
* - operand type |
* - operand locality |
* operand global, local, parameter, or constant. |
* |
* The combination of these three aspects is balanced only approximately. |
* |
* 1. Statement Type: |
* ----------------- number |
* |
* V1 = V2 9 |
* (incl. V1 = F(..) |
* V = Constant 12 |
* Assignment, 7 |
* with array element |
* Assignment, 6 |
* with record component |
* -- |
* 34 34 |
* |
* X = Y +|-|"&&"|"|" Z 5 |
* X = Y +|-|"==" Constant 6 |
* X = X +|- 1 3 |
* X = Y *|/ Z 2 |
* X = Expression, 1 |
* two operators |
* X = Expression, 1 |
* three operators |
* -- |
* 18 18 |
* |
* if .... 14 |
* with "else" 7 |
* without "else" 7 |
* executed 3 |
* not executed 4 |
* for ... 7 | counted every time |
* while ... 4 | the loop condition |
* do ... while 1 | is evaluated |
* switch ... 1 |
* break 1 |
* declaration with 1 |
* initialization |
* -- |
* 34 34 |
* |
* P (...) procedure call 11 |
* user procedure 10 |
* library procedure 1 |
* X = F (...) |
* function call 6 |
* user function 5 |
* library function 1 |
* -- |
* 17 17 |
* --- |
* 103 |
* |
* The average number of parameters in procedure or function calls |
* is 1.82 (not counting the function values as implicit parameters). |
* |
* |
* 2. Operators |
* ------------ |
* number approximate |
* percentage |
* |
* Arithmetic 32 50.8 |
* |
* + 21 33.3 |
* - 7 11.1 |
* * 3 4.8 |
* / (int div) 1 1.6 |
* |
* Comparison 27 42.8 |
* |
* == 9 14.3 |
* /= 4 6.3 |
* > 1 1.6 |
* < 3 4.8 |
* >= 1 1.6 |
* <= 9 14.3 |
* |
* Logic 4 6.3 |
* |
* && (AND-THEN) 1 1.6 |
* | (OR) 1 1.6 |
* ! (NOT) 2 3.2 |
* |
* -- ----- |
* 63 100.1 |
* |
* |
* 3. Operand Type (counted once per operand reference): |
* --------------- |
* number approximate |
* percentage |
* |
* Integer 175 72.3 % |
* Character 45 18.6 % |
* Pointer 12 5.0 % |
* String30 6 2.5 % |
* Array 2 0.8 % |
* Record 2 0.8 % |
* --- ------- |
* 242 100.0 % |
* |
* When there is an access path leading to the final operand (e.g. a record |
* component), only the final data type on the access path is counted. |
* |
* |
* 4. Operand Locality: |
* ------------------- |
* number approximate |
* percentage |
* |
* local variable 114 47.1 % |
* global variable 22 9.1 % |
* parameter 45 18.6 % |
* value 23 9.5 % |
* reference 22 9.1 % |
* function result 6 2.5 % |
* constant 55 22.7 % |
* --- ------- |
* 242 100.0 % |
* |
* |
* The program does not compute anything meaningful, but it is syntactically |
* and semantically correct. All variables have a value assigned to them |
* before they are used as a source operand. |
* |
* There has been no explicit effort to account for the effects of a |
* cache, or to balance the use of long or short displacements for code or |
* data. |
* |
*************************************************************************** |
*/ |
|
/* Compiler and system dependent definitions: */ |
/* |
#ifndef TIME |
#define TIMES |
#endif |
*/ /* Use times(2) time function unless */ |
/* explicitly defined otherwise */ |
|
/* |
#ifndef HZ |
#define HZ 60 |
#endif |
*/ |
|
/* |
#ifdef TIMES |
#include <sys/types.h> |
#include <sys/times.h> |
*/ /* for "times" */ |
/* |
#endif |
*/ |
#define Mic_secs_Per_Second 1000000.0 |
/* Berkeley UNIX C returns process times in seconds/HZ */ |
|
#ifdef NOSTRUCTASSIGN |
#define structassign(d, s) memcpy(&(d), &(s), sizeof(d)) |
#else |
#define structassign(d, s) d = s |
#endif |
|
#ifdef NOENUM |
#define Ident_1 0 |
#define Ident_2 1 |
#define Ident_3 2 |
#define Ident_4 3 |
#define Ident_5 4 |
typedef int Enumeration; |
#else |
typedef enum {Ident_1, Ident_2, Ident_3, Ident_4, Ident_5} |
Enumeration; |
#endif |
/* for boolean and enumeration types in Ada, Pascal */ |
|
/* General definitions: */ |
|
#include <stdio.h> |
#include <stdlib.h> |
#include <string.h> |
/* for strcpy, strcmp */ |
|
#define Null 0 |
/* Value of a Null pointer */ |
#define true 1 |
#define false 0 |
|
typedef int One_Thirty; |
typedef int One_Fifty; |
typedef char Capital_Letter; |
typedef int Boolean; |
typedef char Str_30 [31]; |
typedef int Arr_1_Dim [50]; |
typedef int Arr_2_Dim [50] [50]; |
|
typedef struct record |
{ |
struct record *Ptr_Comp; |
Enumeration Discr; |
union { |
struct { |
Enumeration Enum_Comp; |
int Int_Comp; |
char Str_Comp [31]; |
} var_1; |
struct { |
Enumeration E_Comp_2; |
char Str_2_Comp [31]; |
} var_2; |
struct { |
char Ch_1_Comp; |
char Ch_2_Comp; |
} var_3; |
} variant; |
} Rec_Type, *Rec_Pointer; |
|
|
/sieve.c
0,0 → 1,26
|
#define TRUE 1 |
#define FALSE 0 |
#define SIZE 8190 |
|
char flags[SIZE+1]; |
|
main() |
{ |
register int i, prime, k, count, iter; |
for (iter=1;iter<=100;iter++) { |
count=0; |
for (i=0;i<=SIZE;i++) |
flags[i]=TRUE; |
for (i=0;i<=SIZE;i++) { |
if (flags[i]) { |
prime=i+i+3; |
for (k=i+prime;k<=SIZE;k+=prime) |
flags[k]=FALSE; |
count++; |
} |
} |
} |
return 0; |
} |
|
/gcov-10.c
0,0 → 1,15
/* Test gcov block mode. */ |
|
/* { dg-options "-fprofile-arcs -ftest-coverage" } */ |
/* { dg-do run { target native } } */ |
|
int main () |
{ |
unsigned ix, jx = 0; |
|
for (ix = 10; ix--;) if (ix & 1) jx++; /* count(11) */ |
|
return jx != 5; |
} |
|
/* { dg-final { run-gcov { -a gcov-10.c } } } */ |
/gcov-11.c
0,0 → 1,23
/* Test gcov block mode. */ |
|
/* { dg-options "-fprofile-arcs -ftest-coverage" } */ |
/* { dg-do run { target native } } */ |
|
int one = 1; /* subvert constant folder. */ |
int zero = 0; |
|
int foo (int ix) |
{ |
return ix & 1 ? one : zero; /* count(10) */ |
} |
|
int main () |
{ |
unsigned ix, jx = 0; |
|
for (ix = 10; ix--;) jx += foo (ix); /* count(11) */ |
|
return jx != 5; |
} |
|
/* { dg-final { run-gcov { -a gcov-11.c } } } */ |
/i386-pf-athlon-1.c
0,0 → 1,31
/* Test that the correct data prefetch instructions are generated for i386 |
variants that use 3DNow! prefetchw or SSE prefetch instructions with |
locality hints. */ |
|
/* { dg-do compile { target { { i?86-*-* x86_64-*-* } && ia32 } } } */ |
|
extern void exit (int); |
|
char *msg = "howdy there"; |
|
void foo (char *p) |
{ |
__builtin_prefetch (p, 0, 0); |
__builtin_prefetch (p, 0, 1); |
__builtin_prefetch (p, 0, 2); |
__builtin_prefetch (p, 0, 3); |
__builtin_prefetch (p, 1, 0); |
__builtin_prefetch (p, 1, 1); |
__builtin_prefetch (p, 1, 2); |
__builtin_prefetch (p, 1, 3); |
} |
|
int main () |
{ |
foo (msg); |
exit (0); |
} |
|
/* { dg-final { scan-assembler "prefetchw" } } */ |
/* { dg-final { scan-assembler "prefetchnta" } } */ |
/* { dg-final { scan-assembler "prefetcht" } } */ |
/gcov-10b.c
0,0 → 1,16
/* Test gcov block mode. */ |
|
/* { dg-options "-fprofile-arcs -ftest-coverage" } */ |
/* { dg-do run { target native } } */ |
|
int main () |
{ |
unsigned ix, jx = 0; |
|
ix = 10; goto test; loop: ; if (ix & 1) jx++; test: ; if (ix--) goto loop; /* count(11) */ |
|
return jx != 5; |
} |
|
/* { dg-final { run-gcov { -a gcov-10b.c } } } */ |
|
/gcov-12.c
0,0 → 1,17
/* Test gcov weak ellision. */ |
|
/* { dg-options "-fprofile-arcs -ftest-coverage" } */ |
/* { dg-require-weak "" } */ |
/* { dg-do run { target native } } */ |
|
int __attribute__ ((weak)) weak () |
{ |
return 0; /* count(1) */ |
} |
|
int main () |
{ |
return weak (); /* count(1) */ |
} |
|
/* { dg-final { run-gcov { -a gcov-12.c } } } */ |
/gcov-13.c
0,0 → 1,20
/* Test gcov weak ellision. */ |
|
/* { dg-options "-fprofile-arcs -ftest-coverage" } */ |
/* { dg-require-weak "" } */ |
/* { dg-do run { target native } } */ |
/* { dg-additional-sources "gcovpart-13b.c" } */ |
/* { dg-skip-if "weak ellision not supported" { { hppa*-*-hpux* } && { ! lp64 } } { "*" } { "" } } */ |
|
int __attribute__ ((weak)) weak () |
{ |
return 1; /* count(-) { xfail *-*-* } */ |
} |
|
int main () |
{ |
return weak (); /* count(1) */ |
} |
|
/* { dg-final { run-gcov { -a gcov-13.c } { xfail *-*-* } } } */ |
/* { dg-final { run-gcov { -a gcovpart-13b.c } } } */ |
/linkage-x.c
0,0 → 1,3
/* 920717-1.c */ |
|
const char s[]="foo"; |
/gcov-14.c
0,0 → 1,28
/* Test gcov extern inline. */ |
|
/* { dg-options "-O2 -fprofile-arcs -ftest-coverage" } */ |
/* The following line arranges that Darwin has behavior like elf weak import. */ |
/* { dg-additional-options "-flat_namespace -undefined suppress" { target *-*-darwin* } } */ |
/* { dg-require-weak "" } */ |
/* { dg-do run { target native } } */ |
/* { dg-skip-if "undefined weak not supported" { alpha*-dec-osf* } } */ |
/* { dg-skip-if "undefined weak not supported" { { hppa*-*-hpux* } && { ! lp64 } } } */ |
|
extern int __attribute__ ((weak)) Foo (); |
|
extern __inline int Foo () |
{ |
return 0; /* count(-) */ |
} |
|
int (* __attribute__ ((noinline)) Bar ()) () |
{ |
return Foo; /* count(1) */ |
} |
|
int main () |
{ |
return Bar () != 0; /* count(1) */ |
} |
|
/* { dg-final { run-gcov { -a gcov-14.c } } } */ |
/linkage-y.c
0,0 → 1,8
/* 920717-y.c */ |
|
extern const char s[]; |
|
main() |
{ |
puts(s); |
} |
/gcov-15.c
0,0 → 1,30
/* Test gcov multiple paths to file. */ |
|
/* { dg-options "-fprofile-arcs -ftest-coverage" } */ |
/* { dg-do run { target native } } */ |
|
#if !RECURSIVE |
#define RECURSIVE 1 |
#include "./gcov-15.c" |
#undef RECURSIVE |
#endif |
|
static void __attribute__ ((noinline)) Recursive (void); |
|
|
#if RECURSIVE |
static void __attribute__ ((noinline)) |
Recursive () |
{ |
return; /* count(1) */ |
} |
|
#else |
int main () |
{ |
Recursive (); /* count(1) */ |
return 0; |
} |
#endif |
|
/* { dg-final { run-gcov { -a gcov-15.c } } } */ |
/i386-pf-3dnow-1.c
0,0 → 1,31
/* Test that the correct data prefetch instructions are generated for i386 |
variants that use 3DNow! prefetch instructions. */ |
|
/* { dg-do compile { target { { i?86-*-* x86_64-*-* } && ia32 } } } */ |
|
extern void exit (int); |
|
char *msg = "howdy there"; |
|
void foo (char *p) |
{ |
__builtin_prefetch (p, 0, 0); |
__builtin_prefetch (p, 0, 1); |
__builtin_prefetch (p, 0, 2); |
__builtin_prefetch (p, 0, 3); |
__builtin_prefetch (p, 1, 0); |
__builtin_prefetch (p, 1, 1); |
__builtin_prefetch (p, 1, 2); |
__builtin_prefetch (p, 1, 3); |
} |
|
int main () |
{ |
foo (msg); |
exit (0); |
} |
|
/* { dg-final { scan-assembler "prefetch" } } */ |
/* { dg-final { scan-assembler "prefetchw" } } */ |
/* { dg-final { scan-assembler-not "prefetchnta" } } */ |
/* { dg-final { scan-assembler-not "prefetcht" } } */ |
/sort2.exp
0,0 → 1,28
# Copyright (C) 1997, 2007 Free Software Foundation, Inc. |
|
# This program is free software; you can redistribute it and/or modify |
# it under the terms of the GNU General Public License as published by |
# the Free Software Foundation; either version 3 of the License, or |
# (at your option) any later version. |
# |
# This program is distributed in the hope that it will be useful, |
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
# GNU General Public License for more details. |
# |
# You should have received a copy of the GNU General Public License |
# along with GCC; see the file COPYING3. If not see |
# <http://www.gnu.org/licenses/>. |
|
global PERF_TEST |
if { ![info exists PERF_TEST] || "$PERF_TEST" != "yes" } { |
return |
} |
|
load_lib mike-gcc.exp |
|
prebase |
set actions run |
set compiler_output "^$" |
set program_output "^$" |
postbase sort2.c $run $groups |
/matrix1.exp
0,0 → 1,28
# Copyright (C) 1997, 2007 Free Software Foundation, Inc. |
|
# This program is free software; you can redistribute it and/or modify |
# it under the terms of the GNU General Public License as published by |
# the Free Software Foundation; either version 3 of the License, or |
# (at your option) any later version. |
# |
# This program is distributed in the hope that it will be useful, |
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
# GNU General Public License for more details. |
# |
# You should have received a copy of the GNU General Public License |
# along with GCC; see the file COPYING3. If not see |
# <http://www.gnu.org/licenses/>. |
|
global PERF_TEST |
if { ![info exists PERF_TEST] || "$PERF_TEST" != "yes" } { |
return |
} |
|
load_lib mike-gcc.exp |
|
prebase |
set actions run |
set compiler_output "^$" |
set program_output "^$" |
postbase matrix1.c $run $groups |
/gcov-4b.c
0,0 → 1,263
/* Check that execution counts for various C constructs are reported |
correctly by gcov. */ |
|
/* { dg-options "-fprofile-arcs -ftest-coverage" } */ |
/* { dg-do run { target native } } */ |
|
extern void abort (void); |
|
int do_something (int i) |
{ |
return i; |
} |
|
/* Check for loops. */ |
|
int for_val1; |
int for_val2; |
int for_temp; |
|
int |
test_for1 (int n) |
{ |
int i; |
for_temp = 1; |
for (i = 0; i < n; i++) /* branch(25) */ |
/* branch(end) */ |
for_temp++; |
return for_temp; |
} |
|
int |
test_for2 (int m, int n, int o) |
{ |
int i, j, k; |
for_temp = 1; |
for (i = 0; i < n; i++) /* branch(30) */ |
/* branch(end) */ |
for (j = 0; j < m; j++) /* branch(32) */ |
/* branch(end) */ |
for (k = 0; k < o; k++) /* branch(27) */ |
/* branch(end) */ |
for_temp++; |
return for_temp; |
} |
|
void |
call_for () |
{ |
for_val1 += test_for1 (0); |
for_val1 += test_for1 (2); |
for_val1 += test_for1 (7); |
|
for_val2 += test_for2 (0, 0, 0); |
for_val2 += test_for2 (1, 0, 0); |
for_val2 += test_for2 (1, 3, 0); |
for_val2 += test_for2 (1, 3, 1); |
for_val2 += test_for2 (3, 1, 5); |
for_val2 += test_for2 (3, 7, 3); |
} |
|
/* Check the use of goto. */ |
|
int goto_val; |
|
int |
test_goto1 (int f) |
{ |
if (f) /* branch(50) */ |
/* branch(end) */ |
goto lab1; |
return 1; |
lab1: |
return 2; |
} |
|
int |
test_goto2 (int f) |
{ |
int i; |
for (i = 0; i < 10; i++) /* branch(7) */ |
/* branch(end) */ |
if (i == f) goto lab2; |
return 4; |
lab2: |
return 8; |
} |
|
void |
call_goto () |
{ |
goto_val += test_goto1 (0); |
goto_val += test_goto1 (1); |
goto_val += test_goto2 (3); |
goto_val += test_goto2 (30); |
} |
|
/* Check nested if-then-else statements. */ |
|
int ifelse_val1; |
int ifelse_val2; |
int ifelse_val3; |
|
int |
test_ifelse1 (int i, int j) |
{ |
int result = 0; |
if (i) /* branch(40) */ |
/* branch(end) */ |
if (j) /* branch(0) */ |
/* branch(end) */ |
result = do_something (4); |
else |
result = do_something (1024); |
else |
if (j) /* branch(50) */ |
/* branch(end) */ |
result = do_something (1); |
else |
result = do_something (2); |
if (i > j) /* branch(80) */ |
/* branch(end) */ |
result = do_something (result*2); |
if (i > 10) /* branch(80) */ |
/* branch(end) */ |
if (j > 10) /* branch(100) */ |
result = do_something (result*4); |
return result; |
} |
|
int |
test_ifelse2 (int i) |
{ |
int result = 0; |
if (!i) /* branch(83) */ |
/* branch(end) */ |
result = do_something (1); |
if (i == 1) /* branch(100) */ |
/* branch(end) */ |
result = do_something (1024); |
if (i == 2) /* branch(50) */ |
/* branch(end) */ |
result = do_something (2); |
if (i == 3) /* branch(67) */ |
/* branch(end) */ |
return do_something (8); |
if (i == 4) /* branch(100) */ |
/* branch(end) */ |
return do_something (2048); |
return result; |
} |
|
int |
test_ifelse3 (int i, int j) |
{ |
int result = 1; |
if (i > 10 && j > i && j < 20) /* branch(27 50 75) */ |
/* branch(end) */ |
result = do_something (16); |
if (i > 20) /* branch(55) */ |
/* branch(end) */ |
if (j > i) /* branch(60) */ |
/* branch(end) */ |
if (j < 30) /* branch(50) */ |
/* branch(end) */ |
result = do_something (32); |
if (i == 3 || j == 47 || i == j) /* branch(9 10 89) */ |
/* branch(end) */ |
result = do_something (64); |
return result; |
} |
|
void |
call_ifelse () |
{ |
ifelse_val1 += test_ifelse1 (0, 2); |
ifelse_val1 += test_ifelse1 (0, 0); |
ifelse_val1 += test_ifelse1 (1, 2); |
ifelse_val1 += test_ifelse1 (10, 2); |
ifelse_val1 += test_ifelse1 (11, 11); |
|
ifelse_val2 += test_ifelse2 (0); |
ifelse_val2 += test_ifelse2 (2); |
ifelse_val2 += test_ifelse2 (2); |
ifelse_val2 += test_ifelse2 (2); |
ifelse_val2 += test_ifelse2 (3); |
ifelse_val2 += test_ifelse2 (3); |
|
ifelse_val3 += test_ifelse3 (11, 19); |
ifelse_val3 += test_ifelse3 (25, 27); |
ifelse_val3 += test_ifelse3 (11, 22); |
ifelse_val3 += test_ifelse3 (11, 10); |
ifelse_val3 += test_ifelse3 (21, 32); |
ifelse_val3 += test_ifelse3 (21, 20); |
ifelse_val3 += test_ifelse3 (1, 2); |
ifelse_val3 += test_ifelse3 (32, 31); |
ifelse_val3 += test_ifelse3 (3, 0); |
ifelse_val3 += test_ifelse3 (0, 47); |
ifelse_val3 += test_ifelse3 (65, 65); |
} |
|
/* Check switch statements. */ |
|
int switch_val, switch_m; |
|
int |
test_switch (int i, int j) |
{ |
int result = 0; |
|
switch (i) /* branch(20 0 60 20) */ |
/* branch(end) */ |
{ |
case 1: |
result = do_something (2); |
break; |
case 2: |
result = do_something (1024); |
break; |
case 3: |
case 4: |
if (j == 2) /* branch(67) */ |
/* branch(end) */ |
return do_something (4); |
result = do_something (8); |
break; |
default: |
result = do_something (32); |
switch_m++; |
break; |
} |
return result; |
} |
|
void |
call_switch () |
{ |
switch_val += test_switch (1, 0); |
switch_val += test_switch (3, 0); |
switch_val += test_switch (3, 2); |
switch_val += test_switch (4, 0); |
switch_val += test_switch (16, 0); |
switch_val += switch_m; |
} |
|
int |
main() |
{ |
call_for (); |
call_goto (); |
call_ifelse (); |
call_switch (); |
if ((for_val1 != 12) |
|| (for_val2 != 87) |
|| (goto_val != 15) |
|| (ifelse_val1 != 31) |
|| (ifelse_val2 != 23) |
|| (ifelse_val3 != 246) |
|| (switch_val != 55)) |
abort (); |
return 0; |
} |
|
/* { dg-final { run-gcov branches { -b gcov-4b.c } } } */ |
/help.exp
0,0 → 1,80
# Copyright (C) 2005, 2007, 2009 Free Software Foundation, Inc. |
|
# This program is free software; you can redistribute it and/or modify |
# it under the terms of the GNU General Public License as published by |
# the Free Software Foundation; either version 3 of the License, or |
# (at your option) any later version. |
# |
# This program is distributed in the hope that it will be useful, |
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
# GNU General Public License for more details. |
# |
# You should have received a copy of the GNU General Public License |
# along with GCC; see the file COPYING3. If not see |
# <http://www.gnu.org/licenses/>. |
|
# This file contains a set of test that check that gcc options are |
# documented in --help, and that the various --help* options work. |
|
load_lib options.exp |
|
# Document --version. Ideally, there should be no undocumented switches |
# in --help. |
check_for_options c "--help" "--version" "This switch lacks documentation" "" |
|
# Output from different subprocesses should not be intermingled |
# (we check for some patterns that could be seen with a missing |
# fflush in gcc.c). |
check_for_options c "-v --help" "" { |
[^\n]The following options |
-Wconversion[^\n]*lacks documentation |
" -g " |
} "" |
|
# There are still undocumented switches in -v --help. |
check_for_options c "-v --help" "" "This switch lacks documentation" "xfail" |
|
# Check whether multiline conversion in optc-gen is broken. |
check_for_options c "-v --help" "" {are likely to\n -std} "" |
|
# Try various --help= classes and qualifiers. |
check_for_options c "--help=optimizers" "-O" " -g " "" |
check_for_options c "--help=params" "maximum number of" "-Wunsafe-loop-optimizations" "" |
check_for_options c "--help=C" "-ansi" "-gnatO" "" |
check_for_options c {--help=C++} {-std=c\+\+} "-gnatO" "" |
check_for_options c "--help=common" "-dumpbase" "-gnatO" "" |
check_for_options c "--help=undocumented" "This switch lacks documentation" "" "" |
|
# Undocumented flags are not yet consistently marked as such. |
check_for_options c "--help=^undocumented" "-Wall" "This switch lacks documentation" "xfail" |
|
# Try some --help=* examples from the manual. |
check_for_options c "--help=target,undocumented" "" "" "" |
check_for_options c "--help=target,optimizers" "" "" "" |
check_for_options c "--help=warnings,^joined,^undocumented" "" "" "" |
check_for_options c "-Q -O2 --help=optimizers" { |
-O |
-ftree-vectorize[^\n]*disabled |
} " -g " "" |
check_for_options c "-Q -O3 --help=optimizers" { |
-O |
-ftree-vectorize[^\n]*enabled |
} " -g " "" |
# Try repeated --help=. |
check_for_options c "--help=params --help=optimizers" { |
maximum number of |
-O |
} "" "" |
|
# Ensure PR 37805 is fixed. |
check_for_options c "--help=joined" "Wformat=" "-fstrict-prototype" "" |
check_for_options c "--help=separate" "-MF" "-fstrict-prototype" "" |
check_for_options c "--help=warnings,joined" "Wformat=" "Wtrigraphs" "" |
check_for_options c "--help=warnings,^joined" "Wtrigraphs" "Wformat=" "" |
check_for_options c "--help=joined,separate" "-I" "" "" |
check_for_options c "--help=^joined,separate" "--param " "" "" |
check_for_options c "--help=joined,^separate" "--help=" "" "" |
check_for_options c "--help=joined,undocumented" "" "" "" |
# Listing only excludes gives empty results. |
check_for_options c "--help=^joined,^separate" "" "" "" |
/dectest.exp
0,0 → 1,527
# Copyright 2005, 2006, 2007, 2008 Free Software Foundation, Inc. |
|
# This program is free software; you can redistribute it and/or modify |
# it under the terms of the GNU General Public License as published by |
# the Free Software Foundation; either version 3 of the License, or |
# (at your option) any later version. |
# |
# This program is distributed in the hope that it will be useful, |
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
# GNU General Public License for more details. |
# |
# You should have received a copy of the GNU General Public License |
# along with GCC; see the file COPYING3. If not see |
# <http://www.gnu.org/licenses/>. |
|
# DejaGnu test driver around Mike Cowlishaw's testsuite for decimal |
# decimal arithmetic ("decTest"). See: |
# <http://www2.hursley.ibm.com/decimal/dectest.html>. |
# |
# Contributed by Ben Elliston <bje@au.ibm.com>. |
|
set DEC_TORTURE_OPTIONS [list {} -O1 -O2 -O3 -Os -msoft-float] |
|
proc target-specific-flags {} { |
set result "-frounding-math " |
return $result |
} |
|
# Load support procs (borrow these from c-torture). |
load_lib c-torture.exp |
load_lib target-supports.exp |
load_lib torture-options.exp |
|
# Skip these tests for targets that don't support this extension. |
if { ![check_effective_target_dfp] } { |
return |
} |
|
# The list format is [coefficient, max-exponent, min-exponent]. |
set properties(_Decimal32) [list 7 96 -95] |
set properties(_Decimal64) [list 16 384 -383] |
set properties(_Decimal128) [list 34 6144 -6143] |
|
# Operations implemented by the compiler. |
set operators(add) {+} |
set operators(compare) {==} |
set operators(divide) {/} |
set operators(multiply) {*} |
set operators(subtract) {-} |
set operators(minus) {-} |
set operators(plus) {+} |
set operators(apply) {} |
|
# Operations imlemented by the library. |
set libfuncs(abs) fabsl |
set libfuncs(squareroot) sqrtl |
set libfuncs(max) fmaxl |
set libfuncs(min) fminl |
set libfuncs(quantize) quantize |
set libfuncs(samequantum) samequantum |
set libfuncs(power) powl |
set libfuncs(toSci) unknown |
set libfuncs(tosci) unknown |
set libfuncs(toEng) unknown |
set libfuncs(toeng) unknown |
set libfuncs(divideint) unknown |
set libfuncs(rescale) unknown |
set libfuncs(remainder) unknown |
set libfuncs(remaindernear) unknown |
set libfuncs(normalize) unknown |
set libfuncs(tointegral) unknown |
set libfuncs(trim) unknown |
|
# Run all of the tests listed in TESTCASES by invoking df-run-test on |
# each. Skip tests that not included by the user invoking runtest |
# with the foo.exp=test.c syntax. |
|
proc dfp-run-tests { testcases } { |
global runtests |
foreach test $testcases { |
# If we're only testing specific files and this isn't one of |
# them, skip it. |
if ![runtest_file_p $runtests $test] continue |
dfp-run-test $test |
} |
} |
|
# Run a single test case named by TESTCASE. |
# Called for each test by dfp-run-tests. |
|
proc dfp-run-test { testcase } { |
set fd [open $testcase r] |
while {[gets $fd line] != -1} { |
switch -regexp -- $line { |
{^[ \t]*--.*$} { |
# Ignore comments. |
} |
{^[ \t]*$} { |
# Ignore blank lines. |
} |
{^[ \t]*[^:]*:[^:]*} { |
regsub -- {[ \t]*--.*$} $line {} line |
process-directive $line |
} |
default { |
process-test-case $testcase $line |
} |
} |
} |
close $fd |
} |
|
# Return the appropriate constant from <fenv.h> for MODE. |
|
proc c-rounding-mode { mode } { |
switch [string tolower $mode] { |
"floor" { return 0 } # FE_DEC_DOWNWARD |
"half_even" { return 1 } # FE_DEC_TONEARESTFROMZERO |
"half_up" { return 2 } # FE_DEC_TONEAREST |
"down" { return 3 } # FE_DEC_TOWARDZERO |
"ceiling" { return 4 } # FE_DEC_UPWARD |
} |
error "unsupported rounding mode ($mode)" |
} |
|
# Return a string of C code that forms the preamble to perform the |
# test named ID. |
|
proc c-test-preamble { id } { |
append result "/* Machine generated test case for $id */\n" |
append result "\n" |
append result "\#include <assert.h>\n" |
append result "\#include <fenv.h>\n" |
append result "\#include <math.h>\n" |
append result "\n" |
append result "int main ()\n" |
append result "\{" |
return $result |
} |
|
# Return a string of C code that forms the postable to the test named ID. |
|
proc c-test-postamble { id } { |
return "\}" |
} |
|
# Generate a C unary expression that applies OPERATION to OP. |
|
proc c-unary-expression {operation op} { |
global operators |
global libfuncs |
if [catch {set result "$operators($operation) $op"}] { |
# If operation isn't in the operators or libfuncs arrays, |
# we'll throw an error. That's what we want. |
# FIXME: append d32, etc. here. |
set result "$libfuncs($operation) ($op)" |
} |
return $result |
} |
|
# Generate a C binary expression that applies OPERATION to OP1 and OP2. |
|
proc c-binary-expression {operation op1 op2} { |
global operators |
global libfuncs |
if [catch {set result "$op1 $operators($operation) $op2"}] { |
# If operation isn't in the operators or libfuncs arrays, |
# we'll throw an error. That's what we want. |
set result "$libfuncs($operation) ($op1, $op2)" |
} |
return $result |
} |
|
# Return the most appropriate C type (_Decimal32, etc) for this test. |
|
proc c-decimal-type { } { |
global directives |
if [catch {set precision $directives(precision)}] { |
set precision "_Decimal128" |
} |
if { $precision == 7 } { |
set result "_Decimal32" |
} elseif {$precision == 16} { |
set result "_Decimal64" |
} elseif {$precision == 34} { |
set result "_Decimal128" |
} else { |
error "Unsupported precision" |
} |
return $result |
} |
|
# Return the size of the most appropriate C type, in bytes. |
|
proc c-sizeof-decimal-type { } { |
switch [c-decimal-type] { |
"_Decimal32" { return 4 } |
"_Decimal64" { return 8 } |
"_Decimal128" { return 16 } |
} |
error "Unsupported precision" |
} |
|
# Return the right literal suffix for CTYPE. |
|
proc c-type-suffix { ctype } { |
switch $ctype { |
"_Decimal32" { return "df" } |
"_Decimal64" { return "dd" } |
"_Decimal128" { return "dl" } |
"float" { return "f" } |
"long double" { return "l" } |
} |
return "" |
} |
|
proc nan-p { operand } { |
if {[string match "NaN*" $operand] || [string match "-NaN*" $operand]} { |
return 1 |
} else { |
return 0 |
} |
} |
|
proc infinity-p { operand } { |
if {[string match "Inf*" $operand] || [string match "-Inf*" $operand]} { |
return 1 |
} else { |
return 0 |
} |
} |
|
proc isnan-builtin-name { } { |
set bits [expr [c-sizeof-decimal-type] * 8] |
return "__builtin_isnand$bits" |
} |
|
proc isinf-builtin-name { } { |
set bits [expr [c-sizeof-decimal-type] * 8] |
return "__builtin_isinfd$bits" |
} |
|
# Return a string that declares a C union containing the decimal type |
# and an unsigned char array of the right size. |
|
proc c-union-decl { } { |
append result " union {\n" |
append result " [c-decimal-type] d;\n" |
append result " unsigned char bytes\[[c-sizeof-decimal-type]\];\n" |
append result " } u;" |
return $result |
} |
|
proc transform-hex-constant {value} { |
regsub \# $value {} value |
regsub -all (\.\.) $value {0x\1, } bytes |
return [list $bytes] |
} |
|
# Create a C program file (named using ID) containing a test for a |
# binary OPERATION on OP1 and OP2 that expects RESULT and CONDITIONS. |
|
proc make-c-test {testcase id operation result conditions op1 {op2 "NONE"}} { |
global directives |
set filename ${id}.c |
set outfd [open $filename w] |
|
puts $outfd [c-test-preamble $id] |
puts $outfd [c-union-decl] |
if {[string compare $result ?] != 0} { |
if {[string index $result 0] == "\#"} { |
puts $outfd " static unsigned char compare\[[c-sizeof-decimal-type]\] = [transform-hex-constant $result];" |
} |
} |
if {[string compare $op2 NONE] == 0} { |
if {[string index $op1 0] == "\#"} { |
puts $outfd " static unsigned char fill\[[c-sizeof-decimal-type]\] = [transform-hex-constant $op1];" |
} |
} |
|
puts $outfd "" |
puts $outfd " /* FIXME: Set rounding mode with fesetround() once in libc. */" |
puts $outfd " __dfp_set_round ([c-rounding-mode $directives(rounding)]);" |
puts $outfd "" |
|
# Build the expression to be tested. |
if {[string compare $op2 NONE] == 0} { |
if {[string index $op1 0] == "\#"} { |
puts $outfd " memcpy (u.bytes, fill, [c-sizeof-decimal-type]);" |
} else { |
puts $outfd " u.d = [c-unary-expression $operation [c-operand $op1]];" |
} |
} else { |
puts $outfd " u.d = [c-binary-expression $operation [c-operand $op1] [c-operand $op2]];" |
} |
|
# Test the result. |
if {[string compare $result ?] != 0} { |
# Not an undefined result .. |
if {[string index $result 0] == "\#"} { |
# Handle hex comparisons. |
puts $outfd " return memcmp (u.bytes, compare, [c-sizeof-decimal-type]);" |
} elseif {[nan-p $result]} { |
puts $outfd " return ![isnan-builtin-name] (u.d);" |
} elseif {[infinity-p $result]} { |
puts $outfd " return ![isinf-builtin-name] (u.d);" |
} else { |
# Ordinary values. |
puts $outfd " return !(u.d == [c-operand $result]);" |
} |
} else { |
puts $outfd " return 0;" |
} |
|
puts $outfd [c-test-postamble $id] |
close $outfd |
return $filename |
} |
|
# Is the test supported for this target? |
|
proc supported-p { id op } { |
global directives |
global libfuncs |
|
# Ops that are unsupported. Many of these tests fail because they |
# do not tolerate the C front-end rounding the value of floating |
# point literals to suit the type of the constant. Otherwise, by |
# treating the `apply' operator like C assignment, some of them do |
# pass. |
switch -- $op { |
apply { return 0 } |
} |
|
# Ditto for the following miscellaneous tests. |
switch $id { |
addx1130 { return 0 } |
addx1131 { return 0 } |
addx1132 { return 0 } |
addx1133 { return 0 } |
addx1134 { return 0 } |
addx1135 { return 0 } |
addx1136 { return 0 } |
addx1138 { return 0 } |
addx1139 { return 0 } |
addx1140 { return 0 } |
addx1141 { return 0 } |
addx1142 { return 0 } |
addx1151 { return 0 } |
addx1152 { return 0 } |
addx1153 { return 0 } |
addx1154 { return 0 } |
addx1160 { return 0 } |
addx690 { return 0 } |
mulx263 { return 0 } |
subx947 { return 0 } |
} |
|
if [info exist libfuncs($op)] { |
# No library support for now. |
return 0 |
} |
if [catch {c-rounding-mode $directives(rounding)}] { |
# Unsupported rounding mode. |
return 0 |
} |
if [catch {c-decimal-type}] { |
# Unsupported precision. |
return 0 |
} |
return 1 |
} |
|
# Break LINE into a list of tokens. Be sensitive to quoting. |
# There has to be a better way to do this :-| |
|
proc tokenize { line } { |
set quoting 0 |
set tokens [list] |
|
foreach char [split $line {}] { |
if {!$quoting} { |
if { [info exists token] && $char == " " } { |
if {[string compare "$token" "--"] == 0} { |
# Only comments remain. |
return $tokens |
} |
lappend tokens $token |
unset token |
} else { |
if {![info exists token] && $char == "'" } { |
set quoting 1 |
} else { |
if { $char != " " } { |
append token $char |
} |
} |
} |
} else { |
# Quoting. |
if { $char == "'" } { |
set quoting 0 |
if [info exists token] { |
lappend tokens $token |
unset token |
} else { |
lappend tokens {} |
} |
} else { |
append token $char |
} |
} |
} |
# Flush any residual token. |
if {[info exists token] && [string compare $token "--"]} { |
lappend tokens $token |
} |
return $tokens |
} |
|
# Process a directive in LINE. |
|
proc process-directive { line } { |
global directives |
set keyword [string tolower [string trim [lindex [split $line :] 0]]] |
set value [string tolower [string trim [lindex [split $line :] 1]]] |
set directives($keyword) $value |
} |
|
# Produce a C99-valid floating point literal. |
|
proc c-operand {operand} { |
set bits [expr 8 * [c-sizeof-decimal-type]] |
|
switch -glob -- $operand { |
"Inf*" { return "__builtin_infd${bits} ()" } |
"-Inf*" { return "- __builtin_infd${bits} ()" } |
"NaN*" { return "__builtin_nand${bits} (\"\")" } |
"-NaN*" { return "- __builtin_nand${bits} (\"\")" } |
"sNaN*" { return "__builtin_nand${bits} (\"\")" } |
"-sNaN*" { return "- __builtin_nand${bits} (\"\")" } |
} |
|
if {[string first . $operand] < 0 && \ |
[string first E $operand] < 0 && \ |
[string first e $operand] < 0} { |
append operand . |
} |
set suffix [c-type-suffix [c-decimal-type]] |
return [append operand $suffix] |
} |
|
# Process an arithmetic test in LINE from TESTCASE. |
|
proc process-test-case { testcase line } { |
set testfile [file tail $testcase] |
|
# Compress multiple spaces down to one. |
regsub -all { *} $line { } line |
|
set args [tokenize $line] |
if {[llength $args] < 5} { |
error "Skipping invalid test: $line" |
return |
} |
|
set id [string trim [lindex $args 0]] |
set operation [string trim [lindex $args 1]] |
set operand1 [string trim [lindex $args 2]] |
|
if { [string compare [lindex $args 3] -> ] == 0 } { |
# Unary operation. |
set operand2 NONE |
set result_index 4 |
set cond_index 5 |
} else { |
# Binary operation. |
set operand2 [string trim [lindex $args 3]] |
if { [string compare [lindex $args 4] -> ] != 0 } { |
warning "Skipping invalid test: $line" |
return |
} |
set result_index 5 |
set cond_index 6 |
} |
|
set result [string trim [lindex $args $result_index]] |
set conditions [list] |
for { set i $cond_index } { $i < [llength $args] } { incr i } { |
lappend conditions [string tolower [lindex $args $i]] |
} |
|
# If this test is unsupported, say so. |
if ![supported-p $id $operation] { |
unsupported "$testfile ($id)" |
return |
} |
|
if {[string compare $operand1 \#] == 0 || \ |
[string compare $operand2 \#] == 0} { |
unsupported "$testfile ($id), null reference" |
return |
} |
|
# Construct a C program and then compile/execute it on the target. |
# Grab some stuff from the c-torture.exp test driver for this. |
|
set cprog [make-c-test $testfile $id $operation $result $conditions $operand1 $operand2] |
c-torture-execute $cprog [target-specific-flags] |
} |
|
### Script mainline: |
|
if [catch {set testdir $env(DECTEST)}] { |
# If $DECTEST is unset, skip this test driver altogether. |
return |
} |
|
torture-init |
set-torture-options $DEC_TORTURE_OPTIONS |
|
note "Using tests in $testdir" |
dfp-run-tests [lsort [glob -nocomplain $testdir/*.decTest]] |
unset testdir |
|
torture-finish |
/options.exp
0,0 → 1,54
# Copyright (C) 2005, 2007 Free Software Foundation, Inc. |
|
# This program is free software; you can redistribute it and/or modify |
# it under the terms of the GNU General Public License as published by |
# the Free Software Foundation; either version 3 of the License, or |
# (at your option) any later version. |
# |
# This program is distributed in the hope that it will be useful, |
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
# GNU General Public License for more details. |
# |
# You should have received a copy of the GNU General Public License |
# along with GCC; see the file COPYING3. If not see |
# <http://www.gnu.org/licenses/>. |
|
# Run the LANGUAGE compiler with GCC_OPTIONS and inspect the compiler, |
# assembler and linker output (from gcc -v) to make sure that they |
# match the patterns COMPILER_PATTERN, AS_PATTERN and LD_PATTERN, |
# respectively. |
|
proc check_for_all_options {language gcc_options compiler_pattern as_pattern ld_pattern} { |
set filename test-[pid] |
set fd [open $filename.c w] |
puts $fd "int main (void) \{ return 0; \}" |
close $fd |
remote_download host $filename.c |
|
set test "compiler driver $gcc_options option(s)" |
set gcc_options "\{additional_flags=$gcc_options -v\}" |
|
switch "$language" { |
"c" { set compiler cc1 } |
default { error "unknown language" } |
} |
set gcc_output [gcc_target_compile $filename.c $filename.x executable $gcc_options] |
remote_file build delete $filename.c $filename.x $filename.gcno |
|
if {![regexp -- "/${compiler}(\\.exe)? -quiet.*$compiler_pattern" $gcc_output]} { |
fail "$test (compiler options)" |
return |
} |
if {![regexp -- " *as(\\.exe)? .*$as_pattern" $gcc_output]} { |
fail "$test (assembler options)" |
return |
} |
if {![regexp -- "/collect2(\\.exe)? .*$ld_pattern" $gcc_output]} { |
fail "$test (linker options)" |
return |
} |
pass $test |
} |
|
check_for_all_options c {--coverage} {-fprofile-arcs -ftest-coverage} {} {-lgcov} |
/gcovpart-13b.c
0,0 → 1,4
int weak () |
{ |
return 0; /* count(1) */ |
} |
/gcov.exp
0,0 → 1,44
# Copyright (C) 1997, 2001, 2007 Free Software Foundation, Inc. |
|
# This program is free software; you can redistribute it and/or modify |
# it under the terms of the GNU General Public License as published by |
# the Free Software Foundation; either version 3 of the License, or |
# (at your option) any later version. |
# |
# This program is distributed in the hope that it will be useful, |
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
# GNU General Public License for more details. |
# |
# You should have received a copy of the GNU General Public License |
# along with GCC; see the file COPYING3. If not see |
# <http://www.gnu.org/licenses/>. |
|
# Gcov test driver. |
|
# Load support procs. |
load_lib gcc-dg.exp |
load_lib gcov.exp |
|
global GCC_UNDER_TEST |
|
# For now find gcov in the same directory as $GCC_UNDER_TEST. |
if { ![is_remote host] && [string match "*/*" [lindex $GCC_UNDER_TEST 0]] } { |
set GCOV [file dirname [lindex $GCC_UNDER_TEST 0]]/gcov |
} else { |
set GCOV gcov |
} |
|
# Initialize harness. |
dg-init |
|
# Delete old .gcda files. |
set files [glob -nocomplain gcov*.gcda] |
if { $files != "" } { |
eval "remote_file build delete $files" |
} |
|
# Main loop. |
dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/gcov-*.c]] "" "" |
|
dg-finish |
/sort2.c
0,0 → 1,54
/* Simple test program: bubble sort of a fixed table. */ |
/* This demonstrates some of the compiler's common-subexpression*/ |
/* elimination capabilities. For example, inspect the code */ |
/* generated for procedure Sort_array. See the Programmer's */ |
/* Guide for how to request an assembly listing on your host. */ |
|
typedef unsigned char boolean; |
|
void Sort_array(); |
int Tab[100]; |
|
main () { |
int I,J,K,L; |
|
for (L = 0; L < 1000; L++) { |
/* Initialize the table that will be sorted. */ |
K = 0; |
for (I = 9; I >= 0; I--) |
for (J = I*10; J < (I+1)*10; J++) |
Tab[K++] = J&1 ? J+1 : J-1; |
|
/* Print_array(); */ |
Sort_array(Tab,99); /* Sort it. */ |
/* Print_array(); */ |
} |
return 0; |
} |
|
void Sort_array(Tab,Last) int Tab[]; int Last; { |
boolean Swap; |
int Temp,I; |
do { |
Swap = 0; |
for (I = 0; I<Last; I++) |
if (Tab[I] > Tab[I+1]) { |
Temp = Tab[I]; |
Tab[I] = Tab[I+1]; |
Tab[I+1] = Temp; |
Swap = 1; |
} |
} |
while (Swap); |
} |
|
|
void Print_array() { |
int I,J; |
/*printf("\nArray Contents:\n");*/ |
for (I=0; I<=9; I++) { |
/*printf("%5d:",10*I); */ |
for (J=0; J<=9; J++); /*printf("%5d",Tab[10*I+J]); */ |
/* printf("\n");*/ |
} |
} |
/mg-2.exp
0,0 → 1,24
# Copyright (C) 2005, 2007 Free Software Foundation, Inc. |
|
# This program is free software; you can redistribute it and/or modify |
# it under the terms of the GNU General Public License as published by |
# the Free Software Foundation; either version 3 of the License, or |
# (at your option) any later version. |
# |
# This program is distributed in the hope that it will be useful, |
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
# GNU General Public License for more details. |
# |
# You should have received a copy of the GNU General Public License |
# along with GCC; see the file COPYING3. If not see |
# <http://www.gnu.org/licenses/>. |
|
# Test the -MG flag with a system header file. |
|
load_lib mike-gcc.exp |
|
prebase |
set actions none-of-the-above |
set compiler_output "mg-2.o ?: .*mg-2.c \[ \\\\\n\]*nonexist.h" |
postbase mg-2.c "" "" "-MM -MG" |
/mg.exp
0,0 → 1,24
# Copyright (C) 1997, 2007 Free Software Foundation, Inc. |
|
# This program is free software; you can redistribute it and/or modify |
# it under the terms of the GNU General Public License as published by |
# the Free Software Foundation; either version 3 of the License, or |
# (at your option) any later version. |
# |
# This program is distributed in the hope that it will be useful, |
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
# GNU General Public License for more details. |
# |
# You should have received a copy of the GNU General Public License |
# along with GCC; see the file COPYING3. If not see |
# <http://www.gnu.org/licenses/>. |
|
# Test the -MG flag. |
|
load_lib mike-gcc.exp |
|
prebase |
set actions none-of-the-above |
set compiler_output "mg.o ?: .*mg.c \[ \\\\\n\]*nonexist.h" |
postbase mg.c "" "" "-MM -MG" |
/bprob.exp
0,0 → 1,61
# Copyright (C) 2001, 2002, 2004, 2007, 2008 Free Software Foundation, Inc. |
|
# This program is free software; you can redistribute it and/or modify |
# it under the terms of the GNU General Public License as published by |
# the Free Software Foundation; either version 3 of the License, or |
# (at your option) any later version. |
# |
# This program is distributed in the hope that it will be useful, |
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
# GNU General Public License for more details. |
# |
# You should have received a copy of the GNU General Public License |
# along with GCC; see the file COPYING3. If not see |
# <http://www.gnu.org/licenses/>. |
|
# Test the functionality of programs compiled with profile-directed block |
# ordering using -fprofile-arcs followed by -fbranch-probabilities. |
|
load_lib target-supports.exp |
|
# Some targets don't have any implementation of __bb_init_func or are |
# missing other needed machinery. |
if { ![check_profiling_available "-fprofile-arcs"] } { |
return |
} |
|
# The procedures in profopt.exp need these parameters. |
set tool gcc |
set prof_ext "gcda" |
set perf_ext tim |
|
# Override the list defined in profopt.exp. |
set PROFOPT_OPTIONS [list \ |
{ -g } \ |
{ -O0 } \ |
{ -O1 } \ |
{ -O2 -DPERFTIME } \ |
{ -O3 -DPERFTIME } \ |
{ -O3 -g -DPERFTIME } \ |
{ -Os } ] |
|
if $tracelevel then { |
strace $tracelevel |
} |
|
# Load support procs. |
load_lib profopt.exp |
|
set profile_options "-fprofile-arcs" |
set feedback_options "-fbranch-probabilities" |
|
foreach profile_option $profile_options feedback_option $feedback_options { |
foreach src [lsort [glob -nocomplain $srcdir/$subdir/bprob-*.c]] { |
# If we're only testing specific files and this isn't one of them, skip it. |
if ![runtest_file_p $runtests $src] then { |
continue |
} |
profopt-execute $src |
} |
} |
/acker1.exp
0,0 → 1,28
# Copyright (C) 1997, 2007 Free Software Foundation, Inc. |
|
# This program is free software; you can redistribute it and/or modify |
# it under the terms of the GNU General Public License as published by |
# the Free Software Foundation; either version 3 of the License, or |
# (at your option) any later version. |
# |
# This program is distributed in the hope that it will be useful, |
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
# GNU General Public License for more details. |
# |
# You should have received a copy of the GNU General Public License |
# along with GCC; see the file COPYING3. If not see |
# <http://www.gnu.org/licenses/>. |
|
global PERF_TEST |
if { ![info exists PERF_TEST] || "$PERF_TEST" != "yes" } { |
return |
} |
|
load_lib mike-gcc.exp |
|
prebase |
set actions run |
set compiler_output "^$" |
set program_output "^$" |
postbase acker1.c $run $groups |
/dhry.exp
0,0 → 1,28
# Copyright (C) 1997, 2007 Free Software Foundation, Inc. |
|
# This program is free software; you can redistribute it and/or modify |
# it under the terms of the GNU General Public License as published by |
# the Free Software Foundation; either version 3 of the License, or |
# (at your option) any later version. |
# |
# This program is distributed in the hope that it will be useful, |
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
# GNU General Public License for more details. |
# |
# You should have received a copy of the GNU General Public License |
# along with GCC; see the file COPYING3. If not see |
# <http://www.gnu.org/licenses/>. |
|
global PERF_TEST |
if { ![info exists PERF_TEST] || "$PERF_TEST" != "yes" } { |
return |
} |
|
load_lib mike-gcc.exp |
|
prebase |
set actions run |
set compiler_output "^$" |
set program_output "^$" |
postbase dhry.c $run $groups |
/i386-pf-sse-1.c
0,0 → 1,32
/* Test that the correct data prefetch instructions are generated for i386 |
variants that use SSE prefetch instructions. */ |
|
/* { dg-do compile { target { { i?86-*-* x86_64-*-* } && ia32 } } } */ |
|
extern void exit (int); |
|
char *msg = "howdy there"; |
|
void foo (char *p) |
{ |
__builtin_prefetch (p, 0, 0); |
__builtin_prefetch (p, 0, 1); |
__builtin_prefetch (p, 0, 2); |
__builtin_prefetch (p, 0, 3); |
__builtin_prefetch (p, 1, 0); |
__builtin_prefetch (p, 1, 1); |
__builtin_prefetch (p, 1, 2); |
__builtin_prefetch (p, 1, 3); |
} |
|
int main () |
{ |
foo (msg); |
exit (0); |
} |
|
/* { dg-final { scan-assembler "prefetchnta" } } */ |
/* { dg-final { scan-assembler "prefetcht0" } } */ |
/* { dg-final { scan-assembler "prefetcht1" } } */ |
/* { dg-final { scan-assembler "prefetcht2" } } */ |
/* { dg-final { scan-assembler-not "prefetchw" } } */ |
/arm-isr.exp
0,0 → 1,28
# Copyright (C) 2001, 2007, 2008 Free Software Foundation, Inc. |
|
# This program is free software; you can redistribute it and/or modify |
# it under the terms of the GNU General Public License as published by |
# the Free Software Foundation; either version 3 of the License, or |
# (at your option) any later version. |
# |
# This program is distributed in the hope that it will be useful, |
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
# GNU General Public License for more details. |
# |
# You should have received a copy of the GNU General Public License |
# along with GCC; see the file COPYING3. If not see |
# <http://www.gnu.org/licenses/>. |
|
# This file is based on a bug report submitted to gcc-bugs: |
# http://gcc.gnu.org/ml/gcc-patches/2001-12/msg02158.html |
|
# Load support procs. |
load_lib gcc-dg.exp |
|
dg-init |
if { [istarget "arm*-*-*"] } { |
dg-runtest "$srcdir/$subdir/arm-isr.c" "" "" |
} |
dg-finish |
|
/linkage.exp
0,0 → 1,130
# Copyright (C) 1988, 90-96, 1997, 2000, 2001, 2002, 2007, 2008, 2010 |
# Free Software Foundation, Inc. |
|
# This program is free software; you can redistribute it and/or modify |
# it under the terms of the GNU General Public License as published by |
# the Free Software Foundation; either version 3 of the License, or |
# (at your option) any later version. |
# |
# This program is distributed in the hope that it will be useful, |
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
# GNU General Public License for more details. |
# |
# You should have received a copy of the GNU General Public License |
# along with GCC; see the file COPYING3. If not see |
# <http://www.gnu.org/licenses/>. |
|
# This file used to be gcc.c-torture/special/special.exp, which |
# was written by Rob Savoye. (rob@cygnus.com) |
# All the other tests driven by that file have since been moved elsewhere. |
|
if { [isnative] && ![is_remote host] } then { |
set lines [gcc_target_compile "$srcdir/$subdir/linkage-x.c" "linkage-x.o" object {additional_flags="-w"}] |
if ![string match "" $lines] then { |
fail "$subdir/linkage.c compile" |
} else { |
# This is a completely bogus test. Sorry. |
|
# Need to ensure ABI for native compiler matches gcc |
set native_cflags "" |
if [istarget "mips-sgi-irix6*"] { |
set file_string [exec file "linkage-x.o"] |
if [ string match "*64*" $file_string ] { |
set native_cflags "-64" |
} |
if [ string match "*ELF 32*" $file_string ] { |
set native_cflags "-32" |
} |
if [ string match "*N32*" $file_string ] { |
set native_cflags "-n32" |
} |
} |
if [istarget "sparc*-sun-solaris2*"] { |
set file_string [exec file "linkage-x.o"] |
if [ string match "*64*" $file_string ] { |
set native_cflags "-xarch=v9" |
} |
} |
if {[istarget "i?86*-*-solaris2*"] |
|| [istarget "x86_64-*-solaris2.1\[0-9\]*"]} { |
set file_string [exec file "linkage-x.o"] |
if [ string match "*64*" $file_string ] { |
set native_cflags "-xarch=amd64" |
} |
} |
if [istarget "s390*-*-linux*"] { |
set file_string [exec file "linkage-x.o"] |
if [ string match "*32-bit*" $file_string ] { |
set native_cflags "-m31" |
} |
if [ string match "*64-bit*" $file_string ] { |
set native_cflags "-m64" |
} |
} elseif {[istarget "i*86-*-linux*"] || [istarget "x86_64-*-linux*"]} { |
set file_string [exec file "linkage-x.o"] |
if [ string match "*32-bit*" $file_string ] { |
set native_cflags "-m32" |
} |
if [ string match "*64-bit*" $file_string ] { |
set native_cflags "-m64" |
} |
} elseif [istarget "*-hp-hpux*"] { |
set file_string [exec file "linkage-x.o"] |
if [ string match "*ELF-64*" $file_string ] { |
set native_cflags "+DD64" |
} |
} elseif [istarget "powerpc*-*-linux*"] { |
set file_string [exec file "linkage-x.o"] |
if [ string match "*64-bit*" $file_string ] { |
set native_cflags "-m64" |
} elseif [ string match "*32-bit*" $file_string ] { |
set native_cflags "-m32" |
} |
} elseif [istarget "powerpc*-*-darwin*"] { |
set file_string [exec file "linkage-x.o"] |
if [ string match "*ppc64" $file_string ] { |
set native_cflags "-m64" |
} elseif [ string match "*ppc" $file_string ] { |
set native_cflags "-m32" |
} |
} elseif [istarget "tilegx-*-linux*"] { |
set file_string [exec file "linkage-x.o"] |
if [ string match "*64-bit*" $file_string ] { |
set native_cflags "-m64" |
} elseif [ string match "*32-bit*" $file_string ] { |
set native_cflags "-m32" |
} |
} elseif [istarget "*86*-*-darwin*"] { |
set file_string [exec file "linkage-x.o"] |
if [ string match "*64*" $file_string ] { |
set native_cflags "-m64" |
} elseif [ string match "*i386" $file_string ] { |
set native_cflags "-m32" |
} |
} |
|
if [file exists "linkage-y.o"] then { |
file delete "linkage-y.o" |
} |
send_log "cc -c $native_cflags $srcdir/$subdir/linkage-y.c >&/dev/null\n" |
catch { exec cc -c $native_cflags "$srcdir/$subdir/linkage-y.c" >&/dev/null } |
if ![file exists "linkage-y.o"] then { |
send_log "c89 -c $native_cflags $srcdir/$subdir/linkage-y.c >&/dev/null\n" |
catch { exec c89 -c $native_cflags "$srcdir/$subdir/linkage-y.c" >&/dev/null } |
} |
if [file exists "linkage-y.o"] then { |
set lines [gcc_target_compile "linkage-y.o linkage-x.o" "linkage.exe" executable ""] |
if [string match "" $lines] then { |
pass "$subdir/linkage.c link" |
file delete "linkage.exe" |
} else { |
fail "$subdir/linkage.c link" |
} |
file delete "linkage-y.o" |
} else { |
unsupported "$subdir/linkage.c native compile failed" |
} |
file delete "linkage-x.o" |
} |
} |
/matrix1.c
0,0 → 1,46
/* Matrix operations */ |
|
#define BOUND 100 |
|
int a[BOUND][BOUND],b[BOUND][BOUND],c[BOUND][BOUND]; |
|
main() |
{ |
int i,j,k; |
|
|
|
for (i=0; i<BOUND; i++) |
{ |
for (j=0; j<BOUND; j++) |
{ |
a[i][j] = 1; |
b[i][j] = 1; |
} |
} |
for (i=0; i<BOUND; i++) |
{ |
for (j=0; j<BOUND; j++) |
{ |
c[i][j] = 0; |
for (k=0; k<BOUND; k++) |
{ |
c[i][j] = c[i][j] + a[i][k] * b[k][j]; |
} |
} |
} |
for (i=0; i<BOUND; i++) |
{ |
for (j=0; j<BOUND; j++) |
{ |
if (c[i][j] != BOUND) |
{ |
puts("ERROR"); |
return 0; |
} |
} |
} |
i=5; |
|
return 0; |
} |
/sieve.exp
0,0 → 1,28
# Copyright (C) 1997, 2007 Free Software Foundation, Inc. |
|
# This program is free software; you can redistribute it and/or modify |
# it under the terms of the GNU General Public License as published by |
# the Free Software Foundation; either version 3 of the License, or |
# (at your option) any later version. |
# |
# This program is distributed in the hope that it will be useful, |
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
# GNU General Public License for more details. |
# |
# You should have received a copy of the GNU General Public License |
# along with GCC; see the file COPYING3. If not see |
# <http://www.gnu.org/licenses/>. |
|
global PERF_TEST |
if { ![info exists PERF_TEST] || "$PERF_TEST" != "yes" } { |
return |
} |
|
load_lib mike-gcc.exp |
|
prebase |
set actions run |
set compiler_output "^$" |
set program_output "^$" |
postbase sieve.c $run $groups |
/i386-pf-none-1.c
0,0 → 1,28
/* Test that data prefetch instructions are not generated for i386 variants |
that do not support those instructions. */ |
|
/* { dg-do compile { target { { i?86-*-* x86_64-*-* } && ia32 } } } */ |
|
extern void exit (int); |
|
char *msg = "howdy there"; |
|
void foo (char *p) |
{ |
__builtin_prefetch (p, 0, 0); |
__builtin_prefetch (p, 0, 1); |
__builtin_prefetch (p, 0, 2); |
__builtin_prefetch (p, 0, 3); |
__builtin_prefetch (p, 1, 0); |
__builtin_prefetch (p, 1, 1); |
__builtin_prefetch (p, 1, 2); |
__builtin_prefetch (p, 1, 3); |
} |
|
int main () |
{ |
foo (msg); |
exit (0); |
} |
|
/* { dg-final { scan-assembler-not "fetch" } } */ |
/gcov-1.c
0,0 → 1,20
/* Test Gcov basics. */ |
|
/* { dg-options "-fprofile-arcs -ftest-coverage" } */ |
/* { dg-do run { target native } } */ |
|
void noop () |
{ |
} |
|
int main () |
{ |
int i; |
|
for (i = 0; i < 10; i++) /* count(11) */ |
noop (); /* count(10) */ |
|
return 0; /* count(1) */ |
} |
|
/* { dg-final { run-gcov gcov-1.c } } */ |
/gcov-2.c
0,0 → 1,22
/* Test Gcov basics. */ |
|
/* { dg-options "-fprofile-arcs -ftest-coverage -g" } */ |
/* { dg-do run { target native } } */ |
|
void noop () |
{ |
} |
|
int main () |
{ |
int i; |
|
for (i = 0; i < 10; i++) /* count(11) */ |
noop (); /* count(10) */ |
|
return 0; /* count(1) */ |
} |
|
int a_variable = 0; |
|
/* { dg-final { run-gcov gcov-2.c } } */ |