/* This testcase is part of GDB, the GNU debugger.

   Copyright 1998-2015 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;
}