clang/test/SemaCXX/builtin-dump-struct.cpp

   1 // RUN: %clang_cc1 -std=c++20 -verify %s
   2
   3 namespace std {
   4   typedef decltype(sizeof(int)) size_t;
   5
   6   template <class E> struct initializer_list {
   7     const E *data;
   8     size_t size;
   9
  10     constexpr initializer_list(const E *data, size_t size)
  11         : data(data), size(size) {}
  12     constexpr initializer_list() : data(), size() {}
  13
  14     constexpr const E *begin() const { return data; }
  15     constexpr const E *end() const { return data + size; }
  16   };
  17 }
  18
  19 struct ConstexprString {
  20   constexpr ConstexprString() : ConstexprString("") {}
  21   constexpr ConstexprString(const char *p, std::size_t size) : data(new char[size+1]) {
  22     __builtin_memcpy(data, p, size);
  23     data[size] = '\0';
  24   }
  25   constexpr ConstexprString(const char *p) : ConstexprString(p, __builtin_strlen(p)) {}
  26   constexpr explicit ConstexprString(const char *p, const char *q) : data(nullptr) {
  27     auto p_size = __builtin_strlen(p);
  28     auto q_size = __builtin_strlen(q);
  29     data = new char[p_size + q_size + 1];
  30     __builtin_memcpy(data, p, p_size);
  31     __builtin_memcpy(data + p_size, q, q_size + 1);
  32   }
  33   constexpr ConstexprString(const ConstexprString &o) : ConstexprString(o.data) {}
  34   constexpr ConstexprString(ConstexprString &&o) : data(o.data) { o.data = nullptr; }
  35   constexpr ConstexprString &operator=(const ConstexprString &o) {
  36     return *this = ConstexprString(o);
  37   }
  38   constexpr ConstexprString &operator=(ConstexprString &&o) {
  39     delete[] data;
  40     data = o.data;
  41     o.data = nullptr;
  42     return *this;
  43   }
  44   constexpr ~ConstexprString() { delete[] data; }
  45   char *data;
  46
  47   friend constexpr ConstexprString operator+(const ConstexprString &a, const ConstexprString &b) {
  48     return ConstexprString(a.data, b.data);
  49   }
  50   friend constexpr ConstexprString &operator+=(ConstexprString &a, const ConstexprString &b) {
  51     return a = a + b;
  52   }
  53   friend constexpr bool operator==(const ConstexprString &a, const ConstexprString &b) {
  54     return __builtin_strcmp(a.data, b.data) == 0;
  55   }
  56 };
  57
  58 template<typename... T> constexpr void Format(ConstexprString &out, const char *fmt, T... args);
  59
  60 struct Arg {
  61   template<typename T, int (*)[__is_integral(T) ? 1 : -1] = nullptr>
  62   constexpr Arg(T value) {
  63     bool negative = false;
  64     if (value < 0) {
  65       value = -value;
  66       negative = true;
  67     }
  68     while (value > 0) {
  69       char str[2] = {char('0' + value % 10), '\0'};
  70       s = ConstexprString(str) + s;
  71       value /= 10;
  72     }
  73     if (negative)
  74       s = "-" + s;
  75   }
  76   template<typename T, int (*)[__is_class(T) ? 1 : -1] = nullptr>
  77   constexpr Arg(const T &value) {
  78     __builtin_dump_struct(&value, Format, s);
  79   }
  80   constexpr Arg(const char *s) : s(s) {}
  81   constexpr Arg(const ConstexprString *s) : s("\"" + *s + "\"") {}
  82   template<typename T, int (*)[__is_integral(T) ? 1 : -1] = nullptr>
  83   constexpr Arg(const T *p) : s("reference to " + Arg(*p).s) {}
  84   ConstexprString s;
  85 };
  86
  87 template<typename... T> constexpr void Format(ConstexprString &out, const char *fmt, T... args) { // #Format
  88   Arg formatted_args[] = {args...};
  89   int i = 0;
  90   while (const char *percent = __builtin_strchr(fmt, '%')) {
  91     if (percent[1] == '%') continue;
  92     if (percent != fmt && percent[-1] == '*') --percent;
  93     out += ConstexprString(fmt, percent - fmt);
  94     out += formatted_args[i++].s;
  95
  96     // Skip past format specifier until we hit a conversion specifier.
  97     fmt = percent;
  98     while (!__builtin_strchr("diouxXeEfFgGcsp", *fmt)) ++fmt;
  99     // Skip the conversion specifier too. TODO: Check it's the right one.
 100     ++fmt;
 101   }
 102   out += ConstexprString(fmt);
 103 }
 104
 105 template<typename T> constexpr ConstexprString ToString(const T &t) { return Arg(t).s; }
 106
 107 struct A {
 108   int x, y, z : 3;
 109   int : 4;
 110   ConstexprString s;
 111 };
 112 struct B : A {
 113   int p, q;
 114   struct {
 115     int anon1, anon2;
 116   };
 117   union {
 118     int anon3;
 119   };
 120   struct {
 121     int m;
 122   } c;
 123   int &&r;
 124 };
 125
 126 #if PRINT_OUTPUT
 127 #include <stdio.h>
 128 int main() {
 129   puts(ToString(B{1, 2, 3, "hello", 4, 5, 6, 7, 8, 9, 10}).data);
 130 }
 131 #else
 132 static_assert(ToString(B{1, 2, 3, "hello", 4, 5, 6, 7, 8, 9, 10}) == &R"(
 133 B {
 134   A {
 135     int x = 1
 136     int y = 2
 137     int z : 3 = 3
 138     ConstexprString s = "hello"
 139   }
 140   int p = 4
 141   int q = 5
 142   int anon1 = 6
 143   int anon2 = 7
 144   int anon3 = 8
 145   struct (unnamed) c = {
 146     int m = 9
 147   }
 148   int && r = reference to 10
 149 }
 150 )"[1]);
 151
 152 void errors(B b) {
 153   __builtin_dump_struct(); // expected-error {{too few arguments to function call, expected 2, have 0}}
 154   __builtin_dump_struct(1); // expected-error {{too few arguments to function call, expected 2, have 1}}
 155   __builtin_dump_struct(1, 2); // expected-error {{expected pointer to struct as 1st argument to '__builtin_dump_struct', found 'int'}}
 156   __builtin_dump_struct(&b, 2); // expected-error {{expected a callable expression as 2nd argument to '__builtin_dump_struct', found 'int'}}
 157   __builtin_dump_struct(&b, Format, 0); // expected-error {{no matching function for call to 'Format'}}
 158                                         // expected-note@-1 {{in call to printing function with arguments '(0, "%s", "B")' while dumping struct}}
 159                                         // expected-note@#Format {{no known conversion from 'int' to 'ConstexprString &' for 1st argument}}
 160 }
 161 #endif