gdb/testsuite/gdb.cp/meth-typedefs.cc

   1 /* This testcase is part of GDB, the GNU debugger.
   2
   3    Copyright 2011-2019 Free Software Foundation, Inc.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18    Contributed by Red Hat, originally written by Keith Seitz.  */
  19
  20 #include <stdlib.h>
  21
  22 typedef const char* const* my_type;
  23 typedef int my_type_2;
  24 typedef my_type my_other_type;
  25 typedef my_type_2 my_other_type_2;
  26 typedef unsigned long CORE_ADDR;
  27 typedef enum {E_A, E_B, E_C} anon_enum;
  28 typedef struct {int a; char b;} anon_struct;
  29 typedef union {int a; char b;} anon_union;
  30 typedef anon_enum aenum;
  31 typedef anon_struct astruct;
  32 typedef anon_union aunion;
  33
  34 typedef void (*fptr1) (my_other_type);
  35 typedef void (*fptr2) (fptr1, my_other_type_2);
  36 typedef void (*fptr3) (fptr2, my_other_type);
  37 typedef void (*fptr4) (anon_enum a, anon_struct const& b, anon_union const*** c);
  38
  39 // For c++/24367 testing
  40 typedef struct incomplete_struct incomplete_struct;
  41 typedef struct _incomplete_struct another_incomplete_struct;
  42 int test_incomplete (incomplete_struct *p) { return 0; } // test_incomplete(incomplete_struct*)
  43 int test_incomplete (another_incomplete_struct *p) { return 1; } // test_incomplete(another_incomplete_struct*)
  44 int test_incomplete (int *p) { return -1; } // test_incomplete(int*)
  45
  46 namespace A
  47 {
  48   class foo
  49   {
  50   public:
  51     foo (void) { }
  52     foo (my_other_type a) { } // A::FOO::foo(my_other_type)
  53     foo (my_other_type_2 a) { } // A::FOO::foo(my_other_type_2)
  54     foo (my_other_type_2 a, const my_other_type b) { } // A::FOO::foo(my_other_type_2, const my_other_type)
  55     foo (fptr3) { } // A::FOO::foo(fptr3)
  56     foo (fptr1* a) { } // A::FOO::foo(fptr1*)
  57     foo (CORE_ADDR (*) [10]) { } // A::FOO::foo(CORE_ADDR (*) [10])
  58     foo (aenum a, astruct const& b, aunion const*** c) { } // A::FOO::foo(aenum, astruct const&, aunion const***)
  59
  60     void test (my_other_type a) { } // A::FOO::test(my_other_type)
  61     void test (my_other_type_2 a) { } // A::FOO::test(my_other_type_2)
  62     void test (my_other_type_2 a, const my_other_type b) { } // A::FOO::test(my_other_type_2, const my_other_type)
  63     void test (fptr3 a) { } // A::FOO::test(fptr3)
  64     void test (fptr1* a) { } // A::FOO::test(fptr1*)
  65     void test (CORE_ADDR (*) [10]) { } // A::FOO::test(CORE_ADDR (*) [10])
  66     void test (aenum a, astruct const& b, aunion const*** c) { }; // A::FOO::test(aenum, astruct const&, aunion const***)
  67   };
  68
  69   typedef foo FOO;
  70 };
  71
  72 namespace B
  73 {
  74   void
  75   test (my_other_type foo) { } // B::test(my_other_type)
  76
  77   void
  78   test (aenum a, astruct const& b, aunion const*** c) { } // B::test(aenum, astruct const&, aunion const***)
  79
  80   template <typename T1, typename T2>
  81   void test (T1 a, T2 b) { } // B::test (T1, T2)
  82
  83   template <>
  84   void test (my_other_type foo, my_other_type_2) { } // B::test<my_other_type, my_other_type_2>(my_other_type, my_other_type_2)
  85 };
  86
  87 namespace a
  88 {
  89   namespace b
  90   {
  91     namespace c
  92     {
  93       namespace d
  94       {
  95         class bar { };
  96       }
  97     }
  98
  99     typedef c::d::bar BAR;
 100   }
 101 }
 102
 103 typedef a::b::BAR _BAR_;
 104
 105 template <typename T1, typename T2>
 106 void test (T1 a, T2 b) {} // test (T1, T2)
 107
 108 template <>
 109 void test (my_other_type foo, my_other_type_2) { } // test<my_other_type, my_other_type_2>(my_other_type, my_other_type_2)
 110
 111 void
 112 test (my_other_type foo) { } // test(my_other_type)
 113
 114 void
 115 test (_BAR_ &b) { } // test(_BAR_&)
 116
 117 void
 118 test (aenum a, astruct const& b, aunion const*** c) { } // test(aenum, astruct const&, aunion const***)
 119
 120 int
 121 main (void)
 122 {
 123   A::FOO my_foo;
 124   fptr1 fptr;
 125   astruct as = { 0, 0 };
 126   aunion const au = { 0 };
 127   aunion const* aup = &au;
 128   aunion const** aupp = &aup;
 129   aunion const*** auppp = &aupp;
 130
 131   my_foo.test (static_cast<my_other_type> (NULL));
 132   my_foo.test (0);
 133   my_foo.test (0, static_cast<my_type> (NULL));
 134   my_foo.test (static_cast<fptr3> (NULL));
 135   my_foo.test (&fptr);
 136   my_foo.test (static_cast<CORE_ADDR (*) [10]> (0));
 137   my_foo.test (E_A, as, auppp);
 138
 139   B::test (static_cast<my_other_type> (NULL));
 140   B::test (static_cast<my_other_type> (NULL), 0);
 141   B::test (E_A, as, auppp);
 142
 143   test (static_cast<my_other_type> (NULL));
 144   test<my_other_type, my_other_type_2> (static_cast<my_other_type> (NULL), 0);
 145   test (E_A, as, auppp);
 146
 147   A::foo a (static_cast<my_other_type> (NULL));
 148   A::foo b (0);
 149   A::foo c (0, static_cast<my_other_type> (NULL));
 150   A::foo d (static_cast<fptr3> (NULL));
 151   A::foo e (&fptr);
 152   A::foo f (static_cast<CORE_ADDR (*) [10]> (0));
 153   A::foo g (E_A, as, auppp);
 154
 155   fptr4 f4;
 156
 157   // Tests for c++/24367
 158   int *i = nullptr;
 159   incomplete_struct *is = nullptr;
 160   another_incomplete_struct *ais = nullptr;
 161   int result = (test_incomplete (i) + test_incomplete (is)
 162                 + test_incomplete (ais));
 163   return 0;
 164 }