| /* This testcase is part of GDB, the GNU debugger. |
| |
| Copyright 1998-2017 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 this program. If not, see <http://www.gnu.org/licenses/>. */ |
| |
| /* |
| * Test program for trace collection |
| */ |
| |
| /* |
| * Typedefs |
| */ |
| |
| typedef struct TEST_STRUCT { |
| char memberc; |
| int memberi; |
| float memberf; |
| double memberd; |
| } test_struct; |
| |
| typedef int test_array [4]; |
| |
| /* |
| * Global variables to be collected |
| */ |
| |
| char globalc; |
| int globali; |
| float globalf; |
| double globald; |
| test_struct globalstruct; |
| test_struct *globalp; |
| int globalarr[16]; |
| int globalarr2[4]; |
| int globalarr3[4]; |
| |
| struct global_pieces { |
| unsigned int a; |
| unsigned int b; |
| } global_pieces = |
| { |
| 0x12345678, 0x87654321 |
| }; |
| |
| /* |
| * Additional globals used in arithmetic tests |
| */ |
| |
| signed char c0, c1, c2, c3, c4, c5, c6, c7, |
| c8, c9, c10, c11, c12, c13, c14, c15, cminus; |
| signed short s0, s1, s2, s3, s4, s5, s6, s7, |
| s8, s9, s10, s11, s12, s13, s14, s15, sminus; |
| signed long l0, l1, l2, l3, l4, l5, l6, l7, |
| l8, l9, l10, l11, l12, l13, l14, l15, lminus; |
| |
| |
| /* |
| * Test functions |
| */ |
| |
| static void begin () /* called before anything else */ |
| { |
| } |
| |
| static void end () /* called after everything else */ |
| { |
| } |
| |
| /* Test collecting args. */ |
| int args_test_func (argc, argi, argf, argd, argstruct, argarray) |
| char argc; |
| int argi; |
| float argf; |
| double argd; |
| test_struct argstruct; |
| int argarray[4]; |
| { |
| int i; |
| |
| i = (int) argc + argi + argf + argd + argstruct.memberi + argarray[1]; |
| |
| return i; |
| } |
| |
| /* Test collecting struct args. */ |
| int argstruct_test_func (argstruct) |
| test_struct argstruct; |
| { |
| return (int) argstruct.memberc + argstruct.memberi + |
| argstruct.memberf + argstruct.memberd; |
| } |
| |
| /* Test collecting array args. */ |
| int argarray_test_func (argarray) |
| int argarray[4]; |
| { |
| return (int) argarray[0] + argarray[1] + argarray[2] + argarray[3]; |
| } |
| |
| |
| |
| int local_test_func () /* test collecting locals */ |
| { |
| char locc = 11; |
| int loci = 12; |
| float locf = 13.3; |
| double locd = 14.4; |
| test_struct locst; |
| int locar[4]; |
| int i; |
| struct localstruct {} locdefst; |
| |
| locst.memberc = 15; |
| locst.memberi = 16; |
| locst.memberf = 17.7; |
| locst.memberd = 18.8; |
| locar[0] = 121; |
| locar[1] = 122; |
| locar[2] = 123; |
| locar[3] = 124; |
| |
| i = /* Set_Tracepoint_Here */ |
| (int) locc + loci + locf + locd + locst.memberi + locar[1]; |
| |
| return i; |
| } |
| |
| int reglocal_test_func () /* test collecting register locals */ |
| { |
| register char locc = 11; |
| register int loci = 12; |
| register float locf = 13.3; |
| register double locd = 14.4; |
| register test_struct locst; |
| register int locar[4]; |
| int i; |
| |
| locst.memberc = 15; |
| locst.memberi = 16; |
| locst.memberf = 17.7; |
| locst.memberd = 18.8; |
| locar[0] = 121; |
| locar[1] = 122; |
| locar[2] = 123; |
| locar[3] = 124; |
| |
| i = /* Set_Tracepoint_Here */ |
| (int) locc + loci + locf + locd + locst.memberi + locar[1]; |
| |
| return i; |
| } |
| |
| int statlocal_test_func () /* test collecting static locals */ |
| { |
| static char locc; |
| static int loci; |
| static float locf; |
| static double locd; |
| static test_struct locst; |
| static int locar[4]; |
| int i; |
| |
| locc = 11; |
| loci = 12; |
| locf = 13.3; |
| locd = 14.4; |
| locst.memberc = 15; |
| locst.memberi = 16; |
| locst.memberf = 17.7; |
| locst.memberd = 18.8; |
| locar[0] = 121; |
| locar[1] = 122; |
| locar[2] = 123; |
| locar[3] = 124; |
| |
| i = /* Set_Tracepoint_Here */ |
| (int) locc + loci + locf + locd + locst.memberi + locar[1]; |
| |
| /* Set static locals back to zero so collected values are clearly special. */ |
| locc = 0; |
| loci = 0; |
| locf = 0; |
| locd = 0; |
| locst.memberc = 0; |
| locst.memberi = 0; |
| locst.memberf = 0; |
| locst.memberd = 0; |
| locar[0] = 0; |
| locar[1] = 0; |
| locar[2] = 0; |
| locar[3] = 0; |
| |
| return i; |
| } |
| |
| |
| int globals_test_func () |
| { |
| int i = 0; |
| |
| i += globalc + globali + globalf + globald; |
| i += globalstruct.memberc + globalstruct.memberi; |
| i += globalstruct.memberf + globalstruct.memberd; |
| i += globalarr[1]; |
| |
| return i; /* Set_Tracepoint_Here */ |
| } |
| |
| int strings_test_func () |
| { |
| int i = 0; |
| char *locstr, *longloc; |
| |
| locstr = "abcdef"; |
| longloc = malloc(500); |
| strcpy(longloc, "how now brown cow spam spam spam wonderful wonderful spam"); |
| |
| i += strlen (locstr); |
| i += strlen (longloc); |
| |
| return i; /* Set_Tracepoint_Here */ |
| } |
| |
| int |
| main (argc, argv, envp) |
| int argc; |
| char *argv[], **envp; |
| { |
| int i = 0; |
| test_struct mystruct; |
| int myarray[4]; |
| |
| begin (); |
| /* Assign collectable values to global variables. */ |
| l0 = s0 = c0 = 0; l1 = s1 = c1 = 1; |
| l2 = s2 = c2 = 2; l3 = s3 = c3 = 3; |
| l4 = s4 = c4 = 4; l5 = s5 = c5 = 5; |
| l6 = s6 = c6 = 6; l7 = s7 = c7 = 7; |
| l8 = s8 = c8 = 8; l9 = s9 = c9 = 9; |
| l10 = s10 = c10 = 10; l11 = s11 = c11 = 11; |
| l12 = s12 = c12 = 12; l13 = s13 = c13 = 13; |
| l14 = s14 = c14 = 14; l15 = s15 = c15 = 15; |
| lminus = sminus = cminus = -2; |
| globalc = 71; |
| globali = 72; |
| globalf = 73.3; |
| globald = 74.4; |
| globalstruct.memberc = 81; |
| globalstruct.memberi = 82; |
| globalstruct.memberf = 83.3; |
| globalstruct.memberd = 84.4; |
| globalp = &globalstruct; |
| |
| for (i = 0; i < 15; i++) |
| globalarr[i] = i; |
| |
| for (i = 0; i < 4; i++) |
| globalarr2[i] = i; |
| |
| for (i = 0; i < 4; i++) |
| globalarr3[3 - i] = i; |
| |
| mystruct.memberc = 101; |
| mystruct.memberi = 102; |
| mystruct.memberf = 103.3; |
| mystruct.memberd = 104.4; |
| myarray[0] = 111; |
| myarray[1] = 112; |
| myarray[2] = 113; |
| myarray[3] = 114; |
| |
| /* Call test functions, so they can be traced and data collected. */ |
| i = 0; |
| i += args_test_func (1, 2, 3.3, 4.4, mystruct, myarray); |
| i += argstruct_test_func (mystruct); |
| i += argarray_test_func (myarray); |
| i += local_test_func (); |
| i += reglocal_test_func (); |
| i += statlocal_test_func (); |
| i += globals_test_func (); |
| i += strings_test_func (); |
| |
| /* Values of globals at end of test should be different from |
| values that they had when trace data was captured. */ |
| |
| l0 = s0 = c0 = 0; l1 = s1 = c1 = 0; |
| l2 = s2 = c2 = 0; l3 = s3 = c3 = 0; |
| l4 = s4 = c4 = 0; l5 = s5 = c5 = 0; |
| l6 = s6 = c6 = 0; l7 = s7 = c7 = 0; |
| l8 = s8 = c8 = 0; l9 = s9 = c9 = 0; |
| l10 = s10 = c10 = 0; l11 = s11 = c11 = 0; |
| l12 = s12 = c12 = 0; l13 = s13 = c13 = 0; |
| l14 = s14 = c14 = 0; l15 = s15 = c15 = 0; |
| lminus = sminus = cminus = 0; |
| |
| /* Set 'em back to zero, so that the collected values will be |
| distinctly different from the "realtime" (end of test) values. */ |
| |
| globalc = 0; |
| globali = 0; |
| globalf = 0; |
| globald = 0; |
| globalstruct.memberc = 0; |
| globalstruct.memberi = 0; |
| globalstruct.memberf = 0; |
| globalstruct.memberd = 0; |
| globalp = 0; |
| for (i = 0; i < 15; i++) |
| globalarr[i] = 0; |
| for (i = 0; i < 4; i++) |
| globalarr2[i] = 0; |
| for (i = 0; i < 4; i++) |
| globalarr3[i] = 0; |
| |
| end (); |
| return 0; |
| } |