gdb/testsuite/gdb.trace/unavailable.cc

   1 /* This testcase is part of GDB, the GNU debugger.
   2
   3    Copyright 2002, 2003, 2004, 2007, 2008, 2009, 2010, 2011
   4    Free Software Foundation, Inc.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #include <stdlib.h>
  20 #include <string.h>
  21
  22 /* Test program partial trace data visualization.  */
  23
  24 /* Typedefs.  */
  25
  26 typedef struct TEST_STRUCT {
  27   char   memberc;
  28   int    memberi;
  29   float  memberf;
  30   double memberd;
  31 } test_struct;
  32
  33 struct small_struct
  34 {
  35   int member;
  36 };
  37
  38 struct small_struct_b : public small_struct
  39 {
  40 };
  41
  42 typedef int test_array [4];
  43
  44 /* Global variables to be collected.  */
  45
  46 char         globalc;
  47 int          globali;
  48 float        globalf;
  49 double       globald;
  50 test_struct  globalstruct;
  51 test_struct *globalp;
  52 int          globalarr[16];
  53 small_struct g_smallstruct;
  54 small_struct_b g_smallstruct_b;
  55
  56 /* Strings.  */
  57
  58 const char g_const_string[] = "hello world";
  59 char g_string_unavail[sizeof (g_const_string)];
  60 char g_string_partial[sizeof (g_const_string)];
  61 const char *g_string_p;
  62
  63 /* Used to check that <unavailable> is not the same as 0 in array
  64    element repetitions.  */
  65
  66 struct tuple
  67 {
  68   int a;
  69   int b;
  70 };
  71
  72 struct tuple tarray[8];
  73
  74 /* Random tests.  */
  75
  76 struct StructA
  77 {
  78   int a, b;
  79   int array[10000];
  80   void *ptr;
  81   int bitfield:1;
  82 };
  83
  84 struct StructB
  85 {
  86   int d, ef;
  87   StructA struct_a;
  88   int s:1;
  89   static StructA static_struct_a;
  90   const char *string;
  91 };
  92
  93 /* References.  */
  94
  95 int g_int;
  96 int &g_ref = g_int;
  97
  98 struct StructRef
  99 {
 100   StructRef (unsigned int val) : ref(d) {}
 101
 102   void clear ()
 103   {
 104     d = 0;
 105   }
 106
 107   unsigned int d;
 108   unsigned int &ref;
 109 };
 110
 111 struct StructB struct_b;
 112 struct StructA StructB::static_struct_a;
 113
 114 StructRef g_structref(0x12345678);
 115 StructRef *g_structref_p = &g_structref;
 116
 117
 118 /* Test functions.  */
 119
 120 static void
 121 begin ()        /* called before anything else */
 122 {
 123 }
 124
 125 static void
 126 end ()          /* called after everything else */
 127 {
 128 }
 129
 130 int
 131 globals_test_func ()
 132 {
 133   int i = 0;
 134
 135   i += globalc + globali + globalf + globald;
 136   i += globalstruct.memberc + globalstruct.memberi;
 137   i += globalstruct.memberf + globalstruct.memberd;
 138   i += globalarr[1];
 139
 140   return i;     /* set globals_test_func tracepoint here */
 141 }
 142
 143 int
 144 main (int argc, char **argv, char **envp)
 145 {
 146   int         i = 0;
 147   test_struct mystruct;
 148   int         myarray[4];
 149
 150   begin ();
 151   /* Assign collectable values to global variables.  */
 152   globalc = 71;
 153   globali = 72;
 154   globalf = 73.3;
 155   globald = 74.4;
 156   globalstruct.memberc = 81;
 157   globalstruct.memberi = 82;
 158   globalstruct.memberf = 83.3;
 159   globalstruct.memberd = 84.4;
 160   globalp = &globalstruct;
 161
 162   for (i = 0; i < 15; i++)
 163     globalarr[i] = i;
 164
 165   mystruct.memberc = 101;
 166   mystruct.memberi = 102;
 167   mystruct.memberf = 103.3;
 168   mystruct.memberd = 104.4;
 169   myarray[0] = 111;
 170   myarray[1] = 112;
 171   myarray[2] = 113;
 172   myarray[3] = 114;
 173
 174   g_int = 123;
 175   memset (&struct_b, 0xaa, sizeof struct_b);
 176   memset (&struct_b.static_struct_a, 0xaa, sizeof struct_b.static_struct_a);
 177   struct_b.string = g_const_string;
 178   memcpy (g_string_unavail, g_const_string, sizeof (g_const_string));
 179   memcpy (g_string_partial, g_const_string, sizeof (g_const_string));
 180   g_string_p = g_const_string;
 181
 182   /* Call test functions, so they can be traced and data collected.  */
 183   i = 0;
 184   i += globals_test_func ();
 185
 186   /* Set 'em back to zero, so that the collected values will be
 187      distinctly different from the "realtime" (end of test) values.  */
 188
 189   globalc = 0;
 190   globali = 0;
 191   globalf = 0;
 192   globald = 0;
 193   globalstruct.memberc = 0;
 194   globalstruct.memberi = 0;
 195   globalstruct.memberf = 0;
 196   globalstruct.memberd = 0;
 197   globalp = 0;
 198   for (i = 0; i < 15; i++)
 199     globalarr[i] = 0;
 200
 201   memset (&struct_b, 0, sizeof struct_b);
 202   memset (&struct_b.static_struct_a, 0, sizeof struct_b.static_struct_a);
 203   struct_b.string = NULL;
 204   memset (g_string_unavail, 0, sizeof (g_string_unavail));
 205   memset (g_string_partial, 0, sizeof (g_string_partial));
 206   g_string_p = NULL;
 207
 208   g_int = 0;
 209
 210   g_structref.clear ();
 211   g_structref_p = NULL;
 212
 213   end ();
 214   return 0;
 215 }