lldb/test/Shell/SymbolFile/NativePDB/globals-fundamental.cpp

   1 // clang-format off
   2 // REQUIRES: lld, x86
   3
   4 // Test that we can display tag types.
   5 // RUN: %clang_cl --target=x86_64-windows-msvc -Od -Z7 \
   6 // RUN:   -Xclang -fkeep-static-consts -c /Fo%t.obj -- %s
   7 // RUN: lld-link -debug:full -nodefaultlib -entry:main %t.obj -out:%t.exe -pdb:%t.pdb
   8 // RUN: env LLDB_USE_NATIVE_PDB_READER=1 %lldb -f %t.exe -s \
   9 // RUN:     %p/Inputs/globals-fundamental.lldbinit | FileCheck %s
  10
  11
  12 // Fundamental data types
  13 bool BFalse = false;
  14 // CHECK: (lldb) target variable BFalse
  15 // CHECK-NEXT: (bool) BFalse = false
  16 bool BTrue = true;
  17 // CHECK-NEXT: (lldb) target variable BTrue
  18 // CHECK-NEXT: (bool) BTrue = true
  19 char CA = 'A';
  20 // CHECK-NEXT: (lldb) target variable CA
  21 // CHECK-NEXT: (char) CA = 'A'
  22 char CZ = 'Z';
  23 // CHECK-NEXT: (lldb) target variable CZ
  24 // CHECK-NEXT: (char) CZ = 'Z'
  25 signed char SCa = 'a';
  26 // CHECK-NEXT: (lldb) target variable SCa
  27 // CHECK-NEXT: (signed char) SCa = 'a'
  28 signed char SCz = 'z';
  29 // CHECK-NEXT: (lldb) target variable SCz
  30 // CHECK-NEXT: (signed char) SCz = 'z'
  31 unsigned char UC24 = 24;
  32 // CHECK-NEXT: (lldb) target variable UC24
  33 // CHECK-NEXT: (unsigned char) UC24 = '\x18'
  34 unsigned char UC42 = 42;
  35 // CHECK-NEXT: (lldb) target variable UC42
  36 // CHECK-NEXT: (unsigned char) UC42 = '*'
  37 char16_t C16_24 = u'\24';
  38 // CHECK-NEXT: (lldb) target variable C16_24
  39 // CHECK-NEXT: (char16_t) C16_24 = U+0014
  40 char32_t C32_42 = U'\42';
  41 // CHECK-NEXT: (lldb) target variable C32_42
  42 // CHECK-NEXT: (char32_t) C32_42 = U+0x00000022
  43 wchar_t WC1 = L'1';
  44 // CHECK-NEXT: (lldb) target variable WC1
  45 // CHECK-NEXT: (wchar_t) WC1 = L'1'
  46 wchar_t WCP = L'P';
  47 // CHECK-NEXT: (lldb) target variable WCP
  48 // CHECK-NEXT: (wchar_t) WCP = L'P'
  49 short SMax = 32767;
  50 // CHECK-NEXT: (lldb) target variable SMax
  51 // CHECK-NEXT: (short) SMax = 32767
  52 short SMin = -32768;
  53 // CHECK-NEXT: (lldb) target variable SMin
  54 // CHECK-NEXT: (short) SMin = -32768
  55 unsigned short USMax = 65535;
  56 // CHECK-NEXT: (lldb) target variable USMax
  57 // CHECK-NEXT: (unsigned short) USMax = 65535
  58 unsigned short USMin = 0;
  59 // CHECK-NEXT: (lldb) target variable USMin
  60 // CHECK-NEXT: (unsigned short) USMin = 0
  61 int IMax = 2147483647;
  62 // CHECK-NEXT: (lldb) target variable IMax
  63 // CHECK-NEXT: (int) IMax = 2147483647
  64 int IMin = -2147483648;
  65 // CHECK-NEXT: (lldb) target variable IMin
  66 // CHECK-NEXT: (int) IMin = -2147483648
  67 unsigned int UIMax = 4294967295;
  68 // CHECK-NEXT: (lldb) target variable UIMax
  69 // CHECK-NEXT: (unsigned int) UIMax = 4294967295
  70 unsigned int UIMin = 0;
  71 // CHECK-NEXT: (lldb) target variable UIMin
  72 // CHECK-NEXT: (unsigned int) UIMin = 0
  73 long LMax = 2147483647;
  74 // CHECK-NEXT: (lldb) target variable LMax
  75 // CHECK-NEXT: (long) LMax = 2147483647
  76 long LMin = -2147483648;
  77 // CHECK-NEXT: (lldb) target variable LMin
  78 // CHECK-NEXT: (long) LMin = -2147483648
  79 unsigned long ULMax = 4294967295;
  80 // CHECK-NEXT: (lldb) target variable ULMax
  81 // CHECK-NEXT: (unsigned long) ULMax = 4294967295
  82 unsigned long ULMin = 0;
  83 // CHECK-NEXT: (lldb) target variable ULMin
  84 // CHECK-NEXT: (unsigned long) ULMin = 0
  85 long long LLMax = 9223372036854775807LL;
  86 // CHECK-NEXT: (lldb) target variable LLMax
  87 // CHECK-NEXT: (long long) LLMax = 9223372036854775807
  88 long long LLMin = -9223372036854775807i64 - 1;
  89 // CHECK-NEXT: (lldb) target variable LLMin
  90 // CHECK-NEXT: (long long) LLMin = -9223372036854775808
  91 unsigned long long ULLMax = 18446744073709551615ULL;
  92 // CHECK-NEXT: (lldb) target variable ULLMax
  93 // CHECK-NEXT: (unsigned long long) ULLMax = 18446744073709551615
  94 unsigned long long ULLMin = 0;
  95 // CHECK-NEXT: (lldb) target variable ULLMin
  96 // CHECK-NEXT: (unsigned long long) ULLMin = 0
  97 float F = 3.1415f;
  98 // CHECK-NEXT: (lldb) target variable F
  99 // CHECK-NEXT: (float) F = 3.1415
 100 double D = 3.1415;
 101 // CHECK-NEXT: (lldb) target variable D
 102 // CHECK-NEXT: (double) D = 3.1415
 103
 104 const bool CBFalse = false;
 105 // CHECK-NEXT: (lldb) target variable CBFalse
 106 // CHECK-NEXT: (const bool) CBFalse = false
 107 const bool CBTrue = true;
 108 // CHECK-NEXT: (lldb) target variable CBTrue
 109 // CHECK-NEXT: (const bool) CBTrue = true
 110 const char CCA = 'A';
 111 // CHECK-NEXT: (lldb) target variable CCA
 112 // CHECK-NEXT: (const char) CCA = 'A'
 113 const char CCZ = 'Z';
 114 // CHECK-NEXT: (lldb) target variable CCZ
 115 // CHECK-NEXT: (const char) CCZ = 'Z'
 116 const signed char CSCa = 'a';
 117 // CHECK-NEXT: (lldb) target variable CSCa
 118 // CHECK-NEXT: (const signed char) CSCa = 'a'
 119 const signed char CSCz = 'z';
 120 // CHECK-NEXT: (lldb) target variable CSCz
 121 // CHECK-NEXT: (const signed char) CSCz = 'z'
 122 const unsigned char CUC24 = 24;
 123 // CHECK-NEXT: (lldb) target variable CUC24
 124 // CHECK-NEXT: (const unsigned char) CUC24 = '\x18'
 125 const unsigned char CUC42 = 42;
 126 // CHECK-NEXT: (lldb) target variable CUC42
 127 // CHECK-NEXT: (const unsigned char) CUC42 = '*'
 128 const char16_t CC16_24 = u'\24';
 129 // CHECK-NEXT: (lldb) target variable CC16_24
 130 // CHECK-NEXT: (const char16_t) CC16_24 = U+0014
 131 const char32_t CC32_42 = U'\42';
 132 // CHECK-NEXT: (lldb) target variable CC32_42
 133 // CHECK-NEXT: (const char32_t) CC32_42 = U+0x00000022
 134 const wchar_t CWC1 = L'1';
 135 // CHECK-NEXT: (lldb) target variable CWC1
 136 // CHECK-NEXT: (const wchar_t) CWC1 = L'1'
 137 const wchar_t CWCP = L'P';
 138 // CHECK-NEXT: (lldb) target variable CWCP
 139 // CHECK-NEXT: (const wchar_t) CWCP = L'P'
 140 const short CSMax = 32767;
 141 // CHECK-NEXT: (lldb) target variable CSMax
 142 // CHECK-NEXT: (const short) CSMax = 32767
 143 const short CSMin = -32768;
 144 // CHECK-NEXT: (lldb) target variable CSMin
 145 // CHECK-NEXT: (const short) CSMin = -32768
 146 const unsigned short CUSMax = 65535;
 147 // CHECK-NEXT: (lldb) target variable CUSMax
 148 // CHECK-NEXT: (const unsigned short) CUSMax = 65535
 149 const unsigned short CUSMin = 0;
 150 // CHECK-NEXT: (lldb) target variable CUSMin
 151 // CHECK-NEXT: (const unsigned short) CUSMin = 0
 152 const int CIMax = 2147483647;
 153 // CHECK-NEXT: (lldb) target variable CIMax
 154 // CHECK-NEXT: (const int) CIMax = 2147483647
 155 const int CIMin = -2147483648;
 156 // CHECK-NEXT: (lldb) target variable CIMin
 157 // CHECK-NEXT: (const int) CIMin = -2147483648
 158 const unsigned int CUIMax = 4294967295;
 159 // CHECK-NEXT: (lldb) target variable CUIMax
 160 // CHECK-NEXT: (const unsigned int) CUIMax = 4294967295
 161 const unsigned int CUIMin = 0;
 162 // CHECK-NEXT: (lldb) target variable CUIMin
 163 // CHECK-NEXT: (const unsigned int) CUIMin = 0
 164 const long CLMax = 2147483647;
 165 // CHECK-NEXT: (lldb) target variable CLMax
 166 // CHECK-NEXT: (const long) CLMax = 2147483647
 167 const long CLMin = -2147483648;
 168 // CHECK-NEXT: (lldb) target variable CLMin
 169 // CHECK-NEXT: (const long) CLMin = -2147483648
 170 const unsigned long CULMax = 4294967295;
 171 // CHECK-NEXT: (lldb) target variable CULMax
 172 // CHECK-NEXT: (const unsigned long) CULMax = 4294967295
 173 const unsigned long CULMin = 0;
 174 // CHECK-NEXT: (lldb) target variable CULMin
 175 // CHECK-NEXT: (const unsigned long) CULMin = 0
 176 const long long CLLMax = 9223372036854775807i64;
 177 // CHECK-NEXT: (lldb) target variable CLLMax
 178 // CHECK-NEXT: (const long long) CLLMax = 9223372036854775807
 179 const long long CLLMin = -9223372036854775807i64 - 1;
 180 // CHECK-NEXT: (lldb) target variable CLLMin
 181 // CHECK-NEXT: (const long long) CLLMin = -9223372036854775808
 182 const unsigned long long CULLMax = 18446744073709551615ULL;
 183 // CHECK-NEXT: (lldb) target variable CULLMax
 184 // CHECK-NEXT: (const unsigned long long) CULLMax = 18446744073709551615
 185 const unsigned long long CULLMin = 0;
 186 // CHECK-NEXT: (lldb) target variable CULLMin
 187 // CHECK-NEXT: (const unsigned long long) CULLMin = 0
 188 const float CF = 3.1415f;
 189 // CHECK-NEXT: (lldb) target variable CF
 190 // CHECK-NEXT: (const float) CF = 3.1415
 191 const double CD = 3.1415;
 192 // CHECK-NEXT: (lldb) target variable CD
 193 // CHECK-NEXT: (const double) CD = 3.1415
 194
 195 // constexpr fundamental data types.
 196 constexpr bool ConstexprBFalse = false;
 197 // CHECK-NEXT: (lldb) target variable ConstexprBFalse
 198 // CHECK-NEXT: (const bool) ConstexprBFalse = false
 199 constexpr bool ConstexprBTrue = true;
 200 // CHECK-NEXT: (lldb) target variable ConstexprBTrue
 201 // CHECK-NEXT: (const bool) ConstexprBTrue = true
 202 constexpr char ConstexprCA = 'A';
 203 // CHECK-NEXT: (lldb) target variable ConstexprCA
 204 // CHECK-NEXT: (const char) ConstexprCA = 'A'
 205 constexpr char ConstexprCZ = 'Z';
 206 // CHECK-NEXT: (lldb) target variable ConstexprCZ
 207 // CHECK-NEXT: (const char) ConstexprCZ = 'Z'
 208 constexpr signed char ConstexprSCa = 'a';
 209 // CHECK-NEXT: (lldb) target variable ConstexprSCa
 210 // CHECK-NEXT: (const signed char) ConstexprSCa = 'a'
 211 constexpr signed char ConstexprSCz = 'z';
 212 // CHECK-NEXT: (lldb) target variable ConstexprSCz
 213 // CHECK-NEXT: (const signed char) ConstexprSCz = 'z'
 214 constexpr unsigned char ConstexprUC24 = 24;
 215 // CHECK-NEXT: (lldb) target variable ConstexprUC24
 216 // CHECK-NEXT: (const unsigned char) ConstexprUC24 = '\x18'
 217 constexpr unsigned char ConstexprUC42 = 42;
 218 // CHECK-NEXT: (lldb) target variable ConstexprUC42
 219 // CHECK-NEXT: (const unsigned char) ConstexprUC42 = '*'
 220 constexpr char16_t ConstexprC16_24 = u'\24';
 221 // CHECK-NEXT: (lldb) target variable ConstexprC16_24
 222 // CHECK-NEXT: (const char16_t) ConstexprC16_24 = U+0014
 223 constexpr char32_t ConstexprC32_42 = U'\42';
 224 // CHECK-NEXT: (lldb) target variable ConstexprC32_42
 225 // CHECK-NEXT: (const char32_t) ConstexprC32_42 = U+0x00000022
 226 constexpr wchar_t ConstexprWC1 = L'1';
 227 // CHECK-NEXT: (lldb) target variable ConstexprWC1
 228 // CHECK-NEXT: (const wchar_t) ConstexprWC1 = L'1'
 229 constexpr wchar_t ConstexprWCP = L'P';
 230 // CHECK-NEXT: (lldb) target variable ConstexprWCP
 231 // CHECK-NEXT: (const wchar_t) ConstexprWCP = L'P'
 232 constexpr short ConstexprSMax = 32767;
 233 // CHECK-NEXT: (lldb) target variable ConstexprSMax
 234 // CHECK-NEXT: (const short) ConstexprSMax = 32767
 235 constexpr short ConstexprSMin = -32768;
 236 // CHECK-NEXT: (lldb) target variable ConstexprSMin
 237 // CHECK-NEXT: (const short) ConstexprSMin = -32768
 238 constexpr unsigned short ConstexprUSMax = 65535;
 239 // CHECK-NEXT: (lldb) target variable ConstexprUSMax
 240 // CHECK-NEXT: (const unsigned short) ConstexprUSMax = 65535
 241 constexpr unsigned short ConstexprUSMin = 0;
 242 // CHECK-NEXT: (lldb) target variable ConstexprUSMin
 243 // CHECK-NEXT: (const unsigned short) ConstexprUSMin = 0
 244 constexpr int ConstexprIMax = 2147483647;
 245 // CHECK-NEXT: (lldb) target variable ConstexprIMax
 246 // CHECK-NEXT: (const int) ConstexprIMax = 2147483647
 247 constexpr int ConstexprIMin = -2147483648;
 248 // CHECK-NEXT: (lldb) target variable ConstexprIMin
 249 // CHECK-NEXT: (const int) ConstexprIMin = -2147483648
 250 constexpr unsigned int ConstexprUIMax = 4294967295;
 251 // CHECK-NEXT: (lldb) target variable ConstexprUIMax
 252 // CHECK-NEXT: (const unsigned int) ConstexprUIMax = 4294967295
 253 constexpr unsigned int ConstexprUIMin = 0;
 254 // CHECK-NEXT: (lldb) target variable ConstexprUIMin
 255 // CHECK-NEXT: (const unsigned int) ConstexprUIMin = 0
 256 constexpr long ConstexprLMax = 2147483647;
 257 // CHECK-NEXT: (lldb) target variable ConstexprLMax
 258 // CHECK-NEXT: (const long) ConstexprLMax = 2147483647
 259 constexpr long ConstexprLMin = -2147483648;
 260 // CHECK-NEXT: (lldb) target variable ConstexprLMin
 261 // CHECK-NEXT: (const long) ConstexprLMin = -2147483648
 262 constexpr unsigned long ConstexprULMax = 4294967295;
 263 // CHECK-NEXT: (lldb) target variable ConstexprULMax
 264 // CHECK-NEXT: (const unsigned long) ConstexprULMax = 4294967295
 265 constexpr unsigned long ConstexprULMin = 0;
 266 // CHECK-NEXT: (lldb) target variable ConstexprULMin
 267 // CHECK-NEXT: (const unsigned long) ConstexprULMin = 0
 268 constexpr long long ConstexprLLMax = 9223372036854775807i64;
 269 // CHECK-NEXT: (lldb) target variable ConstexprLLMax
 270 // CHECK-NEXT: (const long long) ConstexprLLMax = 9223372036854775807
 271 constexpr long long ConstexprLLMin = -9223372036854775807i64 - 1;
 272 // CHECK-NEXT: (lldb) target variable ConstexprLLMin
 273 // CHECK-NEXT: (const long long) ConstexprLLMin = -9223372036854775808
 274 constexpr unsigned long long ConstexprULLMax = 18446744073709551615ULL;
 275 // CHECK-NEXT: (lldb) target variable ConstexprULLMax
 276 // CHECK-NEXT: (const unsigned long long) ConstexprULLMax = 18446744073709551615
 277 constexpr unsigned long long ConstexprULLMin = 0;
 278 // CHECK-NEXT: (lldb) target variable ConstexprULLMin
 279 // CHECK-NEXT: (const unsigned long long) ConstexprULLMin = 0
 280 constexpr float ConstexprF = 3.1415f;
 281 // CHECK-NEXT: (lldb) target variable ConstexprF
 282 // CHECK-NEXT: (const float) ConstexprF = 3.1415
 283 constexpr double ConstexprD = 3.1415;
 284 // CHECK-NEXT: (lldb) target variable ConstexprD
 285 // CHECK-NEXT: (const double) ConstexprD = 3.1415
 286
 287
 288 // FIXME: LLDB currently doesn't resolve pointers within the target without a
 289 // running process (I haven't checked whether or not it can with a running
 290 // process). So currently it will just print an address, which is unstable and
 291 // should not be relied upon for testing. So for now we're just checking that
 292 // the variable name and type is correct. We should fix this in LLDB and then
 293 // update the tests.
 294 bool *PBFalse = &BFalse;
 295 // CHECK-NEXT: (lldb) target variable PBFalse
 296 // CHECK-NEXT: (bool *) PBFalse = {{.*}}
 297 bool *PBTrue = &BTrue;
 298 // CHECK-NEXT: (lldb) target variable PBTrue
 299 // CHECK-NEXT: (bool *) PBTrue = {{.*}}
 300 char *PCA = &CA;
 301 // CHECK-NEXT: (lldb) target variable PCA
 302 // CHECK-NEXT: (char *) PCA = {{.*}}
 303 char *PCZ = &CZ;
 304 // CHECK-NEXT: (lldb) target variable PCZ
 305 // CHECK-NEXT: (char *) PCZ = {{.*}}
 306 signed char *PSCa = &SCa;
 307 // CHECK-NEXT: (lldb) target variable PSCa
 308 // CHECK-NEXT: (signed char *) PSCa = {{.*}}
 309 signed char *PSCz = &SCz;
 310 // CHECK-NEXT: (lldb) target variable PSCz
 311 // CHECK-NEXT: (signed char *) PSCz = {{.*}}
 312 unsigned char *PUC24 = &UC24;
 313 // CHECK-NEXT: (lldb) target variable PUC24
 314 // CHECK-NEXT: (unsigned char *) PUC24 = {{.*}}
 315 unsigned char *PUC42 = &UC42;
 316 // CHECK-NEXT: (lldb) target variable PUC42
 317 // CHECK-NEXT: (unsigned char *) PUC42 = {{.*}}
 318 char16_t *PC16_24 = &C16_24;
 319 // CHECK-NEXT: (lldb) target variable PC16_24
 320 // CHECK-NEXT: (char16_t *) PC16_24 = {{.*}}
 321 char32_t *PC32_42 = &C32_42;
 322 // CHECK-NEXT: (lldb) target variable PC32_42
 323 // CHECK-NEXT: (char32_t *) PC32_42 = {{.*}}
 324 wchar_t *PWC1 = &WC1;
 325 // CHECK-NEXT: (lldb) target variable PWC1
 326 // CHECK-NEXT: (wchar_t *) PWC1 = {{.*}}
 327 wchar_t *PWCP = &WCP;
 328 // CHECK-NEXT: (lldb) target variable PWCP
 329 // CHECK-NEXT: (wchar_t *) PWCP = {{.*}}
 330 short *PSMax = &SMax;
 331 // CHECK-NEXT: (lldb) target variable PSMax
 332 // CHECK-NEXT: (short *) PSMax = {{.*}}
 333 short *PSMin = &SMin;
 334 // CHECK-NEXT: (lldb) target variable PSMin
 335 // CHECK-NEXT: (short *) PSMin = {{.*}}
 336 unsigned short *PUSMax = &USMax;
 337 // CHECK-NEXT: (lldb) target variable PUSMax
 338 // CHECK-NEXT: (unsigned short *) PUSMax = {{.*}}
 339 unsigned short *PUSMin = &USMin;
 340 // CHECK-NEXT: (lldb) target variable PUSMin
 341 // CHECK-NEXT: (unsigned short *) PUSMin = {{.*}}
 342 int *PIMax = &IMax;
 343 // CHECK-NEXT: (lldb) target variable PIMax
 344 // CHECK-NEXT: (int *) PIMax = {{.*}}
 345 int *PIMin = &IMin;
 346 // CHECK-NEXT: (lldb) target variable PIMin
 347 // CHECK-NEXT: (int *) PIMin = {{.*}}
 348 unsigned int *PUIMax = &UIMax;
 349 // CHECK-NEXT: (lldb) target variable PUIMax
 350 // CHECK-NEXT: (unsigned int *) PUIMax = {{.*}}
 351 unsigned int *PUIMin = &UIMin;
 352 // CHECK-NEXT: (lldb) target variable PUIMin
 353 // CHECK-NEXT: (unsigned int *) PUIMin = {{.*}}
 354 long *PLMax = &LMax;
 355 // CHECK-NEXT: (lldb) target variable PLMax
 356 // CHECK-NEXT: (long *) PLMax = {{.*}}
 357 long *PLMin = &LMin;
 358 // CHECK-NEXT: (lldb) target variable PLMin
 359 // CHECK-NEXT: (long *) PLMin = {{.*}}
 360 unsigned long *PULMax = &ULMax;
 361 // CHECK-NEXT: (lldb) target variable PULMax
 362 // CHECK-NEXT: (unsigned long *) PULMax = {{.*}}
 363 unsigned long *PULMin = &ULMin;
 364 // CHECK-NEXT: (lldb) target variable PULMin
 365 // CHECK-NEXT: (unsigned long *) PULMin = {{.*}}
 366 long long *PLLMax = &LLMax;
 367 // CHECK-NEXT: (lldb) target variable PLLMax
 368 // CHECK-NEXT: (long long *) PLLMax = {{.*}}
 369 long long *PLLMin = &LLMin;
 370 // CHECK-NEXT: (lldb) target variable PLLMin
 371 // CHECK-NEXT: (long long *) PLLMin = {{.*}}
 372 unsigned long long *PULLMax = &ULLMax;
 373 // CHECK-NEXT: (lldb) target variable PULLMax
 374 // CHECK-NEXT: (unsigned long long *) PULLMax = {{.*}}
 375 unsigned long long *PULLMin = &ULLMin;
 376 // CHECK-NEXT: (lldb) target variable PULLMin
 377 // CHECK-NEXT: (unsigned long long *) PULLMin = {{.*}}
 378 float *PF = &F;
 379 // CHECK-NEXT: (lldb) target variable PF
 380 // CHECK-NEXT: (float *) PF = {{.*}}
 381 double *PD = &D;
 382 // CHECK-NEXT: (lldb) target variable PD
 383 // CHECK-NEXT: (double *) PD = {{.*}}
 384
 385 // Const pointers to fundamental data types
 386 const bool *CPBFalse = &BFalse;
 387 // CHECK-NEXT: (lldb) target variable CPBFalse
 388 // CHECK-NEXT: (const bool *) CPBFalse = {{.*}}
 389 const bool *CPBTrue = &BTrue;
 390 // CHECK-NEXT: (lldb) target variable CPBTrue
 391 // CHECK-NEXT: (const bool *) CPBTrue = {{.*}}
 392 const char *CPCA = &CA;
 393 // CHECK-NEXT: (lldb) target variable CPCA
 394 // CHECK-NEXT: (const char *) CPCA = {{.*}}
 395 const char *CPCZ = &CZ;
 396 // CHECK-NEXT: (lldb) target variable CPCZ
 397 // CHECK-NEXT: (const char *) CPCZ = {{.*}}
 398 const signed char *CPSCa = &SCa;
 399 // CHECK-NEXT: (lldb) target variable CPSCa
 400 // CHECK-NEXT: (const signed char *) CPSCa = {{.*}}
 401 const signed char *CPSCz = &SCz;
 402 // CHECK-NEXT: (lldb) target variable CPSCz
 403 // CHECK-NEXT: (const signed char *) CPSCz = {{.*}}
 404 const unsigned char *CPUC24 = &UC24;
 405 // CHECK-NEXT: (lldb) target variable CPUC24
 406 // CHECK-NEXT: (const unsigned char *) CPUC24 = {{.*}}
 407 const unsigned char *CPUC42 = &UC42;
 408 // CHECK-NEXT: (lldb) target variable CPUC42
 409 // CHECK-NEXT: (const unsigned char *) CPUC42 = {{.*}}
 410 const char16_t *CPC16_24 = &C16_24;
 411 // CHECK-NEXT: (lldb) target variable CPC16_24
 412 // CHECK-NEXT: (const char16_t *) CPC16_24 = {{.*}}
 413 const char32_t *CPC32_42 = &C32_42;
 414 // CHECK-NEXT: (lldb) target variable CPC32_42
 415 // CHECK-NEXT: (const char32_t *) CPC32_42 = {{.*}}
 416 const wchar_t *CPWC1 = &WC1;
 417 // CHECK-NEXT: (lldb) target variable CPWC1
 418 // CHECK-NEXT: (const wchar_t *) CPWC1 = {{.*}}
 419 const wchar_t *CPWCP = &WCP;
 420 // CHECK-NEXT: (lldb) target variable CPWCP
 421 // CHECK-NEXT: (const wchar_t *) CPWCP = {{.*}}
 422 const short *CPSMax = &SMax;
 423 // CHECK-NEXT: (lldb) target variable CPSMax
 424 // CHECK-NEXT: (const short *) CPSMax = {{.*}}
 425 const short *CPSMin = &SMin;
 426 // CHECK-NEXT: (lldb) target variable CPSMin
 427 // CHECK-NEXT: (const short *) CPSMin = {{.*}}
 428 const unsigned short *CPUSMax = &USMax;
 429 // CHECK-NEXT: (lldb) target variable CPUSMax
 430 // CHECK-NEXT: (const unsigned short *) CPUSMax = {{.*}}
 431 const unsigned short *CPUSMin = &USMin;
 432 // CHECK-NEXT: (lldb) target variable CPUSMin
 433 // CHECK-NEXT: (const unsigned short *) CPUSMin = {{.*}}
 434 const int *CPIMax = &IMax;
 435 // CHECK-NEXT: (lldb) target variable CPIMax
 436 // CHECK-NEXT: (const int *) CPIMax = {{.*}}
 437 const int *CPIMin = &IMin;
 438 // CHECK-NEXT: (lldb) target variable CPIMin
 439 // CHECK-NEXT: (const int *) CPIMin = {{.*}}
 440 const unsigned int *CPUIMax = &UIMax;
 441 // CHECK-NEXT: (lldb) target variable CPUIMax
 442 // CHECK-NEXT: (const unsigned int *) CPUIMax = {{.*}}
 443 const unsigned int *CPUIMin = &UIMin;
 444 // CHECK-NEXT: (lldb) target variable CPUIMin
 445 // CHECK-NEXT: (const unsigned int *) CPUIMin = {{.*}}
 446 const long *CPLMax = &LMax;
 447 // CHECK-NEXT: (lldb) target variable CPLMax
 448 // CHECK-NEXT: (const long *) CPLMax = {{.*}}
 449 const long *CPLMin = &LMin;
 450 // CHECK-NEXT: (lldb) target variable CPLMin
 451 // CHECK-NEXT: (const long *) CPLMin = {{.*}}
 452 const unsigned long *CPULMax = &ULMax;
 453 // CHECK-NEXT: (lldb) target variable CPULMax
 454 // CHECK-NEXT: (const unsigned long *) CPULMax = {{.*}}
 455 const unsigned long *CPULMin = &ULMin;
 456 // CHECK-NEXT: (lldb) target variable CPULMin
 457 // CHECK-NEXT: (const unsigned long *) CPULMin = {{.*}}
 458 const long long *CPLLMax = &LLMax;
 459 // CHECK-NEXT: (lldb) target variable CPLLMax
 460 // CHECK-NEXT: (const long long *) CPLLMax = {{.*}}
 461 const long long *CPLLMin = &LLMin;
 462 // CHECK-NEXT: (lldb) target variable CPLLMin
 463 // CHECK-NEXT: (const long long *) CPLLMin = {{.*}}
 464 const unsigned long long *CPULLMax = &ULLMax;
 465 // CHECK-NEXT: (lldb) target variable CPULLMax
 466 // CHECK-NEXT: (const unsigned long long *) CPULLMax = {{.*}}
 467 const unsigned long long *CPULLMin = &ULLMin;
 468 // CHECK-NEXT: (lldb) target variable CPULLMin
 469 // CHECK-NEXT: (const unsigned long long *) CPULLMin = {{.*}}
 470 const float *CPF = &F;
 471 // CHECK-NEXT: (lldb) target variable CPF
 472 // CHECK-NEXT: (const float *) CPF = {{.*}}
 473 const double *CPD = &D;
 474 // CHECK-NEXT: (lldb) target variable CPD
 475 // CHECK-NEXT: (const double *) CPD = {{.*}}
 476
 477
 478 // References to fundamental data types
 479
 480 bool &RBFalse = BFalse;
 481 // CHECK-NEXT: (lldb) target variable RBFalse
 482 // CHECK-NEXT: (bool &) RBFalse = {{.*}} (&::RBFalse = false)
 483 bool &RBTrue = BTrue;
 484 // CHECK-NEXT: (lldb) target variable RBTrue
 485 // CHECK-NEXT: (bool &) RBTrue = {{.*}} (&::RBTrue = true)
 486 char &RCA = CA;
 487 // CHECK-NEXT: (lldb) target variable RCA
 488 // CHECK-NEXT: (char &) RCA = {{.*}} (&::RCA = 'A')
 489 char &RCZ = CZ;
 490 // CHECK-NEXT: (lldb) target variable RCZ
 491 // CHECK-NEXT: (char &) RCZ = {{.*}} (&::RCZ = 'Z')
 492 signed char &RSCa = SCa;
 493 // CHECK-NEXT: (lldb) target variable RSCa
 494 // CHECK-NEXT: (signed char &) RSCa = {{.*}} (&::RSCa = 'a')
 495 signed char &RSCz = SCz;
 496 // CHECK-NEXT: (lldb) target variable RSCz
 497 // CHECK-NEXT: (signed char &) RSCz = {{.*}} (&::RSCz = 'z')
 498 unsigned char &RUC24 = UC24;
 499 // CHECK-NEXT: (lldb) target variable RUC24
 500 // CHECK-NEXT: (unsigned char &) RUC24 = {{.*}} (&::RUC24 = '\x18')
 501 unsigned char &RUC42 = UC42;
 502 // CHECK-NEXT: (lldb) target variable RUC42
 503 // CHECK-NEXT: (unsigned char &) RUC42 = {{.*}} (&::RUC42 = '*')
 504 short &RSMax = SMax;
 505 // CHECK-NEXT: (lldb) target variable RSMax
 506 // CHECK-NEXT: (short &) RSMax = {{.*}} (&::RSMax = 32767)
 507 short &RSMin = SMin;
 508 // CHECK-NEXT: (lldb) target variable RSMin
 509 // CHECK-NEXT: (short &) RSMin = {{.*}} (&::RSMin = -32768)
 510 unsigned short &RUSMax = USMax;
 511 // CHECK-NEXT: (lldb) target variable RUSMax
 512 // CHECK-NEXT: (unsigned short &) RUSMax = {{.*}} (&::RUSMax = 65535)
 513 unsigned short &RUSMin = USMin;
 514 // CHECK-NEXT: (lldb) target variable RUSMin
 515 // CHECK-NEXT: (unsigned short &) RUSMin = {{.*}} (&::RUSMin = 0)
 516 int &RIMax = IMax;
 517 // CHECK-NEXT: (lldb) target variable RIMax
 518 // CHECK-NEXT: (int &) RIMax = {{.*}} (&::RIMax = 2147483647)
 519 int &RIMin = IMin;
 520 // CHECK-NEXT: (lldb) target variable RIMin
 521 // CHECK-NEXT: (int &) RIMin = {{.*}} (&::RIMin = -2147483648)
 522 unsigned int &RUIMax = UIMax;
 523 // CHECK-NEXT: (lldb) target variable RUIMax
 524 // CHECK-NEXT: (unsigned int &) RUIMax = {{.*}} (&::RUIMax = 4294967295)
 525 unsigned int &RUIMin = UIMin;
 526 // CHECK-NEXT: (lldb) target variable RUIMin
 527 // CHECK-NEXT: (unsigned int &) RUIMin = {{.*}} (&::RUIMin = 0)
 528 long &RLMax = LMax;
 529 // CHECK-NEXT: (lldb) target variable RLMax
 530 // CHECK-NEXT: (long &) RLMax = {{.*}} (&::RLMax = 2147483647)
 531 long &RLMin = LMin;
 532 // CHECK-NEXT: (lldb) target variable RLMin
 533 // CHECK-NEXT: (long &) RLMin = {{.*}} (&::RLMin = -2147483648)
 534 unsigned long &RULMax = ULMax;
 535 // CHECK-NEXT: (lldb) target variable RULMax
 536 // CHECK-NEXT: (unsigned long &) RULMax = {{.*}} (&::RULMax = 4294967295)
 537 unsigned long &RULMin = ULMin;
 538 // CHECK-NEXT: (lldb) target variable RULMin
 539 // CHECK-NEXT: (unsigned long &) RULMin = {{.*}} (&::RULMin = 0)
 540 long long &RLLMax = LLMax;
 541 // CHECK-NEXT: (lldb) target variable RLLMax
 542 // CHECK-NEXT: (long long &) RLLMax = {{.*}} (&::RLLMax = 9223372036854775807)
 543 long long &RLLMin = LLMin;
 544 // CHECK-NEXT: (lldb) target variable RLLMin
 545 // CHECK-NEXT: (long long &) RLLMin = {{.*}} (&::RLLMin = -9223372036854775808)
 546 unsigned long long &RULLMax = ULLMax;
 547 // CHECK-NEXT: (lldb) target variable RULLMax
 548 // CHECK-NEXT: (unsigned long long &) RULLMax = {{.*}} (&::RULLMax = 18446744073709551615)
 549 unsigned long long &RULLMin = ULLMin;
 550 // CHECK-NEXT: (lldb) target variable RULLMin
 551 // CHECK-NEXT: (unsigned long long &) RULLMin = {{.*}} (&::RULLMin = 0)
 552 float &RF = F;
 553 // CHECK-NEXT: (lldb) target variable RF
 554 // CHECK-NEXT: (float &) RF = {{.*}} (&::RF = 3.1415)
 555 double &RD = D;
 556 // CHECK-NEXT: (lldb) target variable RD
 557 // CHECK-NEXT: (double &) RD = {{.*}} (&::RD = 3.1415000000000002)
 558
 559 // const references to fundamental data types
 560 const bool &CRBFalse = BFalse;
 561 // CHECK-NEXT: (lldb) target variable CRBFalse
 562 // CHECK-NEXT: (const bool &) CRBFalse = {{.*}} (&::CRBFalse = false)
 563 const bool &CRBTrue = BTrue;
 564 // CHECK-NEXT: (lldb) target variable CRBTrue
 565 // CHECK-NEXT: (const bool &) CRBTrue = {{.*}} (&::CRBTrue = true)
 566 const char &CRCA = CA;
 567 // CHECK-NEXT: (lldb) target variable CRCA
 568 // CHECK-NEXT: (const char &) CRCA = {{.*}} (&::CRCA = 'A')
 569 const char &CRCZ = CZ;
 570 // CHECK-NEXT: (lldb) target variable CRCZ
 571 // CHECK-NEXT: (const char &) CRCZ = {{.*}} (&::CRCZ = 'Z')
 572 const signed char &CRSCa = SCa;
 573 // CHECK-NEXT: (lldb) target variable CRSCa
 574 // CHECK-NEXT: (const signed char &) CRSCa = {{.*}} (&::CRSCa = 'a')
 575 const signed char &CRSCz = SCz;
 576 // CHECK-NEXT: (lldb) target variable CRSCz
 577 // CHECK-NEXT: (const signed char &) CRSCz = {{.*}} (&::CRSCz = 'z')
 578 const unsigned char &CRUC24 = UC24;
 579 // CHECK-NEXT: (lldb) target variable CRUC24
 580 // CHECK-NEXT: (const unsigned char &) CRUC24 = {{.*}} (&::CRUC24 = '\x18')
 581 const unsigned char &CRUC42 = UC42;
 582 // CHECK-NEXT: (lldb) target variable CRUC42
 583 // CHECK-NEXT: (const unsigned char &) CRUC42 = {{.*}} (&::CRUC42 = '*')
 584 const short &CRSMax = SMax;
 585 // CHECK-NEXT: (lldb) target variable CRSMax
 586 // CHECK-NEXT: (const short &) CRSMax = {{.*}} (&::CRSMax = 32767)
 587 const short &CRSMin = SMin;
 588 // CHECK-NEXT: (lldb) target variable CRSMin
 589 // CHECK-NEXT: (const short &) CRSMin = {{.*}} (&::CRSMin = -32768)
 590 const unsigned short &CRUSMax = USMax;
 591 // CHECK-NEXT: (lldb) target variable CRUSMax
 592 // CHECK-NEXT: (const unsigned short &) CRUSMax = {{.*}} (&::CRUSMax = 65535)
 593 const unsigned short &CRUSMin = USMin;
 594 // CHECK-NEXT: (lldb) target variable CRUSMin
 595 // CHECK-NEXT: (const unsigned short &) CRUSMin = {{.*}} (&::CRUSMin = 0)
 596 const int &CRIMax = IMax;
 597 // CHECK-NEXT: (lldb) target variable CRIMax
 598 // CHECK-NEXT: (const int &) CRIMax = {{.*}} (&::CRIMax = 2147483647)
 599 const int &CRIMin = IMin;
 600 // CHECK-NEXT: (lldb) target variable CRIMin
 601 // CHECK-NEXT: (const int &) CRIMin = {{.*}} (&::CRIMin = -2147483648)
 602 const unsigned int &CRUIMax = UIMax;
 603 // CHECK-NEXT: (lldb) target variable CRUIMax
 604 // CHECK-NEXT: (const unsigned int &) CRUIMax = {{.*}} (&::CRUIMax = 4294967295)
 605 const unsigned int &CRUIMin = UIMin;
 606 // CHECK-NEXT: (lldb) target variable CRUIMin
 607 // CHECK-NEXT: (const unsigned int &) CRUIMin = {{.*}} (&::CRUIMin = 0)
 608 const long &CRLMax = LMax;
 609 // CHECK-NEXT: (lldb) target variable CRLMax
 610 // CHECK-NEXT: (const long &) CRLMax = {{.*}} (&::CRLMax = 2147483647)
 611 const long &CRLMin = LMin;
 612 // CHECK-NEXT: (lldb) target variable CRLMin
 613 // CHECK-NEXT: (const long &) CRLMin = {{.*}} (&::CRLMin = -2147483648)
 614 const unsigned long &CRULMax = ULMax;
 615 // CHECK-NEXT: (lldb) target variable CRULMax
 616 // CHECK-NEXT: (const unsigned long &) CRULMax = {{.*}} (&::CRULMax = 4294967295)
 617 const unsigned long &CRULMin = ULMin;
 618 // CHECK-NEXT: (lldb) target variable CRULMin
 619 // CHECK-NEXT: (const unsigned long &) CRULMin = {{.*}} (&::CRULMin = 0)
 620 const long long &CRLLMax = LLMax;
 621 // CHECK-NEXT: (lldb) target variable CRLLMax
 622 // CHECK-NEXT: (const long long &) CRLLMax = {{.*}} (&::CRLLMax = 9223372036854775807)
 623 const long long &CRLLMin = LLMin;
 624 // CHECK-NEXT: (lldb) target variable CRLLMin
 625 // CHECK-NEXT: (const long long &) CRLLMin = {{.*}} (&::CRLLMin = -9223372036854775808)
 626 const unsigned long long &CRULLMax = ULLMax;
 627 // CHECK-NEXT: (lldb) target variable CRULLMax
 628 // CHECK-NEXT: (const unsigned long long &) CRULLMax = {{.*}} (&::CRULLMax = 18446744073709551615)
 629 const unsigned long long &CRULLMin = ULLMin;
 630 // CHECK-NEXT: (lldb) target variable CRULLMin
 631 // CHECK-NEXT: (const unsigned long long &) CRULLMin = {{.*}} (&::CRULLMin = 0)
 632 const float &CRF = F;
 633 // CHECK-NEXT: (lldb) target variable CRF
 634 // CHECK-NEXT: (const float &) CRF = {{.*}} (&::CRF = 3.1415)
 635 const double &CRD = D;
 636 // CHECK-NEXT: (lldb) target variable CRD
 637 // CHECK-NEXT: (const double &) CRD = {{.*}} (&::CRD = 3.1415000000000002)
 638
 639 char16_t &RC16_24 = C16_24;
 640 // CHECK: (lldb) target variable RC16_24
 641 // FIXME: (char16_t &) RC16_24 = {{.*}} (&::RC16_24 = U+0014)
 642 char32_t &RC32_42 = C32_42;
 643 // CHECK: (lldb) target variable RC32_42
 644 // FIXME: (char32_t &) RC32_42 = {{.*}} (&::RC32_42 = U+0x00000022)
 645 wchar_t &RWC1 = WC1;
 646 // CHECK: (lldb) target variable RWC1
 647 // FIXME: (wchar_t &) RWC1 = {{.*}} (&::RWC1 = L'1')
 648 wchar_t &RWCP = WCP;
 649 // CHECK: (lldb) target variable RWCP
 650 // FIXME: (wchar_t &) RWCP = {{.*}} (&::RWCP = L'P')
 651 const char16_t &CRC16_24 = C16_24;
 652 // CHECK: (lldb) target variable CRC16_24
 653 // FIXME: (const char16_t &) CRC16_24 = {{.*}} (&::CRC16_24 = U+0014)
 654 const char32_t &CRC32_42 = C32_42;
 655 // CHECK: (lldb) target variable CRC32_42
 656 // FIXME: (const char32_t &) CRC32_42 = {{.*}} (&::CRC32_42 = U+0x00000022)
 657 const wchar_t &CRWC1 = WC1;
 658 // CHECK: (lldb) target variable CRWC1
 659 // FIXME: (const wchar_t &) CRWC1 = {{.*}} (&::CRWC1 = L'1')
 660 const wchar_t &CRWCP = WCP;
 661 // CHECK: (lldb) target variable CRWCP
 662 // FIXME: (const wchar_t &) CRWCP = {{.*}} (&::CRWCP = L'P')
 663
 664
 665 // CHECK:      TranslationUnitDecl {{.*}}
 666 // CHECK-NEXT: |-VarDecl {{.*}} BFalse 'bool'
 667 // CHECK-NEXT: |-VarDecl {{.*}} BTrue 'bool'
 668 // CHECK-NEXT: |-VarDecl {{.*}} CA 'char'
 669 // CHECK-NEXT: |-VarDecl {{.*}} CZ 'char'
 670 // CHECK-NEXT: |-VarDecl {{.*}} SCa 'signed char'
 671 // CHECK-NEXT: |-VarDecl {{.*}} SCz 'signed char'
 672 // CHECK-NEXT: |-VarDecl {{.*}} UC24 'unsigned char'
 673 // CHECK-NEXT: |-VarDecl {{.*}} UC42 'unsigned char'
 674 // CHECK-NEXT: |-VarDecl {{.*}} C16_24 'char16_t'
 675 // CHECK-NEXT: |-VarDecl {{.*}} C32_42 'char32_t'
 676 // CHECK-NEXT: |-VarDecl {{.*}} WC1 'wchar_t'
 677 // CHECK-NEXT: |-VarDecl {{.*}} WCP 'wchar_t'
 678 // CHECK-NEXT: |-VarDecl {{.*}} SMax 'short'
 679 // CHECK-NEXT: |-VarDecl {{.*}} SMin 'short'
 680 // CHECK-NEXT: |-VarDecl {{.*}} USMax 'unsigned short'
 681 // CHECK-NEXT: |-VarDecl {{.*}} USMin 'unsigned short'
 682 // CHECK-NEXT: |-VarDecl {{.*}} IMax 'int'
 683 // CHECK-NEXT: |-VarDecl {{.*}} IMin 'int'
 684 // CHECK-NEXT: |-VarDecl {{.*}} UIMax 'unsigned int'
 685 // CHECK-NEXT: |-VarDecl {{.*}} UIMin 'unsigned int'
 686 // CHECK-NEXT: |-VarDecl {{.*}} LMax 'long'
 687 // CHECK-NEXT: |-VarDecl {{.*}} LMin 'long'
 688 // CHECK-NEXT: |-VarDecl {{.*}} ULMax 'unsigned long'
 689 // CHECK-NEXT: |-VarDecl {{.*}} ULMin 'unsigned long'
 690 // CHECK-NEXT: |-VarDecl {{.*}} LLMax 'long long'
 691 // CHECK-NEXT: |-VarDecl {{.*}} LLMin 'long long'
 692 // CHECK-NEXT: |-VarDecl {{.*}} ULLMax 'unsigned long long'
 693 // CHECK-NEXT: |-VarDecl {{.*}} ULLMin 'unsigned long long'
 694 // CHECK-NEXT: |-VarDecl {{.*}} F 'float'
 695 // CHECK-NEXT: |-VarDecl {{.*}} D 'double'
 696 // CHECK-NEXT: |-VarDecl {{.*}} CBFalse 'const bool'
 697 // CHECK-NEXT: |-VarDecl {{.*}} CBTrue 'const bool'
 698 // CHECK-NEXT: |-VarDecl {{.*}} CCA 'const char'
 699 // CHECK-NEXT: |-VarDecl {{.*}} CCZ 'const char'
 700 // CHECK-NEXT: |-VarDecl {{.*}} CSCa 'const signed char'
 701 // CHECK-NEXT: |-VarDecl {{.*}} CSCz 'const signed char'
 702 // CHECK-NEXT: |-VarDecl {{.*}} CUC24 'const unsigned char'
 703 // CHECK-NEXT: |-VarDecl {{.*}} CUC42 'const unsigned char'
 704 // CHECK-NEXT: |-VarDecl {{.*}} CC16_24 'const char16_t'
 705 // CHECK-NEXT: |-VarDecl {{.*}} CC32_42 'const char32_t'
 706 // CHECK-NEXT: |-VarDecl {{.*}} CWC1 'const wchar_t'
 707 // CHECK-NEXT: |-VarDecl {{.*}} CWCP 'const wchar_t'
 708 // CHECK-NEXT: |-VarDecl {{.*}} CSMax 'const short'
 709 // CHECK-NEXT: |-VarDecl {{.*}} CSMin 'const short'
 710 // CHECK-NEXT: |-VarDecl {{.*}} CUSMax 'const unsigned short'
 711 // CHECK-NEXT: |-VarDecl {{.*}} CUSMin 'const unsigned short'
 712 // CHECK-NEXT: |-VarDecl {{.*}} CIMax 'const int'
 713 // CHECK-NEXT: |-VarDecl {{.*}} CIMin 'const int'
 714 // CHECK-NEXT: |-VarDecl {{.*}} CUIMax 'const unsigned int'
 715 // CHECK-NEXT: |-VarDecl {{.*}} CUIMin 'const unsigned int'
 716 // CHECK-NEXT: |-VarDecl {{.*}} CLMax 'const long'
 717 // CHECK-NEXT: |-VarDecl {{.*}} CLMin 'const long'
 718 // CHECK-NEXT: |-VarDecl {{.*}} CULMax 'const unsigned long'
 719 // CHECK-NEXT: |-VarDecl {{.*}} CULMin 'const unsigned long'
 720 // CHECK-NEXT: |-VarDecl {{.*}} CLLMax 'const long long'
 721 // CHECK-NEXT: |-VarDecl {{.*}} CLLMin 'const long long'
 722 // CHECK-NEXT: |-VarDecl {{.*}} CULLMax 'const unsigned long long'
 723 // CHECK-NEXT: |-VarDecl {{.*}} CULLMin 'const unsigned long long'
 724 // CHECK-NEXT: |-VarDecl {{.*}} CF 'const float'
 725 // CHECK-NEXT: |-VarDecl {{.*}} CD 'const double'
 726 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprBFalse 'const bool'
 727 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprBTrue 'const bool'
 728 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprCA 'const char'
 729 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprCZ 'const char'
 730 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprSCa 'const signed char'
 731 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprSCz 'const signed char'
 732 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprUC24 'const unsigned char'
 733 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprUC42 'const unsigned char'
 734 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprC16_24 'const char16_t'
 735 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprC32_42 'const char32_t'
 736 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprWC1 'const wchar_t'
 737 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprWCP 'const wchar_t'
 738 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprSMax 'const short'
 739 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprSMin 'const short'
 740 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprUSMax 'const unsigned short'
 741 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprUSMin 'const unsigned short'
 742 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprIMax 'const int'
 743 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprIMin 'const int'
 744 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprUIMax 'const unsigned int'
 745 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprUIMin 'const unsigned int'
 746 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprLMax 'const long'
 747 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprLMin 'const long'
 748 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprULMax 'const unsigned long'
 749 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprULMin 'const unsigned long'
 750 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprLLMax 'const long long'
 751 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprLLMin 'const long long'
 752 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprULLMax 'const unsigned long long'
 753 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprULLMin 'const unsigned long long'
 754 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprF 'const float'
 755 // CHECK-NEXT: |-VarDecl {{.*}} ConstexprD 'const double'
 756 // CHECK-NEXT: |-VarDecl {{.*}} PBFalse 'bool *'
 757 // CHECK-NEXT: |-VarDecl {{.*}} PBTrue 'bool *'
 758 // CHECK-NEXT: |-VarDecl {{.*}} PCA 'char *'
 759 // CHECK-NEXT: |-VarDecl {{.*}} PCZ 'char *'
 760 // CHECK-NEXT: |-VarDecl {{.*}} PSCa 'signed char *'
 761 // CHECK-NEXT: |-VarDecl {{.*}} PSCz 'signed char *'
 762 // CHECK-NEXT: |-VarDecl {{.*}} PUC24 'unsigned char *'
 763 // CHECK-NEXT: |-VarDecl {{.*}} PUC42 'unsigned char *'
 764 // CHECK-NEXT: |-VarDecl {{.*}} PC16_24 'char16_t *'
 765 // CHECK-NEXT: |-VarDecl {{.*}} PC32_42 'char32_t *'
 766 // CHECK-NEXT: |-VarDecl {{.*}} PWC1 'wchar_t *'
 767 // CHECK-NEXT: |-VarDecl {{.*}} PWCP 'wchar_t *'
 768 // CHECK-NEXT: |-VarDecl {{.*}} PSMax 'short *'
 769 // CHECK-NEXT: |-VarDecl {{.*}} PSMin 'short *'
 770 // CHECK-NEXT: |-VarDecl {{.*}} PUSMax 'unsigned short *'
 771 // CHECK-NEXT: |-VarDecl {{.*}} PUSMin 'unsigned short *'
 772 // CHECK-NEXT: |-VarDecl {{.*}} PIMax 'int *'
 773 // CHECK-NEXT: |-VarDecl {{.*}} PIMin 'int *'
 774 // CHECK-NEXT: |-VarDecl {{.*}} PUIMax 'unsigned int *'
 775 // CHECK-NEXT: |-VarDecl {{.*}} PUIMin 'unsigned int *'
 776 // CHECK-NEXT: |-VarDecl {{.*}} PLMax 'long *'
 777 // CHECK-NEXT: |-VarDecl {{.*}} PLMin 'long *'
 778 // CHECK-NEXT: |-VarDecl {{.*}} PULMax 'unsigned long *'
 779 // CHECK-NEXT: |-VarDecl {{.*}} PULMin 'unsigned long *'
 780 // CHECK-NEXT: |-VarDecl {{.*}} PLLMax 'long long *'
 781 // CHECK-NEXT: |-VarDecl {{.*}} PLLMin 'long long *'
 782 // CHECK-NEXT: |-VarDecl {{.*}} PULLMax 'unsigned long long *'
 783 // CHECK-NEXT: |-VarDecl {{.*}} PULLMin 'unsigned long long *'
 784 // CHECK-NEXT: |-VarDecl {{.*}} PF 'float *'
 785 // CHECK-NEXT: |-VarDecl {{.*}} PD 'double *'
 786 // CHECK-NEXT: |-VarDecl {{.*}} CPBFalse 'const bool *'
 787 // CHECK-NEXT: |-VarDecl {{.*}} CPBTrue 'const bool *'
 788 // CHECK-NEXT: |-VarDecl {{.*}} CPCA 'const char *'
 789 // CHECK-NEXT: |-VarDecl {{.*}} CPCZ 'const char *'
 790 // CHECK-NEXT: |-VarDecl {{.*}} CPSCa 'const signed char *'
 791 // CHECK-NEXT: |-VarDecl {{.*}} CPSCz 'const signed char *'
 792 // CHECK-NEXT: |-VarDecl {{.*}} CPUC24 'const unsigned char *'
 793 // CHECK-NEXT: |-VarDecl {{.*}} CPUC42 'const unsigned char *'
 794 // CHECK-NEXT: |-VarDecl {{.*}} CPC16_24 'const char16_t *'
 795 // CHECK-NEXT: |-VarDecl {{.*}} CPC32_42 'const char32_t *'
 796 // CHECK-NEXT: |-VarDecl {{.*}} CPWC1 'const wchar_t *'
 797 // CHECK-NEXT: |-VarDecl {{.*}} CPWCP 'const wchar_t *'
 798 // CHECK-NEXT: |-VarDecl {{.*}} CPSMax 'const short *'
 799 // CHECK-NEXT: |-VarDecl {{.*}} CPSMin 'const short *'
 800 // CHECK-NEXT: |-VarDecl {{.*}} CPUSMax 'const unsigned short *'
 801 // CHECK-NEXT: |-VarDecl {{.*}} CPUSMin 'const unsigned short *'
 802 // CHECK-NEXT: |-VarDecl {{.*}} CPIMax 'const int *'
 803 // CHECK-NEXT: |-VarDecl {{.*}} CPIMin 'const int *'
 804 // CHECK-NEXT: |-VarDecl {{.*}} CPUIMax 'const unsigned int *'
 805 // CHECK-NEXT: |-VarDecl {{.*}} CPUIMin 'const unsigned int *'
 806 // CHECK-NEXT: |-VarDecl {{.*}} CPLMax 'const long *'
 807 // CHECK-NEXT: |-VarDecl {{.*}} CPLMin 'const long *'
 808 // CHECK-NEXT: |-VarDecl {{.*}} CPULMax 'const unsigned long *'
 809 // CHECK-NEXT: |-VarDecl {{.*}} CPULMin 'const unsigned long *'
 810 // CHECK-NEXT: |-VarDecl {{.*}} CPLLMax 'const long long *'
 811 // CHECK-NEXT: |-VarDecl {{.*}} CPLLMin 'const long long *'
 812 // CHECK-NEXT: |-VarDecl {{.*}} CPULLMax 'const unsigned long long *'
 813 // CHECK-NEXT: |-VarDecl {{.*}} CPULLMin 'const unsigned long long *'
 814 // CHECK-NEXT: |-VarDecl {{.*}} CPF 'const float *'
 815 // CHECK-NEXT: |-VarDecl {{.*}} CPD 'const double *'
 816 // CHECK-NEXT: |-VarDecl {{.*}} RBFalse 'bool &'
 817 // CHECK-NEXT: |-VarDecl {{.*}} RBTrue 'bool &'
 818 // CHECK-NEXT: |-VarDecl {{.*}} RCA 'char &'
 819 // CHECK-NEXT: |-VarDecl {{.*}} RCZ 'char &'
 820 // CHECK-NEXT: |-VarDecl {{.*}} RSCa 'signed char &'
 821 // CHECK-NEXT: |-VarDecl {{.*}} RSCz 'signed char &'
 822 // CHECK-NEXT: |-VarDecl {{.*}} RUC24 'unsigned char &'
 823 // CHECK-NEXT: |-VarDecl {{.*}} RUC42 'unsigned char &'
 824 // CHECK-NEXT: |-VarDecl {{.*}} RSMax 'short &'
 825 // CHECK-NEXT: |-VarDecl {{.*}} RSMin 'short &'
 826 // CHECK-NEXT: |-VarDecl {{.*}} RUSMax 'unsigned short &'
 827 // CHECK-NEXT: |-VarDecl {{.*}} RUSMin 'unsigned short &'
 828 // CHECK-NEXT: |-VarDecl {{.*}} RIMax 'int &'
 829 // CHECK-NEXT: |-VarDecl {{.*}} RIMin 'int &'
 830 // CHECK-NEXT: |-VarDecl {{.*}} RUIMax 'unsigned int &'
 831 // CHECK-NEXT: |-VarDecl {{.*}} RUIMin 'unsigned int &'
 832 // CHECK-NEXT: |-VarDecl {{.*}} RLMax 'long &'
 833 // CHECK-NEXT: |-VarDecl {{.*}} RLMin 'long &'
 834 // CHECK-NEXT: |-VarDecl {{.*}} RULMax 'unsigned long &'
 835 // CHECK-NEXT: |-VarDecl {{.*}} RULMin 'unsigned long &'
 836 // CHECK-NEXT: |-VarDecl {{.*}} RLLMax 'long long &'
 837 // CHECK-NEXT: |-VarDecl {{.*}} RLLMin 'long long &'
 838 // CHECK-NEXT: |-VarDecl {{.*}} RULLMax 'unsigned long long &'
 839 // CHECK-NEXT: |-VarDecl {{.*}} RULLMin 'unsigned long long &'
 840 // CHECK-NEXT: |-VarDecl {{.*}} RF 'float &'
 841 // CHECK-NEXT: |-VarDecl {{.*}} RD 'double &'
 842 // CHECK-NEXT: |-VarDecl {{.*}} CRBFalse 'const bool &'
 843 // CHECK-NEXT: |-VarDecl {{.*}} CRBTrue 'const bool &'
 844 // CHECK-NEXT: |-VarDecl {{.*}} CRCA 'const char &'
 845 // CHECK-NEXT: |-VarDecl {{.*}} CRCZ 'const char &'
 846 // CHECK-NEXT: |-VarDecl {{.*}} CRSCa 'const signed char &'
 847 // CHECK-NEXT: |-VarDecl {{.*}} CRSCz 'const signed char &'
 848 // CHECK-NEXT: |-VarDecl {{.*}} CRUC24 'const unsigned char &'
 849 // CHECK-NEXT: |-VarDecl {{.*}} CRUC42 'const unsigned char &'
 850 // CHECK-NEXT: |-VarDecl {{.*}} CRSMax 'const short &'
 851 // CHECK-NEXT: |-VarDecl {{.*}} CRSMin 'const short &'
 852 // CHECK-NEXT: |-VarDecl {{.*}} CRUSMax 'const unsigned short &'
 853 // CHECK-NEXT: |-VarDecl {{.*}} CRUSMin 'const unsigned short &'
 854 // CHECK-NEXT: |-VarDecl {{.*}} CRIMax 'const int &'
 855 // CHECK-NEXT: |-VarDecl {{.*}} CRIMin 'const int &'
 856 // CHECK-NEXT: |-VarDecl {{.*}} CRUIMax 'const unsigned int &'
 857 // CHECK-NEXT: |-VarDecl {{.*}} CRUIMin 'const unsigned int &'
 858 // CHECK-NEXT: |-VarDecl {{.*}} CRLMax 'const long &'
 859 // CHECK-NEXT: |-VarDecl {{.*}} CRLMin 'const long &'
 860 // CHECK-NEXT: |-VarDecl {{.*}} CRULMax 'const unsigned long &'
 861 // CHECK-NEXT: |-VarDecl {{.*}} CRULMin 'const unsigned long &'
 862 // CHECK-NEXT: |-VarDecl {{.*}} CRLLMax 'const long long &'
 863 // CHECK-NEXT: |-VarDecl {{.*}} CRLLMin 'const long long &'
 864 // CHECK-NEXT: |-VarDecl {{.*}} CRULLMax 'const unsigned long long &'
 865 // CHECK-NEXT: |-VarDecl {{.*}} CRULLMin 'const unsigned long long &'
 866 // CHECK-NEXT: |-VarDecl {{.*}} CRF 'const float &'
 867 // CHECK-NEXT: |-VarDecl {{.*}} CRD 'const double &'
 868 // CHECK-NEXT: |-VarDecl {{.*}} RC16_24 'char16_t &'
 869 // CHECK-NEXT: |-VarDecl {{.*}} RC32_42 'char32_t &'
 870 // CHECK-NEXT: |-VarDecl {{.*}} RWC1 'wchar_t &'
 871 // CHECK-NEXT: |-VarDecl {{.*}} RWCP 'wchar_t &'
 872 // CHECK-NEXT: |-VarDecl {{.*}} CRC16_24 'const char16_t &'
 873 // CHECK-NEXT: |-VarDecl {{.*}} CRC32_42 'const char32_t &'
 874 // CHECK-NEXT: |-VarDecl {{.*}} CRWC1 'const wchar_t &'
 875 // CHECK-NEXT: `-VarDecl {{.*}} CRWCP 'const wchar_t &'
 876
 877 // CHECK: (lldb) quit
 878
 879 int main(int argc, char **argv) {
 880   return CIMax;
 881 }