Subversion Repositories openrisc_me

/* This testcase is part of GDB, the GNU debugger.
 
   Copyright 2008, 2009, 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 this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
#include <string.h>
 
struct s
{
  int a;
  int *b;
};
 
struct ss
{
  struct s a;
  struct s b;
};
 
struct ns {
  const char *null_str;
  int length;
};
 
struct lazystring {
  const char *lazy_str;
};
 
#ifdef __cplusplus
struct S : public s {
  int zs;
};
 
struct SS {
  int zss;
  S s;
};
 
struct SSS
{
  SSS (int x, const S& r);
  int a;
  const S &b;
};
SSS::SSS (int x, const S& r) : a(x), b(r) { }
 
class VirtualTest 
{ 
 private: 
  int value; 
 
 public: 
  VirtualTest () 
    { 
      value = 1;
    } 
};
 
class Vbase1 : public virtual VirtualTest { };
class Vbase2 : public virtual VirtualTest { };
class Vbase3 : public virtual VirtualTest { };
 
class Derived : public Vbase1, public Vbase2, public Vbase3
{ 
 private: 
  int value; 
 
 public:
  Derived () 
    { 
      value = 2; 
    }
};
 
#endif
 
struct substruct {
  int a;
  int b;
};
 
struct outerstruct {
  struct substruct s;
  int x;
};
 
struct outerstruct
substruct_test (void)
{
  struct outerstruct outer;
  outer.s.a = 0;
  outer.s.b = 0;
  outer.x = 0;
 
  outer.s.a = 3;		/* MI outer breakpoint here */
 
  return outer;  
}
 
typedef struct string_repr
{
  struct whybother
  {
    const char *contents;
  } whybother;
} string;
 
/* This lets us avoid malloc.  */
int array[100];
 
struct container
{
  string name;
  int len;
  int *elements;
};
 
typedef struct container zzz_type;
 
string
make_string (const char *s)
{
  string result;
  result.whybother.contents = s;
  return result;
}
 
zzz_type
make_container (const char *s)
{
  zzz_type result;
 
  result.name = make_string (s);
  result.len = 0;
  result.elements = 0;
 
  return result;
}
 
void
add_item (zzz_type *c, int val)
{
  if (c->len == 0)
    c->elements = array;
  c->elements[c->len] = val;
  ++c->len;
}
 
void init_s(struct s *s, int a)
{
  s->a = a;
  s->b = &s->a;
}
 
void init_ss(struct ss *s, int a, int b)
{
  init_s(&s->a, a);
  init_s(&s->b, b);
}
 
void do_nothing(void)
{
  int c;
 
  c = 23;			/* Another MI breakpoint */
}
 
struct nullstr
{
  char *s;
};
 
struct string_repr string_1 = { { "one" } };
struct string_repr string_2 = { { "two" } };
 
int
main ()
{
  struct ss  ss;
  struct ss  ssa[2];
  string x = make_string ("this is x");
  zzz_type c = make_container ("container");
  zzz_type c2 = make_container ("container2");
  const struct string_repr cstring = { { "const string" } };
  /* Clearing by being `static' could invoke an other GDB C++ bug.  */
  struct nullstr nullstr;
 
 
  init_ss(&ss, 1, 2);
  init_ss(ssa+0, 3, 4);
  init_ss(ssa+1, 5, 6);
  memset (&nullstr, 0, sizeof nullstr);
 
  struct ns  ns;
  ns.null_str = "embedded\0null\0string";
  ns.length = 20;
 
  struct lazystring estring;
  estring.lazy_str = "embedded x\201\202\203\204" ;
 
#ifdef __cplusplus
  S cps;
 
  cps.zs = 7;
  init_s(&cps, 8);
 
  SS cpss;
  cpss.zss = 9;
  init_s(&cpss.s, 10);
 
  SS cpssa[2];
  cpssa[0].zss = 11;
  init_s(&cpssa[0].s, 12);
  cpssa[1].zss = 13;
  init_s(&cpssa[1].s, 14);
 
  SSS sss(15, cps);
 
  SSS& ref (sss);
 
  Derived derived;
 
#endif
 
  add_item (&c, 23);		/* MI breakpoint here */
  add_item (&c, 72);
 
#ifdef MI
  add_item (&c, 1011);
  c.elements[0] = 1023;
  c.elements[0] = 2323;
 
  add_item (&c2, 2222);
  add_item (&c2, 3333);
 
  substruct_test ();
  do_nothing ();
#endif
 
  return 0;      /* break to inspect struct and union */
}