clang/test/SemaCXX/cxx2a-constexpr-dynalloc.cpp

   1 // RUN: %clang_cc1 -std=c++2a -verify %s -DNEW=__builtin_operator_new -DDELETE=__builtin_operator_delete
   2 // RUN: %clang_cc1 -std=c++2a -verify %s "-DNEW=operator new" "-DDELETE=operator delete"
   3 // RUN: %clang_cc1 -std=c++2a -verify %s "-DNEW=::operator new" "-DDELETE=::operator delete"
   4
   5 constexpr bool alloc_from_user_code() {
   6   void *p = NEW(sizeof(int)); // expected-note {{cannot allocate untyped memory in a constant expression; use 'std::allocator<T>::allocate'}}
   7   DELETE(p);
   8   return true;
   9 }
  10 static_assert(alloc_from_user_code()); // expected-error {{constant expression}} expected-note {{in call}}
  11
  12 namespace std {
  13   using size_t = decltype(sizeof(0));
  14   // FIXME: It would be preferable to point these notes at the location of the call to allocator<...>::[de]allocate instead
  15   template<typename T> struct allocator {
  16     constexpr T *allocate(size_t N) {
  17       return (T*)NEW(sizeof(T) * N); // expected-note 3{{heap allocation}} expected-note {{not deallocated}}
  18     }
  19     constexpr void deallocate(void *p) {
  20       DELETE(p); // #dealloc expected-note 2{{'std::allocator<...>::deallocate' used to delete pointer to object allocated with 'new'}}
  21     }
  22   };
  23 }
  24
  25 constexpr bool alloc_via_std_allocator() {
  26   std::allocator<int> alloc;
  27   int *p = alloc.allocate(1);
  28   alloc.deallocate(p);
  29   return true;
  30 }
  31 static_assert(alloc_via_std_allocator());
  32
  33 template<> struct std::allocator<void()> {
  34   constexpr void *allocate() { return NEW(8); } // expected-note {{cannot allocate memory of function type 'void ()'}}
  35 };
  36 constexpr void *fn = std::allocator<void()>().allocate(); // expected-error {{constant expression}} expected-note {{in call}}
  37
  38 struct Incomplete;
  39 template<> struct std::allocator<Incomplete> {
  40   constexpr void *allocate() { return NEW(8); } // expected-note {{cannot allocate memory of incomplete type 'Incomplete'}}
  41 };
  42 constexpr void *incomplete = std::allocator<Incomplete>().allocate(); // expected-error {{constant expression}} expected-note {{in call}}
  43
  44 struct WrongSize { char x[5]; };
  45 static_assert(sizeof(WrongSize) == 5);
  46 template<> struct std::allocator<WrongSize> {
  47   constexpr void *allocate() { return NEW(7); } // expected-note {{allocated size 7 is not a multiple of size 5 of element type 'WrongSize'}}
  48 };
  49 constexpr void *wrong_size = std::allocator<WrongSize>().allocate(); // expected-error {{constant expression}} expected-note {{in call}}
  50
  51 constexpr bool mismatched(int alloc_kind, int dealloc_kind) {
  52   int *p;
  53   switch (alloc_kind) {
  54   case 0:
  55     p = new int; // expected-note {{heap allocation}}
  56     break;
  57   case 1:
  58     p = new int[1]; // expected-note {{heap allocation}}
  59     break;
  60   case 2:
  61     p = std::allocator<int>().allocate(1);
  62     break;
  63   }
  64   switch (dealloc_kind) {
  65   case 0:
  66     delete p; // expected-note {{'delete' used to delete pointer to object allocated with 'std::allocator<...>::allocate'}}
  67     break;
  68   case 1:
  69     delete[] p; // expected-note {{'delete' used to delete pointer to object allocated with 'std::allocator<...>::allocate'}}
  70     break;
  71   case 2:
  72     std::allocator<int>().deallocate(p); // expected-note 2{{in call}}
  73     break;
  74   }
  75   return true;
  76 }
  77 static_assert(mismatched(0, 2)); // expected-error {{constant expression}} expected-note {{in call}}
  78 static_assert(mismatched(1, 2)); // expected-error {{constant expression}} expected-note {{in call}}
  79 static_assert(mismatched(2, 0)); // expected-error {{constant expression}} expected-note {{in call}}
  80 static_assert(mismatched(2, 1)); // expected-error {{constant expression}} expected-note {{in call}}
  81 static_assert(mismatched(2, 2));
  82
  83 constexpr int *escape = std::allocator<int>().allocate(3); // expected-error {{constant expression}} expected-note {{pointer to subobject of heap-allocated}}
  84 constexpr int leak = (std::allocator<int>().allocate(3), 0); // expected-error {{constant expression}}
  85 constexpr int no_lifetime_start = (*std::allocator<int>().allocate(1) = 1); // expected-error {{constant expression}} expected-note {{assignment to object outside its lifetime}}
  86 constexpr int no_deallocate_nullptr = (std::allocator<int>().deallocate(nullptr), 1); // expected-error {{constant expression}} expected-note {{in call}}
  87 // expected-note@#dealloc {{'std::allocator<...>::deallocate' used to delete a null pointer}}
  88 constexpr int no_deallocate_nonalloc = (std::allocator<int>().deallocate((int*)&no_deallocate_nonalloc), 1); // expected-error {{constant expression}} expected-note {{in call}}
  89 // expected-note@#dealloc {{delete of pointer '&no_deallocate_nonalloc' that does not point to a heap-allocated object}}
  90 // expected-note@-2 {{declared here}}
  91
  92 void *operator new(std::size_t, void *p) { return p; }
  93 constexpr bool no_placement_new_in_user_code() { // expected-error {{never produces a constant expression}}
  94   int a;
  95   new (&a) int(42); // expected-note {{call to placement 'operator new'}}
  96   return a == 42;
  97 }
  98
  99 namespace std {
 100   constexpr bool placement_new_in_stdlib() {
 101     int a;
 102     new (&a) int(42);
 103     return a == 42;
 104   }
 105 }
 106 static_assert(std::placement_new_in_stdlib());
 107
 108 namespace std {
 109   template<typename T, typename ...Args>
 110   constexpr void construct_at(void *p, Args &&...args) {
 111     new (p) T((Args&&)args...); // #new
 112   }
 113 }
 114
 115 constexpr bool call_std_construct_at() {
 116   int *p = std::allocator<int>().allocate(3);
 117   std::construct_at<int>(p, 1);
 118   std::construct_at<int>(p + 1, 2);
 119   std::construct_at<int>(p + 2, 3);
 120   bool good = p[0] + p[1] + p[2] == 6;
 121   std::allocator<int>().deallocate(p);
 122   return good;
 123 }
 124 static_assert(call_std_construct_at());
 125
 126 constexpr bool bad_construct_at_type() {
 127   int a;
 128   // expected-note@#new {{placement new would change type of storage from 'int' to 'float'}}
 129   std::construct_at<float>(&a, 1.0f); // expected-note {{in call}}
 130   return true;
 131 }
 132 static_assert(bad_construct_at_type()); // expected-error{{}} expected-note {{in call}}
 133
 134 constexpr bool bad_construct_at_subobject() {
 135   struct X { int a, b; };
 136   union A {
 137     int a;
 138     X x;
 139   };
 140   A a = {1};
 141   // expected-note@#new {{construction of subobject of member 'x' of union with active member 'a' is not allowed in a constant expression}}
 142   std::construct_at<int>(&a.x.a, 1); // expected-note {{in call}}
 143   return true;
 144 }
 145 static_assert(bad_construct_at_subobject()); // expected-error{{}} expected-note {{in call}}
 146
 147 constexpr bool change_union_member() {
 148   union U {
 149     int a;
 150     int b;
 151   };
 152   U u = {.a = 1};
 153   std::construct_at<int>(&u.b, 2);
 154   return u.b == 2;
 155 }
 156 static_assert(change_union_member());
 157
 158 int external;
 159 // expected-note@#new {{visible outside}}
 160 static_assert((std::construct_at<int>(&external, 1), true)); // expected-error{{}} expected-note {{in call}}
 161
 162 constexpr int &&temporary = 0; // expected-note {{created here}}
 163 // expected-note@#new {{construction of temporary is not allowed in a constant expression outside the expression that created the temporary}}
 164 static_assert((std::construct_at<int>(&temporary, 1), true)); // expected-error{{}} expected-note {{in call}}
 165
 166 constexpr bool construct_after_lifetime() {
 167   int *p = new int;
 168   delete p;
 169   // expected-note@#new {{construction of heap allocated object that has been deleted}}
 170   std::construct_at<int>(p); // expected-note {{in call}}
 171   return true;
 172 }
 173 static_assert(construct_after_lifetime()); // expected-error {{}} expected-note {{in call}}
 174
 175 constexpr bool construct_after_lifetime_2() {
 176   struct A { struct B {} b; };
 177   A a;
 178   a.~A();
 179   std::construct_at<A::B>(&a.b); // expected-note {{in call}}
 180   // expected-note@#new {{construction of subobject of object outside its lifetime is not allowed in a constant expression}}
 181   return true;
 182 }
 183 static_assert(construct_after_lifetime_2()); // expected-error {{}} expected-note {{in call}}
 184
 185 namespace PR48606 {
 186   struct A { mutable int n = 0; };
 187
 188   constexpr bool f() {
 189     A a;
 190     A *p = &a;
 191     p->~A();
 192     std::construct_at<A>(p);
 193     return true;
 194   }
 195   static_assert(f());
 196
 197   constexpr bool g() {
 198     A *p = new A;
 199     p->~A();
 200     std::construct_at<A>(p);
 201     delete p;
 202     return true;
 203   }
 204   static_assert(g());
 205
 206   constexpr bool h() {
 207     std::allocator<A> alloc;
 208     A *p = alloc.allocate(1);
 209     std::construct_at<A>(p);
 210     p->~A();
 211     std::construct_at<A>(p);
 212     p->~A();
 213     alloc.deallocate(p);
 214     return true;
 215   }
 216   static_assert(h());
 217 }