[clang] Improve Serialization/Imporing of APValues

[Tyker]

Summary

Changes:

• initializer expressions of constexpr variable are now wraped in a ConstantExpr. this is mainly used for testing purposes. the old caching system has not yet been removed.
• Add all the missing Serialization and Importing for APValue.
• Cleanup leftover from last patch.
• Add Tests for Import and serialization.

[Tyker]

Change:

• Add support for LValue, MemberPointer and AddrDiffExpr.
• Add tests for importing.

i wasn't able to test for some APValueKinds: FixePoint, ComplexInt, ComplexFloat, AddrLabelDiff.
LValue could need more tests. i am not sure all edges cases are covered.

[martong]

clang/include/clang/AST/ASTImporter.h

501

typo: Constext -> Context
Also, we return with the APValue in the "to" context, not the one in the "from" context.

clang/lib/AST/ASTImporter.cpp

8764

Looks okay, but could we have unit tests for this in ASTImporterTest.cpp?

[Tyker]

fixed comment typo.

clang/lib/AST/ASTImporter.cpp

8764

I tested importing using the same test file as serialization clang/test/PCH/APValue.cpp with -ast-merge which uses importing. this prevent duplicating the test code for importing and serializing. is the unit-test in ASTImporterTest.cpp necessary anyway ?

[martong]

clang/include/clang/AST/ASTImporter.h

501

The typo is still there: Constext has an extra s.

clang/lib/AST/ASTImporter.cpp

8764

Okay, that's fine I missed that previously, so there is no need for the unit-tests in this case.
Though maybe the -ast-merge part of the test should reside in the clang/test/ASTMerge directory, because that is where all the other -ast-merge tests are.
I am not sure how to solve that nicely, because i see you use the same file for both the serialization and for the import.
Perhaps there should be a common header file which is included both in test/PCH/APValue.cpp and in test/ASTMerge/apvalue/test.cpp?

[Tyker]

fixed the comment for good, sorry for that.

[Tyker]

clang/lib/AST/ASTImporter.cpp

8764

we can have a common header, but i don't know where to put it. having a in PCH that includes a header form ASTMerge seems weird and vice versa.

[martong]

clang/lib/AST/ASTImporter.cpp

8764

Yes, that is indeed not so good.

The point is that, we should execute the APValue tests as well when we invoke ninja check-clang-astmerge. (Some people do not execute the whole check-clang verification when they change only the ASTImporter, this way the edit-test cycle can be faster)

Can we have a symbolic link from test/PCH/APValue.cpp to test/ASTMerge/APValue.cpp? Probably that would work on *nix, but not on Windows (https://stackoverflow.com/questions/5917249/git-symlinks-in-windows).
If the symlink is really not an option then I am just fine with a real copy of the file.
If we have a link or a copy then the tests will run twice, that seems ok for me, but may disturb other devs.
Actually, this is an inconvenient problem, perhaps someone had this before, so maybe a mail to cfe-dev could help us out.

[Tyker]

Sorry for the long wait.

Changes:

• Rebased on current master
• Duplicated test file so that it runs for both importing

[martong]

In D63640#1648700, @Tyker wrote:

Sorry for the long wait.

Changes:

• Rebased on current master
• Duplicated test file so that it runs for both importing

Thanks for addressing the issues. The ASTImporter related changes look good to me now.

[aaron.ballman]

clang/include/clang/AST/APValue.h

517

reserveVector per naming conventions

clang/include/clang/AST/ASTContext.h

281

Why are you getting rid of this? It seems like we would still want these cleaned up.

clang/include/clang/AST/Expr.h

962

Enumerator -> Enumerators
there -> their

clang/include/clang/AST/TextNodeDumper.h

149 ↗

(On Diff #217600)

Good catch -- this pointed out a bug in the class that I've fixed in r372323, so you'll need to rebase.

clang/lib/AST/APValue.cpp

177

Why is this no longer a pointer to const?

764

Can this function be marked const?

clang/lib/AST/ASTImporter.cpp

8764

Conflict markers?

9017

Please don't use auto as the type is not spelled out in the initialization.

9022

Please don't use auto as the type is not spelled out in the initialization.

(Same elsewhere, I'll stop commenting on them.)

clang/lib/AST/TextNodeDumper.cpp

691–692

You'll have to rebase this too -- these changes shouldn't be needed any longer.

clang/lib/Sema/SemaDecl.cpp

11725

Can elide braces.

clang/lib/Serialization/ASTReader.cpp

9598

auto *

9604–9605

auto *

9611

auto *

9622–9628

These names don't match the current coding conventions.

9631

You should add parens here to avoid diagnostics.

clang/lib/Serialization/ASTWriter.cpp

5492

Name doesn't match coding conventions.

5503

const auto *

5525

const auto *

5529

const auto *

5544

Unrelated change?

clang/lib/Serialization/ASTWriterStmt.cpp

42

It seems like there's a lot of unrelated formatting changes in this file that should not be part of the patch.

[Tyker]

Fixed most changes requested by @aaron.ballman
test are currently no valid anymore see comments for why.

clang/include/clang/AST/ASTContext.h

281

when i added APValueCleanups i wasn't aware that there were a generic system to handle this. but with this patch APValue a cleaned up using the generic ASTContext::addDestruction.

clang/include/clang/AST/TextNodeDumper.h

149 ↗

(On Diff #217600)

i took a look at the revision. there is a big difference is the quality of output between APValue::dump and APValue::printPretty. i think it is possible to come quite close to printPretty's output even without the ASTContext. this would require having a default PrintingPolicy and improving dump

in this patch i was relying on the -ast-dump output for testing. i would need to find an other testing strategy or make the improvement to APValue::dump first.

clang/lib/AST/APValue.cpp

177

when imporing or deserializing, we reserve the space for elements and then import/deserialize element directly in place. so the buffer storing them is not const. that said i saw that the normal construction cast away the const.

764

this function gives access to non-const internal data. this function is private so the impact is quite limited.

[Tyker]

clang/lib/AST/APValue.cpp

177

never mind this change wasn't needed.

[aaron.ballman]

clang/include/clang/AST/APValue.h

517

This was marked as done but is still an issue.

542–545

Rather than add this private bit in the middle of the public interface, you can move this to the existing private parts.

616

We're horribly inconsistent in this class, but because the other private member functions go with it, this should probably be GetMemberPointerPathPtr(). Maybe rename the get/setLValue methods from above as well?

clang/include/clang/AST/ASTContext.h

281

I don't see any new calls to addDestruction() though. Have I missed something?

clang/include/clang/AST/TextNodeDumper.h

149 ↗

(On Diff #217600)

there is a big difference is the quality of output between APValue::dump and APValue::printPretty.

Yes, there is.

i think it is possible to come quite close to printPretty's output even without the ASTContext. this would require having a default PrintingPolicy and improving dump

That would be much-appreciated! When I looked at it, it seemed like it may not be plausible because Stmt does not track which ASTContext it is associated with the same way that Decl does, and changing that seemed likely to cause a huge amount of interface churn.

in this patch i was relying on the -ast-dump output for testing. i would need to find an other testing strategy or make the improvement to APValue::dump first.

The issue resolved by r372323 was that we would crash on certain kinds of AST dumps. Specifically, the default AST dumper is often used during a debugging session to dump AST node information within the debugger. It was trivial to get that to crash before r372323, but with that revision, we no longer crash but get slightly uglier output (which is acceptable because it's still human-readable output).

I'm sorry for causing extra pain for you here, but I didn't want the fix from this review to accidentally become an enshrined part of the API because it's very easy to forget about this use case when working on AST dumping functionality.

clang/lib/AST/APValue.cpp

764

That makes it harder to call this helper from a constant context. I think there should be overloads (one const, one not) to handle this.

clang/test/ASTMerge/APValue/APValue.cpp

2

Can remove the spurious newline. Also, it seems this file was added with svn properties, was that intentional (we don't usually do that, FWIW)?

3–4

no need for -x c++ is there? This is already a C++ compilation unit.

29

Are you planning to address this in this patch? Also, I think it's FixedPoint and not FixePoint.

clang/test/PCH/APValue.cpp

1 ↗

(On Diff #221169)

Spurious newline.

2 ↗

(On Diff #221169)

-x c++ ?

It's really unfortunate that these test files are identical copies in different directories.

28 ↗

(On Diff #221169)

Same comment here.

[Tyker]

fixed some changes.
see comments for others.

clang/include/clang/AST/APValue.h

517

sorry

clang/test/PCH/APValue.cpp

2 ↗

(On Diff #221169)

they are almost the same. the second run line is slightly different. i had a version with both run line in the same file. but martong was worried that people running partial test would only not get all test relevant for what they were testing.

after through. ASTMerge requires both serialization and importing so it would probably be sufficient ?

[Tyker]

clang/include/clang/AST/APValue.h

616

We're horribly inconsistent in this class

this class has many flaws. but is far too broadly used to fix.

clang/include/clang/AST/ASTContext.h

281

the modification to use addDestruction() was made in a previous revision (https://reviews.llvm.org/D63376).
the use is currently on master in ConstantExpr::MoveIntoResult in the RSK_APValue case of the switch.
this is just a removing an unused member.

clang/include/clang/AST/TextNodeDumper.h

149 ↗

(On Diff #217600)

no worries, i wrote the original bug. i added APValue::dumpPretty which has almost the same output as APValue::printPretty but doesn't need an ASTContext. and is used for TextNodeDumper.

clang/lib/AST/APValue.cpp

764

this helper is not intended to be used outside of importing and serialization. it is logically part of initialization.
normal users are intended to use ArrayRef<APValue::LValuePathEntry> APValue::getLValuePath() const

clang/test/ASTMerge/APValue/APValue.cpp

2

it wasn't intentional, i added via git add i don't think i did anything weird. is it a problem ?

3–4

i don't know if it is normal. but i am getting an error hen i am not using -x c++
error: invalid argument '-std=gnu++2a' not allowed with 'C'

29

i don't intend to add them in this patch or subsequent patches. i don't know how to use the features that have these representations, i don't even know if they can be stored stored in that AST. so this is untested code.
that said theses representations aren't complex. the imporing for FixePoint, ComplexInt, ComplexFloat is a no-op and for AddrLabelDiff it is trivial. for serialization, I can put an llvm_unreachable to mark them as untested if you want ?

[aaron.ballman]

clang/include/clang/AST/APValue.h

616

Agreed -- I wasn't suggesting to fix the whole class, but just the new APIs that we add to the class. It looks like the private functions most consistently use a capital letter in this class, unfortunately. Best to stick with the local convention when in conflict.

clang/include/clang/AST/ASTContext.h

281

Ahhh, thank you for the explanation, I was missing that context.

clang/include/clang/AST/PrettyPrinter.h

203

Wether -> Whether

clang/lib/AST/APValue.cpp

537

Since you're touching the code anyway, this can be const auto *.

599

Are you sure this doesn't change behavior? See the implementation of ASTContext::getAsArrayType(). Same question applies below.

614

const auto * and same question about behavior changes.

764

Nothing about this API suggests that. The name looks like a generic getter. Perhaps a more descriptive name and some comments would help?

clang/test/ASTMerge/APValue/APValue.cpp

2

No idea; I'm on a platform where file modes are ignored. You should probably drop the svn property.

3–4

There's no %s on that line for the source file, which is why you get that diagnostic. I'm not certain what that RUN line does, actually -- it does an AST merge with... nothing... and then prints it out?

If that's intended, then you only need the -x c++ on that one RUN line.

29

I don't think llvm_unreachable makes a whole lot of sense unless the code is truly unreachable because there's no way to get an AST with that representation. By code inspection, the code looks reasonable but it does make me a bit uncomfortable to adopt it without tests. I suppose the FIXME is a reasonable compromise in this case, but if you have some spare cycles to investigate ways to get those representations, it would be appreciated.

[Tyker]

fixed most comments

clang/lib/AST/APValue.cpp

599

i ran the test suite after the change it there wasn't any test failures. but the test on dumping APValue are probably not as thorough as we would like them to be.
from analysis of ASTContext::getAsArrayType() the only effect i see on the element type is de-sugaring and canonicalization which shouldn't affect correctness of the output. de-sugaring requires the ASTContext but canonicalization doesn't.

i think the best way the have higher confidence is to ask rsmith what he thinks.

clang/test/ASTMerge/APValue/APValue.cpp

29

the reason i proposed llvm_unreachable was because it passes the tests and prevents future developer from depending on the code that depend on it assuming it works.

[aaron.ballman]

clang/include/clang/AST/APValue.h

620

ReserveVector

627

SetLValueEmptyPath

clang/lib/AST/APValue.cpp

599

Yeah, I doubt we have good test coverage for all the various behaviors here. I was wondering if the qualifiers bit was handled properly with a simple cast. @rsmith is a good person to weigh in.

clang/test/ASTMerge/APValue/APValue.cpp

29

We typically only use llvm_unreachable for situations where we believe the code path is impossible to reach, which is why I think that's the wrong approach. We could use an assertion to test the theory, however.

[Tyker]

made renamings

[rsmith]

clang/lib/AST/Expr.cpp

325

Can you use llvm_unreachable here? (Are there cases where we use RSK_None and then later find we actually have a value to store into the ConstantExpr?)

clang/lib/Serialization/ASTReader.cpp

9635

This is problematic.

ReadExpr will read a new copy of the expression, creating a distinct object. But in the case where we reach this when deserializing (for a MaterializeTemporaryExpr), we need to refer to the existing MaterializeTemporaryExpr in the initializer of its lifetime-extending declaration. We will also need to serialize the ASTContext's MaterializedTemporaryValues collection so that the temporaries lifetime-extended in a constant initializer get properly handled.

That all sounds very messy, so I think we should reconsider the model that we use for lifetime-extended materialized temporaries. As a half-baked idea:

• When we lifetime-extend a temporary, create a MaterializedTemporaryDecl to hold its value, and modify MaterializeTemporaryExpr to refer to the MaterializedTemporaryDecl rather than to just hold the subexpression for the temporary.
• Change the LValueBase representation to denote the declaration rather than the expression.
• Store the constant evaluated value for a materialized temporary on the MaterializedTemporaryDecl rather than on a side-table in the ASTContext.

With that done, we should verify that all remaining Expr*s used as LValueBases are either only transiently used during evaluation or don't have these kinds of identity problems.

[Tyker]

update done tasks.

clang/lib/AST/APValue.cpp

599

the original question we had is whether it is correct to replace Ctx.ASTContext::getAsArrayType(ElemTy) by cast<ArrayType>(ElemTy.getCanonicalType()) in this context and the other comment below.

clang/lib/AST/Expr.cpp

325

we can put llvm_unreachable in the switch because of if (!Value.hasValue()) above the switch but we can't remove if (!Value.hasValue()).
all cases i have seen where if (!Value.hasValue()) is taken occur after a semantic error occured.

clang/lib/Serialization/ASTReader.cpp

9635

Would it be possible to adapt serialization/deserialization so that they make sure that MaterializeTemporaryExpr are unique.
by:

• When serializing MaterializeTemporaryExpr serialize a key obtained from the pointer to the expression as it is unique.
• When deserializing MaterializeTemporaryExpr deserializing the key, and than have a cache for previously deserialized expression that need to be unique.

This would make easier adding new Expr that require uniqueness and seem less complicated.
What do you think ?

[Tyker]

ping @rsmith

[Tyker]

clang/lib/Serialization/ASTReader.cpp

9635

i added a review that does the refactoring https://reviews.llvm.org/D69360.

[Tyker]

now that the issue with uniqueness of expressions is solved. we should be able to keep going on that review @rsmith.
https://reviews.llvm.org/D63960 should be i think close to completion. so maybe for testing i could use immediate invocation as a source for ConstantExpr instead of the code i added to make constexpr variables emit ConstantExpr ?

[Tyker]

rebased

[rsmith]

Are we at a point where we can test this now? Perhaps by adding an assert in codegen that we always have an evaluated value for any constexpr variable that we emit?

clang/lib/Sema/SemaDecl.cpp

11741–11743

This may create additional AST nodes outside the ConstantExpr, which VarDecl::evaluateValue is not expecting to see (in particular, if we have cleanups for the initializer). Should the ConstantExpr go outside those nodes rather than inside?

clang/lib/Serialization/ASTReader.cpp

9635

What are the cases for which we still encounter expressions as lvalue bases during serialization? I think all the other ones should be OK, but maybe there's another interesting one we've overlooked.

[Tyker]

Sorry for the delay

In D63640#2151016, @rsmith wrote:

Are we at a point where we can test this now?

Yes we can use consteval to test it. so i removed changes to constexpr AST modling.

i split this path into 2 this path deal with serialization and importing, the other (D85144) improves the dumping of APValues to properly test this patch

[Tyker]

clang/lib/Sema/SemaDecl.cpp

11741–11743

i removed the changes to the storage of constexpr values since it was only used for testing purposes and we can now use consteval for that purpose.

clang/lib/Serialization/ASTReader.cpp

9635

the 2 example that come to mind are string literals and type_info there are probably more.

[Tyker]

rebased

[rsmith]

clang/include/clang/AST/APValue.h

617–619

Maybe something like this?

620

This function changes the size of the vector, so Reserve doesn't seem right to me. How about setVectorUninit? (Generally including Uninit in the names of the setters that leave things uninitialized would be useful.)

Also, instead of exposing GetInternal functions, how about adding functions that return a MutableArrayRef holding the array:

MutableArrayRef<APValue> setVectorUninit(unsigned N);
MutableArrayRef<LValuePathEntry> setLValueUninit(LValueBase B, const CharUnits &O, unsigned Size, bool OnePastTheEnd, bool IsNullPtr);
MutableArrayRef<const CXXRecordDecl*> MakeMemberPointerUninit(const ValueDecl *Member, bool IsDerivedMember, unsigned Size);

(It would be nice if MakeMemberPointer weren't so inconsistent with everything else this class does. But this whole interface is a mess.)

clang/lib/AST/APValue.cpp

833–834

Similarly maybe mentioning Uninit here would be useful.

clang/lib/AST/ASTImporter.cpp

6528–6531

Delete this commented-out code, please.

8866

We want the path in an APValue to be canonical, but importing a canonical decl might result in a non-canonical decl.

8886–8887

If you're intentionally not handling DynamicAllocLValue here (because those should always be transient), a comment to that effect would be useful.

8927

clang/lib/Serialization/ASTReader.cpp

9558–9679

You can assume here (and assert in the writer) that both floats in a ComplexFloat have the same fltSemantics.

9614

[Tyker]

addressed comments

[Tyker]

clang/lib/AST/ASTImporter.cpp

8866

but importing a canonical decl might result in a non-canonical decl.

this is a quite surprising behavior.

8886–8887

i added an asserts with a message.

[rsmith]

Looks great, thanks!

[martong]

Sorry for the late review, I just noticed something which is not a logical error, but we could make the ASTImporter code much cleaner.

clang/lib/AST/ASTImporter.cpp

8906–8917

A series of importChecked would result in a much cleaner code by omitting the second check. Also, instead of breaking out from the switch we can immediately return with the error.

This applies for the other cases where there are more import calls after each other (e.g. AddrLabelDiff, Union, ...).

Giving it more thought, you could use importChecked instead of Import everywhere in this function (for consistency).

[martong]

clang/lib/AST/ASTImporter.cpp

8866

but importing a canonical decl might result in a non-canonical decl.

this is a quite surprising behavior.

If you already have an existing redecl chain in the destination ASTContext (let's say A->B->C, A is the canonical decl), then importing a canonical decl (let's say D) would result an A->B->C->D' chain. Where D' is the imported version of D.

[rsmith]

Reverse ping: I have a patch implementing class type non-type template parameters that's blocked on this landing. If you won't have time to address @martong's comments soon, do you mind if I take this over and land it?

[martong]

In D63640#2331410, @rsmith wrote:

Reverse ping: I have a patch implementing class type non-type template parameters that's blocked on this landing. If you won't have time to address @martong's comments soon, do you mind if I take this over and land it?

It is okay for me to commit this patch in its current state. The changes I suggested could result in a cleaner code, but I can do those changes after we land this.

[Tyker]

try to apply martongs's suggestions.

[Tyker]

In D63640#2331734, @martong wrote:

In D63640#2331410, @rsmith wrote:

Reverse ping: I have a patch implementing class type non-type template parameters

that's blocked on this landing. If you won't have time to address @martong's comments soon, do you mind if I take this over and land it?

nice to see this coming.

It is okay for me to commit this patch in its current state. The changes I suggested could result in a cleaner code, but I can do those changes after we land this.

i couldn't apply martong's suggestion completely because importChecked is part of ASTNodeImporter not ASTImporter, but cleaned up some code.
but the "real" blocker is that the testing depends on D85144 for testing.
we could land it marking the tests XFAIL and correct it when dumping improvements arrive.

[martong]

In D63640#2331779, @Tyker wrote:

In D63640#2331734, @martong wrote:

In D63640#2331410, @rsmith wrote:

Reverse ping: I have a patch implementing class type non-type template parameters

that's blocked on this landing. If you won't have time to address @martong's comments soon, do you mind if I take this over and land it?

nice to see this coming.

It is okay for me to commit this patch in its current state. The changes I suggested could result in a cleaner code, but I can do those changes after we land this.

i couldn't apply martong's suggestion completely because importChecked is part of ASTNodeImporter not ASTImporter, but cleaned up some code.

This indicates that the newly added Import(APValue *) function should be part of the ASTNodeImporter. I came up with a draft patch on top of your patch:
https://github.com/llvm/llvm-project/commit/ac738cf854bdafa83a23c400bd5b2a90520566f9
You can see, this way we can eliminate some redundant ifs and casts.

[rsmith]

In D63640#2331779, @Tyker wrote:

but the "real" blocker is that the testing depends on D85144 for testing.
we could land it marking the tests XFAIL and correct it when dumping improvements arrive.

I'd be OK with that. We'll have coverage for this in various forms landing pretty soon.

[Tyker]

In D63640#2339917, @rsmith wrote:

In D63640#2331779, @Tyker wrote:

but the "real" blocker is that the testing depends on D85144 for testing.
we could land it marking the tests XFAIL and correct it when dumping improvements arrive.

I'd be OK with that. We'll have coverage for this in various forms landing pretty soon.

i appiled martong's patch and landed it marking the test as XFAIL.

clang/include/clang/AST/APValue.h

 //===--- APValue.h - Union class for APFloat/APSInt/Complex -----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines the APValue class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_AST_APVALUE_H
 #define LLVM_CLANG_AST_APVALUE_H
 
+#include "clang/AST/PrettyPrinter.h"
 #include "clang/Basic/FixedPoint.h"
 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/PointerUnion.h"
 
 namespace clang {
public:
     }
   };
   struct NoLValuePath {};
   struct UninitArray {};
   struct UninitStruct {};
 
   friend class ASTReader;
   friend class ASTWriter;
+  friend class ASTImporter;
 
 private:
   ValueKind Kind;
 
   struct ComplexAPSInt {
     APSInt Real, Imag;
     ComplexAPSInt() : Real(1), Imag(1) {}
   };
public:
   bool isStruct() const { return Kind == Struct; }
   bool isUnion() const { return Kind == Union; }
   bool isMemberPointer() const { return Kind == MemberPointer; }
   bool isAddrLabelDiff() const { return Kind == AddrLabelDiff; }
 
   void dump() const;
   void dump(raw_ostream &OS) const;
 
+  void dumpPretty(raw_ostream &OS, QualType Ty,
+                  const clang::PrintingPolicy &Policy =
+                      PrintingPolicy(LangOptions())) const;
+
   void printPretty(raw_ostream &OS, const ASTContext &Ctx, QualType Ty) const;
   std::string getAsString(const ASTContext &Ctx, QualType Ty) const;
 
   APSInt &getInt() {
     assert(isInt() && "Invalid accessor");
     return *(APSInt*)(char*)Data.buffer;
   }
   const APSInt &getInt() const {
public:
   void setFloat(APFloat F) {
     assert(isFloat() && "Invalid accessor");
     *(APFloat *)(char *)Data.buffer = std::move(F);
   }
   void setFixedPoint(APFixedPoint FX) {
     assert(isFixedPoint() && "Invalid accessor");
     *(APFixedPoint *)(char *)Data.buffer = std::move(FX);
   }
-  void setVector(const APValue *E, unsigned N) {
+  void reserveVector(unsigned N) {
     assert(isVector() && "Invalid accessor");
     ((Vec*)(char*)Data.buffer)->Elts = new APValue[N];
     ((Vec*)(char*)Data.buffer)->NumElts = N;
+  }
+  void setVector(const APValue *E, unsigned N) {
+    reserveVector(N);
     for (unsigned i = 0; i != N; ++i)
       ((Vec*)(char*)Data.buffer)->Elts[i] = E[i];
   }
   void setComplexInt(APSInt R, APSInt I) {
     assert(R.getBitWidth() == I.getBitWidth() &&
            "Invalid complex int (type mismatch).");
     assert(isComplexInt() && "Invalid accessor");
     ((ComplexAPSInt *)(char *)Data.buffer)->Real = std::move(R);
     ((ComplexAPSInt *)(char *)Data.buffer)->Imag = std::move(I);
   }
   void setComplexFloat(APFloat R, APFloat I) {
     assert(&R.getSemantics() == &I.getSemantics() &&
            "Invalid complex float (type mismatch).");
     assert(isComplexFloat() && "Invalid accessor");
     ((ComplexAPFloat *)(char *)Data.buffer)->Real = std::move(R);
     ((ComplexAPFloat *)(char *)Data.buffer)->Imag = std::move(I);
   }
   void setLValue(LValueBase B, const CharUnits &O, NoLValuePath,
                  bool IsNullPtr);
   void setLValue(LValueBase B, const CharUnits &O,
                  ArrayRef<LValuePathEntry> Path, bool OnePastTheEnd,
                  bool IsNullPtr);
   void setUnion(const FieldDecl *Field, const APValue &Value) {
     assert(isUnion() && "Invalid accessor");
     ((UnionData*)(char*)Data.buffer)->Field = Field;
     *((UnionData*)(char*)Data.buffer)->Value = Value;
   }
   void setAddrLabelDiff(const AddrLabelExpr* LHSExpr,
                         const AddrLabelExpr* RHSExpr) {
     ((AddrLabelDiffData*)(char*)Data.buffer)->LHSExpr = LHSExpr;
void MakeStruct(unsigned B, unsigned M) {
     new ((void*)(char*)Data.buffer) StructData(B, M);
     Kind = Struct;
   }
   void MakeUnion() {
     assert(isAbsent() && "Bad state change");
     new ((void*)(char*)Data.buffer) UnionData();
     Kind = Union;
   }
+  void MakeEmptyMemberPointer(const ValueDecl *Member, bool IsDerivedMember,
+                              unsigned Size);
   void MakeMemberPointer(const ValueDecl *Member, bool IsDerivedMember,
                          ArrayRef<const CXXRecordDecl*> Path);
   void MakeAddrLabelDiff() {
     assert(isAbsent() && "Bad state change");
     new ((void*)(char*)Data.buffer) AddrLabelDiffData();
     Kind = AddrLabelDiff;
   }
+  const CXXRecordDecl **getMemberPointerPathPtr();
+  void setLValueEmptyPath(LValueBase B, const CharUnits &O, unsigned Size,
+                          bool OnePastTheEnd, bool IsNullPtr);
+  LValuePathEntry *getLValuePathPtr();
+
 };
 
 } // end namespace clang.
 
 namespace llvm {
 template<> struct DenseMapInfo<clang::APValue::LValueBase> {
   static clang::APValue::LValueBase getEmptyKey();
   static clang::APValue::LValueBase getTombstoneKey();
   static unsigned getHashValue(const clang::APValue::LValueBase &Base);
   static bool isEqual(const clang::APValue::LValueBase &LHS,
                       const clang::APValue::LValueBase &RHS);
 };
 }
 
 #endif

clang/include/clang/AST/ASTContext.h

private:
   llvm::DenseMap<const VarDecl *, BlockVarCopyInit> BlockVarCopyInits;
 
   /// Mapping from materialized temporaries with static storage duration
   /// that appear in constant initializers to their evaluated values.  These are
   /// allocated in a std::map because their address must be stable.
   llvm::DenseMap<const MaterializeTemporaryExpr *, APValue *>
     MaterializedTemporaryValues;
 
-  /// Used to cleanups APValues stored in the AST.
-  mutable llvm::SmallVector<APValue *, 0> APValueCleanups;
-
   /// A cache mapping a string value to a StringLiteral object with the same
   /// value.
   ///
   /// This is lazily created.  This is intentionally not serialized.
   mutable llvm::StringMap<StringLiteral *> StringLiteralCache;
 
   /// Representation of a "canonical" template template parameter that
   /// is used in canonical template names.

clang/include/clang/AST/ASTImporter.h

 //  context into another context.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_AST_ASTIMPORTER_H
 #define LLVM_CLANG_AST_ASTIMPORTER_H
 
 #include "clang/AST/DeclBase.h"
+#include "clang/AST/APValue.h"
 #include "clang/AST/DeclarationName.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/TemplateName.h"
 #include "clang/AST/Type.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
public:
 
     /// Import the given CXXBaseSpecifier from the "from" context into
     /// the "to" context.
     ///
     /// \returns The equivalent CXXBaseSpecifier in the source manager of the
     /// "to" context, or the import error.
     llvm::Expected<CXXBaseSpecifier *> Import(const CXXBaseSpecifier *FromSpec);
 
+    /// Import the given APValue from the "from" context into
+    /// the "to" context.
+    ///
+    /// \return the equivalent APValue in the "to" context or the import
+    /// error.
+    llvm::Expected<APValue> Import(const APValue &FromValue);
+
     /// Import the definition of the given declaration, including all of
     /// the declarations it contains.
     LLVM_NODISCARD llvm::Error ImportDefinition(Decl *From);
 
     /// Cope with a name conflict when importing a declaration into the
     /// given context.
     ///
     /// This routine is invoked whenever there is a name conflict while

clang/include/clang/AST/Expr.h

class ConstantExpr final
     : public FullExpr,
       private llvm::TrailingObjects<ConstantExpr, APValue, uint64_t> {
   static_assert(std::is_same<uint64_t, llvm::APInt::WordType>::value,
                 "this class assumes llvm::APInt::WordType is uint64_t for "
                 "trail-allocated storage");
 
 public:
   /// Describes the kind of result that can be trail-allocated.
+  /// Enumerators need to stay ordered by size of their storage.
+  /// Smallest storage first.
   enum ResultStorageKind { RSK_None, RSK_Int64, RSK_APValue };
 
 private:
   size_t numTrailingObjects(OverloadToken<APValue>) const {
     return ConstantExprBits.ResultKind == ConstantExpr::RSK_APValue;
   }
   size_t numTrailingObjects(OverloadToken<uint64_t>) const {
     return ConstantExprBits.ResultKind == ConstantExpr::RSK_Int64;

clang/include/clang/AST/PrettyPrinter.h

PrintingPolicy(const LangOptions &LO)
         SuppressInitializers(false), ConstantArraySizeAsWritten(false),
         AnonymousTagLocations(true), SuppressStrongLifetime(false),
         SuppressLifetimeQualifiers(false),
         SuppressTemplateArgsInCXXConstructors(false), Bool(LO.Bool),
         Restrict(LO.C99), Alignof(LO.CPlusPlus11), UnderscoreAlignof(LO.C11),
         UseVoidForZeroParams(!LO.CPlusPlus), TerseOutput(false),
         PolishForDeclaration(false), Half(LO.Half),
         MSWChar(LO.MicrosoftExt && !LO.WChar), IncludeNewlines(true),
-        MSVCFormatting(false), ConstantsAsWritten(false),
-        SuppressImplicitBase(false), FullyQualifiedName(false),
-        RemapFilePaths(false), PrintCanonicalTypes(false) {}
+        MSVCFormatting(false), UseNullptr(LO.CPlusPlus11),
+        ConstantsAsWritten(false), SuppressImplicitBase(false),
+        FullyQualifiedName(false), RemapFilePaths(false),
+        PrintCanonicalTypes(false) {}
 
   /// Adjust this printing policy for cases where it's known that we're
   /// printing C++ code (for instance, if AST dumping reaches a C++-only
   /// construct). This should not be used if a real LangOptions object is
   /// available.
   void adjustForCPlusPlus() {
     SuppressTagKeyword = true;
     Bool = true;
struct PrintingPolicy {
   /// When true, include newlines after statements like "break", etc.
   unsigned IncludeNewlines : 1;
 
   /// Use whitespace and punctuation like MSVC does. In particular, this prints
   /// anonymous namespaces as `anonymous namespace' and does not insert spaces
   /// after template arguments.
   unsigned MSVCFormatting : 1;
 
+  /// Wether null pointers should be printed as nullptr or as NULL.
+  unsigned UseNullptr : 1;
+
   /// Whether we should print the constant expressions as written in the
   /// sources.
   ///
   /// This flag determines whether constants expressions like
   ///
   /// \code
   /// 0x10
   /// 2.5e3

clang/include/clang/Serialization/ASTReader.h

public:
   /// Read a signed integral value
   llvm::APSInt ReadAPSInt(const RecordData &Record, unsigned &Idx);
 
   /// Read a floating-point value
   llvm::APFloat ReadAPFloat(const RecordData &Record,
                             const llvm::fltSemantics &Sem, unsigned &Idx);
 
   /// Read an APValue
-  APValue ReadAPValue(const RecordData &Record, unsigned &Idx);
+  APValue ReadAPValue(ModuleFile &F, const RecordData &Record, unsigned &Idx);
 
   // Read a string
   static std::string ReadString(const RecordData &Record, unsigned &Idx);
 
   // Skip a string
   static void SkipString(const RecordData &Record, unsigned &Idx) {
     Idx += Record[Idx] + 1;
   }
SourceLocation readSourceLocation() {
     return Reader->ReadSourceLocation(*F, Record, Idx);
   }
 
   /// Read a source range, advancing Idx.
   SourceRange readSourceRange() {
     return Reader->ReadSourceRange(*F, Record, Idx);
   }
 
-  APValue readAPValue() { return Reader->ReadAPValue(Record, Idx); }
+  APValue readAPValue() { return Reader->ReadAPValue(*F, Record, Idx); }
 
   /// Read an integral value, advancing Idx.
   llvm::APInt readAPInt() {
     return Reader->ReadAPInt(Record, Idx);
   }
 
   /// Read a signed integral value, advancing Idx.
   llvm::APSInt readAPSInt() {

clang/lib/AST/APValue.cpp

struct MemberPointerBase {
     unsigned PathLength;
   };
 }
 
 struct APValue::MemberPointerData : MemberPointerBase {
   static const unsigned InlinePathSpace =
       (DataSize - sizeof(MemberPointerBase)) / sizeof(const CXXRecordDecl*);
   typedef const CXXRecordDecl *PathElem;
   union {
     PathElem Path[InlinePathSpace];
     PathElem *PathPtr;
   };
 
   MemberPointerData() { PathLength = 0; }
   ~MemberPointerData() { resizePath(0); }
 
   void resizePath(unsigned Length) {
case MemberPointer:
     return;
   case AddrLabelDiff:
     OS << "AddrLabelDiff: <todo>";
     return;
   }
   llvm_unreachable("Unknown APValue kind!");
 }
 
-void APValue::printPretty(raw_ostream &Out, const ASTContext &Ctx,
-                          QualType Ty) const {
-  switch (getKind()) {
+static void InternalPrinter(raw_ostream &Out, const APValue &Value, QualType Ty,
+                            const ASTContext *Ctx,
+                            const clang::PrintingPolicy &Policy) {
+  switch (Value.getKind()) {
   case APValue::None:
     Out << "<out of lifetime>";
     return;
   case APValue::Indeterminate:
     Out << "<uninitialized>";
     return;
   case APValue::Int:
     if (Ty->isBooleanType())
-      Out << (getInt().getBoolValue() ? "true" : "false");
+      Out << (Value.getInt().getBoolValue() ? "true" : "false");
     else
-      Out << getInt();
+      Out << Value.getInt();
     return;
   case APValue::Float:
-    Out << GetApproxValue(getFloat());
+    Out << GetApproxValue(Value.getFloat());
     return;
   case APValue::FixedPoint:
-    Out << getFixedPoint();
+    Out << Value.getFixedPoint();
     return;
   case APValue::Vector: {
     Out << '{';
     QualType ElemTy = Ty->getAs<VectorType>()->getElementType();
-    getVectorElt(0).printPretty(Out, Ctx, ElemTy);
-    for (unsigned i = 1; i != getVectorLength(); ++i) {
+    ::InternalPrinter(Out, Value.getVectorElt(0), ElemTy, Ctx, Policy);
+    for (unsigned i = 1; i != Value.getVectorLength(); ++i) {
       Out << ", ";
-      getVectorElt(i).printPretty(Out, Ctx, ElemTy);
+      ::InternalPrinter(Out, Value.getVectorElt(i), ElemTy, Ctx, Policy);
     }
     Out << '}';
     return;
   }
   case APValue::ComplexInt:
-    Out << getComplexIntReal() << "+" << getComplexIntImag() << "i";
+    Out << Value.getComplexIntReal() << "+" << Value.getComplexIntImag() << "i";
     return;
   case APValue::ComplexFloat:
-    Out << GetApproxValue(getComplexFloatReal()) << "+"
-        << GetApproxValue(getComplexFloatImag()) << "i";
+    Out << GetApproxValue(Value.getComplexFloatReal()) << "+"
+        << GetApproxValue(Value.getComplexFloatImag()) << "i";
     return;
   case APValue::LValue: {
     bool IsReference = Ty->isReferenceType();
     QualType InnerTy
       = IsReference ? Ty.getNonReferenceType() : Ty->getPointeeType();
     if (InnerTy.isNull())
       InnerTy = Ty;
 
-    LValueBase Base = getLValueBase();
+    APValue::LValueBase Base = Value.getLValueBase();
     if (!Base) {
-      if (isNullPointer()) {
-        Out << (Ctx.getLangOpts().CPlusPlus11 ? "nullptr" : "0");
+      if (Value.isNullPointer()) {
+        Out << (Policy.UseNullptr ? "nullptr" : "NULL");
       } else if (IsReference) {
-        Out << "*(" << InnerTy.stream(Ctx.getPrintingPolicy()) << "*)"
-            << getLValueOffset().getQuantity();
+        Out << "*(" << InnerTy.stream(Policy) << "*)"
+            << Value.getLValueOffset().getQuantity();
       } else {
-        Out << "(" << Ty.stream(Ctx.getPrintingPolicy()) << ")"
-            << getLValueOffset().getQuantity();
+        Out << "(" << Ty.stream(Policy) << ")"
+            << Value.getLValueOffset().getQuantity();
       }
       return;
     }
 
-    if (!hasLValuePath()) {
+    if (!Value.hasLValuePath()) {
       // No lvalue path: just print the offset.
-      CharUnits O = getLValueOffset();
-      CharUnits S = Ctx.getTypeSizeInChars(InnerTy);
+      CharUnits O = Value.getLValueOffset();
+      CharUnits S;
+      if (Ctx)
+        S = Ctx->getTypeSizeInChars(InnerTy);
       if (!O.isZero()) {
         if (IsReference)
           Out << "*(";
-        if (O % S) {
+        if (!Ctx || O % S) {
           Out << "(char*)";
           S = CharUnits::One();
         }
         Out << '&';
       } else if (!IsReference)
         Out << '&';
 
-      if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>())
+      if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl *>())
         Out << *VD;
       else if (TypeInfoLValue TI = Base.dyn_cast<TypeInfoLValue>()) {
-        TI.print(Out, Ctx.getPrintingPolicy());
+        TI.print(Out, Policy);
       } else {
         assert(Base.get<const Expr *>() != nullptr &&
                "Expecting non-null Expr");
-        Base.get<const Expr*>()->printPretty(Out, nullptr,
-                                             Ctx.getPrintingPolicy());
+        Base.get<const Expr *>()->printPretty(Out, nullptr, Policy);
       }
 
       if (!O.isZero()) {
-        Out << " + " << (O / S);
+        Out << " + " << (Ctx ? (O / S) : O.getQuantity());
         if (IsReference)
           Out << ')';
       }
       return;
     }
 
     // We have an lvalue path. Print it out nicely.
     if (!IsReference)
       Out << '&';
-    else if (isLValueOnePastTheEnd())
+    else if (Value.isLValueOnePastTheEnd())
       Out << "*(&";
 
     QualType ElemTy;
+    bool IsRecord = false;
     if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>()) {
       Out << *VD;
       ElemTy = VD->getType();
     } else if (TypeInfoLValue TI = Base.dyn_cast<TypeInfoLValue>()) {
-      TI.print(Out, Ctx.getPrintingPolicy());
+      TI.print(Out, Policy);
       ElemTy = Base.getTypeInfoType();
     } else {
       const Expr *E = Base.get<const Expr*>();
       assert(E != nullptr && "Expecting non-null Expr");
-      E->printPretty(Out, nullptr, Ctx.getPrintingPolicy());
+      E->printPretty(Out, nullptr, Policy);
       ElemTy = E->getType();
     }
 
-    ArrayRef<LValuePathEntry> Path = getLValuePath();
+    ArrayRef<APValue::LValuePathEntry> Path = Value.getLValuePath();
     const CXXRecordDecl *CastToBase = nullptr;
     for (unsigned I = 0, N = Path.size(); I != N; ++I) {
-      if (ElemTy->getAs<RecordType>()) {
+      if (IsRecord || ElemTy->getAs<RecordType>()) {
+        IsRecord = false;
         // The lvalue refers to a class type, so the next path entry is a base
         // or member.
         const Decl *BaseOrMember = Path[I].getAsBaseOrMember().getPointer();
         if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(BaseOrMember)) {
           CastToBase = RD;
-          ElemTy = Ctx.getRecordType(RD);
+          ElemTy = QualType();
+          IsRecord = true;
         } else {
           const ValueDecl *VD = cast<ValueDecl>(BaseOrMember);
           Out << ".";
           if (CastToBase)
             Out << *CastToBase << "::";
           Out << *VD;
           ElemTy = VD->getType();
         }
       } else {
         // The lvalue must refer to an array.
         Out << '[' << Path[I].getAsArrayIndex() << ']';
-        ElemTy = Ctx.getAsArrayType(ElemTy)->getElementType();
+        ElemTy = cast<ArrayType>(ElemTy)->getElementType();
       }
     }
 
     // Handle formatting of one-past-the-end lvalues.
-    if (isLValueOnePastTheEnd()) {
+    if (Value.isLValueOnePastTheEnd()) {
       // FIXME: If CastToBase is non-0, we should prefix the output with
       // "(CastToBase*)".
       Out << " + 1";
       if (IsReference)
         Out << ')';
     }
     return;
   }
   case APValue::Array: {
-    const ArrayType *AT = Ctx.getAsArrayType(Ty);
+    const ArrayType *AT = cast<ArrayType>(Ty);
     QualType ElemTy = AT->getElementType();
     Out << '{';
-    if (unsigned N = getArrayInitializedElts()) {
-      getArrayInitializedElt(0).printPretty(Out, Ctx, ElemTy);
+    if (unsigned N = Value.getArrayInitializedElts()) {
+      ::InternalPrinter(Out, Value.getArrayInitializedElt(0), ElemTy, Ctx, Policy);
       for (unsigned I = 1; I != N; ++I) {
         Out << ", ";
         if (I == 10) {
           // Avoid printing out the entire contents of large arrays.
           Out << "...";
           break;
         }
-        getArrayInitializedElt(I).printPretty(Out, Ctx, ElemTy);
+        ::InternalPrinter(Out, Value.getArrayInitializedElt(I), ElemTy, Ctx,
+                          Policy);
       }
     }
     Out << '}';
     return;
   }
   case APValue::Struct: {
     Out << '{';
     const RecordDecl *RD = Ty->getAs<RecordType>()->getDecl();
     bool First = true;
-    if (unsigned N = getStructNumBases()) {
+    if (unsigned N = Value.getStructNumBases()) {
       const CXXRecordDecl *CD = cast<CXXRecordDecl>(RD);
       CXXRecordDecl::base_class_const_iterator BI = CD->bases_begin();
       for (unsigned I = 0; I != N; ++I, ++BI) {
         assert(BI != CD->bases_end());
         if (!First)
           Out << ", ";
-        getStructBase(I).printPretty(Out, Ctx, BI->getType());
+        ::InternalPrinter(Out, Value.getStructBase(I), BI->getType(), Ctx,
+                          Policy);
         First = false;
       }
     }
     for (const auto *FI : RD->fields()) {
       if (!First)
         Out << ", ";
       if (FI->isUnnamedBitfield()) continue;
-      getStructField(FI->getFieldIndex()).
-        printPretty(Out, Ctx, FI->getType());
+      ::InternalPrinter(Out, Value.getStructField(FI->getFieldIndex()),
+                        FI->getType(), Ctx, Policy);
       First = false;
     }
     Out << '}';
     return;
   }
   case APValue::Union:
     Out << '{';
-    if (const FieldDecl *FD = getUnionField()) {
+    if (const FieldDecl *FD = Value.getUnionField()) {
       Out << "." << *FD << " = ";
-      getUnionValue().printPretty(Out, Ctx, FD->getType());
+      ::InternalPrinter(Out, Value.getUnionValue(), FD->getType(), Ctx, Policy);
     }
     Out << '}';
     return;
   case APValue::MemberPointer:
     // FIXME: This is not enough to unambiguously identify the member in a
     // multiple-inheritance scenario.
-    if (const ValueDecl *VD = getMemberPointerDecl()) {
+    if (const ValueDecl *VD = Value.getMemberPointerDecl()) {
       Out << '&' << *cast<CXXRecordDecl>(VD->getDeclContext()) << "::" << *VD;
       return;
     }
     Out << "0";
     return;
   case APValue::AddrLabelDiff:
-    Out << "&&" << getAddrLabelDiffLHS()->getLabel()->getName();
+    Out << "&&" << Value.getAddrLabelDiffLHS()->getLabel()->getName();
     Out << " - ";
-    Out << "&&" << getAddrLabelDiffRHS()->getLabel()->getName();
+    Out << "&&" << Value.getAddrLabelDiffRHS()->getLabel()->getName();
     return;
   }
   llvm_unreachable("Unknown APValue kind!");
 }
 
+void APValue::printPretty(raw_ostream &Out, const ASTContext &Ctx, QualType Ty) const {
+  ::InternalPrinter(Out, *this, Ty, &Ctx, Ctx.getPrintingPolicy());
+}
+
+void APValue::dumpPretty(raw_ostream &OS, QualType Ty,
+                         const clang::PrintingPolicy &Policy) const {
+  ::InternalPrinter(OS, *this, Ty, nullptr, Policy);
+}
+
 std::string APValue::getAsString(const ASTContext &Ctx, QualType Ty) const {
   std::string Result;
   llvm::raw_string_ostream Out(Result);
   printPretty(Out, Ctx, Ty);
   Out.flush();
   return Result;
 }
 
unsigned APValue::getLValueVersion() const {
   return ((const LV*)(const char*)Data.buffer)->Base.getVersion();
 }
 
 bool APValue::isNullPointer() const {
   assert(isLValue() && "Invalid usage");
   return ((const LV*)(const char*)Data.buffer)->IsNullPtr;
 }
 
+APValue::LValuePathEntry *APValue::getLValuePathPtr() {
+  return ((LV *)(char *)Data.buffer)->getPath();
+}
+
 void APValue::setLValue(LValueBase B, const CharUnits &O, NoLValuePath,
                         bool IsNullPtr) {
   assert(isLValue() && "Invalid accessor");
   LV &LVal = *((LV*)(char*)Data.buffer);
   LVal.Base = B;
   LVal.IsOnePastTheEnd = false;
   LVal.Offset = O;
   LVal.resizePath((unsigned)-1);
   LVal.IsNullPtr = IsNullPtr;
 }
 
-void APValue::setLValue(LValueBase B, const CharUnits &O,
-                        ArrayRef<LValuePathEntry> Path, bool IsOnePastTheEnd,
+void APValue::setLValueEmptyPath(LValueBase B, const CharUnits &O,
+                                 unsigned Size, bool IsOnePastTheEnd,
                                  bool IsNullPtr) {
   assert(isLValue() && "Invalid accessor");
-  LV &LVal = *((LV*)(char*)Data.buffer);
+  LV &LVal = *((LV *)(char *)Data.buffer);
   LVal.Base = B;
   LVal.IsOnePastTheEnd = IsOnePastTheEnd;
   LVal.Offset = O;
-  LVal.resizePath(Path.size());
-  memcpy(LVal.getPath(), Path.data(), Path.size() * sizeof(LValuePathEntry));
   LVal.IsNullPtr = IsNullPtr;
+  LVal.resizePath(Size);
+}
+
+void APValue::setLValue(LValueBase B, const CharUnits &O,
+                        ArrayRef<LValuePathEntry> Path, bool IsOnePastTheEnd,
+                        bool IsNullPtr) {
+  setLValueEmptyPath(B, O, Path.size(), IsOnePastTheEnd, IsNullPtr);
+  memcpy(((LV *)(char *)Data.buffer)->getPath(), Path.data(),
+         Path.size() * sizeof(LValuePathEntry));
 }
 
 const ValueDecl *APValue::getMemberPointerDecl() const {
   assert(isMemberPointer() && "Invalid accessor");
   const MemberPointerData &MPD =
       *((const MemberPointerData *)(const char *)Data.buffer);
   return MPD.MemberAndIsDerivedMember.getPointer();
 }

 }
 
 void APValue::MakeArray(unsigned InitElts, unsigned Size) {
   assert(isAbsent() && "Bad state change");
   new ((void*)(char*)Data.buffer) Arr(InitElts, Size);
   Kind = Array;
 }
 
-void APValue::MakeMemberPointer(const ValueDecl *Member, bool IsDerivedMember,
-                                ArrayRef<const CXXRecordDecl*> Path) {
+void APValue::MakeEmptyMemberPointer(const ValueDecl *Member,
+                                     bool IsDerivedMember, unsigned Size) {
   assert(isAbsent() && "Bad state change");
   MemberPointerData *MPD = new ((void*)(char*)Data.buffer) MemberPointerData;
   Kind = MemberPointer;
   MPD->MemberAndIsDerivedMember.setPointer(Member);
   MPD->MemberAndIsDerivedMember.setInt(IsDerivedMember);
-  MPD->resizePath(Path.size());
-  memcpy(MPD->getPath(), Path.data(), Path.size()*sizeof(const CXXRecordDecl*));
+  MPD->resizePath(Size);
+}
+
+void APValue::MakeMemberPointer(const ValueDecl *Member, bool IsDerivedMember,
+                                ArrayRef<const CXXRecordDecl *> Path) {
+  MakeEmptyMemberPointer(Member, IsDerivedMember, Path.size());
+  memcpy(((MemberPointerData *)(char *)Data.buffer)->getPath(), Path.data(),
+         Path.size() * sizeof(const CXXRecordDecl *));
+}
+
+const CXXRecordDecl **APValue::getMemberPointerPathPtr() {
+  return ((MemberPointerData *)(char *)Data.buffer)->getPath();
 }

clang/lib/AST/ASTContext.cpp

for (llvm::DenseMap<const Decl*, AttrVec*>::iterator A = DeclAttrs.begin(),
     A->second->~AttrVec();
 
   for (std::pair<const MaterializeTemporaryExpr *, APValue *> &MTVPair :
        MaterializedTemporaryValues)
     MTVPair.second->~APValue();
 
   for (const auto &Value : ModuleInitializers)
     Value.second->~PerModuleInitializers();
-
-  for (APValue *Value : APValueCleanups)
-    Value->~APValue();
 }
 
 class ASTContext::ParentMap {
   /// Contains parents of a node.
   using ParentVector = llvm::SmallVector<ast_type_traits::DynTypedNode, 2>;
 
   /// Maps from a node to its parents. This is used for nodes that have
   /// pointer identity only, which are more common and we can save space by

clang/lib/AST/ASTImporter.cpp

ExpectedStmt ASTNodeImporter::VisitAddrLabelExpr(AddrLabelExpr *E) {
   QualType ToType;
   std::tie(ToAmpAmpLoc, ToLabelLoc, ToLabel, ToType) = *Imp;
 
   return new (Importer.getToContext()) AddrLabelExpr(
       ToAmpAmpLoc, ToLabelLoc, ToLabel, ToType);
 }
 
 ExpectedStmt ASTNodeImporter::VisitConstantExpr(ConstantExpr *E) {
-  auto Imp = importSeq(E->getSubExpr());
+  auto Imp = importSeq(E->getSubExpr(), E->getAPValueResult());
   if (!Imp)
     return Imp.takeError();
 
   Expr *ToSubExpr;
-  std::tie(ToSubExpr) = *Imp;
+  APValue ToResult;
+  std::tie(ToSubExpr, ToResult) = *Imp;
 
-  // TODO : Handle APValue::ValueKind that require importing.
-  APValue::ValueKind Kind = E->getResultAPValueKind();
-  if (Kind == APValue::Int || Kind == APValue::Float ||
-      Kind == APValue::FixedPoint || Kind == APValue::ComplexFloat ||
-      Kind == APValue::ComplexInt)
-    return ConstantExpr::Create(Importer.getToContext(), ToSubExpr,
-                                E->getAPValueResult());
-  return ConstantExpr::Create(Importer.getToContext(), ToSubExpr);
+  return ConstantExpr::Create(Importer.getToContext(), ToSubExpr, ToResult);
 }
 
 ExpectedStmt ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
   auto Imp = importSeq(E->getLParen(), E->getRParen(), E->getSubExpr());
   if (!Imp)
     return Imp.takeError();
 
   SourceLocation ToLParen, ToRParen;
   Expr *ToSubExpr;
   std::tie(ToLParen, ToRParen, ToSubExpr) = *Imp;
Expected<Selector> ASTImporter::Import(Selector FromSel) {
 
   SmallVector<IdentifierInfo *, 4> Idents;
   Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0)));
   for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I)
     Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I)));
   return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data());
 }
 
+llvm::Expected<APValue> ASTImporter::Import(const APValue &FromValue) {
+  APValue Result;
+  llvm::Error Error = llvm::Error::success();
+  auto ImportLoop = [&](const APValue *From, APValue *To, unsigned Size) {
+    for (unsigned Idx = 0; Idx < Size; Idx++) {
+      llvm::Expected<APValue> Tmp = Import(From[Idx]);
+      if (!Tmp) {
+        Error = Tmp.takeError();
+        return;
+      }
+      To[Idx] = std::move(Tmp.get());
+    }
+  };
+  switch (FromValue.getKind()) {
+  case APValue::None:
+  case APValue::Indeterminate:
+  case APValue::Int:
+  case APValue::Float:
+  case APValue::FixedPoint:
+  case APValue::ComplexInt:
+  case APValue::ComplexFloat:
+    Result = FromValue;
+    break;
+  case APValue::Vector:
+    Result.MakeVector();
+    Result.reserveVector(FromValue.getVectorLength());
+    ImportLoop(
+        ((const APValue::Vec *)(const char *)FromValue.Data.buffer)->Elts,
+        ((const APValue::Vec *)(const char *)Result.Data.buffer)->Elts,
+        FromValue.getVectorLength());
+    break;
+  case APValue::Array:
+    Result.MakeArray(FromValue.getArrayInitializedElts(),
+                     FromValue.getArraySize());
+    ImportLoop(
+        ((const APValue::Arr *)(const char *)FromValue.Data.buffer)->Elts,
+        ((const APValue::Arr *)(const char *)Result.Data.buffer)->Elts,
+        FromValue.getArrayInitializedElts());
+    break;
+  case APValue::Struct:
+    Result.MakeStruct(FromValue.getStructNumBases(),
+                      FromValue.getStructNumFields());
+    ImportLoop(
+        ((const APValue::StructData *)(const char *)FromValue.Data.buffer)
+            ->Elts,
+        ((const APValue::StructData *)(const char *)Result.Data.buffer)->Elts,
+        FromValue.getStructNumBases() + FromValue.getStructNumFields());
+    break;
+  case APValue::Union: {
+    Result.MakeUnion();
+    llvm::Expected<const Decl *> ImpFDecl = Import(FromValue.getUnionField());
+    if (!ImpFDecl) {
+      Error = ImpFDecl.takeError();
+      break;
+    }
+    llvm::Expected<APValue> ImpValue = Import(FromValue.getUnionValue());
+    if (!ImpValue) {
+      Error = ImpValue.takeError();
+      break;
+    }
+    Result.setUnion(cast<FieldDecl>(ImpFDecl.get()), ImpValue.get());
+    break;
+  }
+  case APValue::AddrLabelDiff: {
+    Result.MakeAddrLabelDiff();
+    llvm::Expected<Expr *> ImpLHS =
+        Import(const_cast<AddrLabelExpr *>(FromValue.getAddrLabelDiffLHS()));
+    if (!ImpLHS) {
+      Error = ImpLHS.takeError();
+      break;
+    }
+    llvm::Expected<Expr *> ImpRHS =
+        Import(const_cast<AddrLabelExpr *>(FromValue.getAddrLabelDiffRHS()));
+    if (!ImpRHS) {
+      Error = ImpRHS.takeError();
+      break;
+    }
+    Result.setAddrLabelDiff(cast<AddrLabelExpr>(ImpLHS.get()),
+                            cast<AddrLabelExpr>(ImpRHS.get()));
+    break;
+  }
+  case APValue::MemberPointer: {
+    llvm::Expected<const Decl *> ImpMemPtrDecl =
+        Import(FromValue.getMemberPointerDecl());
+    if (!ImpMemPtrDecl) {
+      Error = ImpMemPtrDecl.takeError();
+      break;
+    }
+    Result.MakeEmptyMemberPointer(cast<const ValueDecl>(ImpMemPtrDecl.get()),
+                                  FromValue.isMemberPointerToDerivedMember(),
+                                  FromValue.getMemberPointerPath().size());
+    llvm::ArrayRef<const CXXRecordDecl *> FromPath =
+        Result.getMemberPointerPath();
+    const CXXRecordDecl **ToPath = Result.getMemberPointerPathPtr();
+    for (unsigned Idx = 0; Idx < FromValue.getMemberPointerPath().size();
+         Idx++) {
+      llvm::Expected<const Decl *> ImpDecl = Import(FromPath[Idx]);
+      if (!ImpDecl) {
+        Error = ImpDecl.takeError();
+        break;
+      }
+      ToPath[Idx] = cast<const CXXRecordDecl>(const_cast<Decl *>(ImpDecl.get()));
+    }
+    break;
+  }
+  case APValue::LValue:
+    APValue::LValueBase Base;
+    QualType FromElemTy;
+    if (FromValue.getLValueBase()) {
+      if (!FromValue.getLValueBase().is<TypeInfoLValue>()) {
+        if (auto *E = FromValue.getLValueBase().dyn_cast<const Expr *>()) {
+          FromElemTy = E->getType();
+          llvm::Expected<Expr *> ImpExpr = Import(const_cast<Expr *>(E));
+          if (!ImpExpr) {
+            Error = ImpExpr.takeError();
+            break;
+          }
+          Base = APValue::LValueBase(ImpExpr.get(),
+                                     FromValue.getLValueBase().getCallIndex(),
+                                     FromValue.getLValueBase().getVersion());
+        } else {
+          FromElemTy =
+              FromValue.getLValueBase().get<const ValueDecl *>()->getType();
+          llvm::Expected<const Decl *> ImpDecl =
+              Import(FromValue.getLValueBase().get<const ValueDecl *>());
+          if (!ImpDecl) {
+            Error = ImpDecl.takeError();
+            break;
+          }
+          Base = APValue::LValueBase(cast<ValueDecl>(ImpDecl.get()),
+                                     FromValue.getLValueBase().getCallIndex(),
+                                     FromValue.getLValueBase().getVersion());
+        }
+      } else {
+        FromElemTy = FromValue.getLValueBase().getTypeInfoType();
+        llvm::Expected<QualType> ImpTypeInfo = Import(QualType(
+            FromValue.getLValueBase().get<TypeInfoLValue>().getType(), 0));
+        if (!ImpTypeInfo) {
+          Error = ImpTypeInfo.takeError();
+          break;
+        }
+        llvm::Expected<QualType> ImpType =
+            Import(FromValue.getLValueBase().getTypeInfoType());
+        if (!ImpType) {
+          Error = ImpType.takeError();
+          break;
+        }
+        Base = APValue::LValueBase::getTypeInfo(
+            TypeInfoLValue(ImpTypeInfo.get().getTypePtr()), ImpType.get());
+      }
+    }
+    CharUnits Offset = FromValue.getLValueOffset();
+    unsigned PathLength = FromValue.getLValuePath().size();
+    Result.MakeLValue();
+    if (FromValue.hasLValuePath()) {
+      Result.setLValueEmptyPath(Base, Offset, PathLength,
+                                FromValue.isLValueOnePastTheEnd(),
+                                FromValue.isNullPointer());
+      llvm::ArrayRef<APValue::LValuePathEntry> FromPath =
+          FromValue.getLValuePath();
+      APValue::LValuePathEntry *ToPath = Result.getLValuePathPtr();
+      for (unsigned LoopIdx = 0; LoopIdx < PathLength; LoopIdx++) {
+        if (FromElemTy->getAs<RecordType>()) {
+          const Decl *FromDecl =
+              FromPath[LoopIdx].getAsBaseOrMember().getPointer();
+          llvm::Expected<const Decl *> ImpDecl = Import(FromDecl);
+          if (!ImpDecl) {
+            Error = ImpDecl.takeError();
+            break;
+          }
+          if (auto *RD = dyn_cast<CXXRecordDecl>(FromDecl))
+            FromElemTy = FromContext.getRecordType(RD);
+          else
+            FromElemTy = cast<ValueDecl>(FromDecl)->getType();
+          ToPath[LoopIdx] = APValue::LValuePathEntry(APValue::BaseOrMemberType(
+              ImpDecl.get(), FromPath[LoopIdx].getAsBaseOrMember().getInt()));
+        } else {
+          FromElemTy = FromContext.getAsArrayType(FromElemTy)->getElementType();
+          ToPath[LoopIdx] = APValue::LValuePathEntry::ArrayIndex(
+              FromPath[LoopIdx].getAsArrayIndex());
+        }
+      }
+    } else
+      Result.setLValue(Base, Offset, APValue::NoLValuePath{},
+                       FromValue.isNullPointer());
+  }
+  if (Error)
+    return std::move(Error);
+  return Result;
+}
+
 Expected<DeclarationName> ASTImporter::HandleNameConflict(DeclarationName Name,
                                                           DeclContext *DC,
                                                           unsigned IDNS,
                                                           NamedDecl **Decls,
                                                           unsigned NumDecls) {
   if (ODRHandling == ODRHandlingType::Conservative)
     // Report error at any name conflict.
     return make_error<ImportError>(ImportError::NameConflict);
if (Pos != ImportedDecls.end())
     return Pos->second;
   ImportedDecls[From] = To;
   // This mapping should be maintained only in this function. Therefore do not
   // check for additional consistency.
   ImportedFromDecls[To] = From;
   AddToLookupTable(To);
   return To;
 }
 
 llvm::Optional<ImportError>
 ASTImporter::getImportDeclErrorIfAny(Decl *FromD) const {
   auto Pos = ImportDeclErrors.find(FromD);
   if (Pos != ImportDeclErrors.end())
     return Pos->second;
   else
     return Optional<ImportError>();
 }
 
 void ASTImporter::setImportDeclError(Decl *From, ImportError Error) {
   auto InsertRes = ImportDeclErrors.insert({From, Error});
   (void)InsertRes;
   // Either we set the error for the first time, or we already had set one and

clang/lib/AST/Decl.cpp

APValue *VarDecl::evaluateValue(
   // Ensure the computed APValue is cleaned up later if evaluation succeeded,
   // or that it's empty (so that there's nothing to clean up) if evaluation
   // failed.
   if (!Result)
     Eval->Evaluated = APValue();
   else if (Eval->Evaluated.needsCleanup())
     getASTContext().addDestruction(&Eval->Evaluated);
 
+  if (auto *ConstantInit = dyn_cast<ConstantExpr>(Eval->Value))
+    if (ConstantExpr::getStorageKind(Eval->Evaluated) <=
+        ConstantInit->getResultStorageKind())
+      ConstantInit->SetResult(Eval->Evaluated, getASTContext());
+
   Eval->IsEvaluating = false;
   Eval->WasEvaluated = true;
 
   // In C++11, we have determined whether the initializer was a constant
   // expression as a side-effect.
   if (getASTContext().getLangOpts().CPlusPlus11 && !Eval->CheckedICE) {
     Eval->CheckedICE = true;
     Eval->IsICE = Result && Notes.empty();

clang/lib/AST/Expr.cpp

ConstantExpr::getStorageKind(const Type *T, const ASTContext &Context) {
   if (T->isIntegralOrEnumerationType() && Context.getTypeInfo(T).Width <= 64)
     return ConstantExpr::RSK_Int64;
   return ConstantExpr::RSK_APValue;
 }
 
 void ConstantExpr::DefaultInit(ResultStorageKind StorageKind) {
   ConstantExprBits.ResultKind = StorageKind;
   ConstantExprBits.APValueKind = APValue::None;
+  ConstantExprBits.BitWidth = 0;
+  ConstantExprBits.IsUnsigned = false;
   ConstantExprBits.HasCleanup = false;
   if (StorageKind == ConstantExpr::RSK_APValue)
     ::new (getTrailingObjects<APValue>()) APValue();
 }
 
 ConstantExpr::ConstantExpr(Expr *subexpr, ResultStorageKind StorageKind)
     : FullExpr(ConstantExprClass, subexpr) {
   DefaultInit(StorageKind);
 }
 
 ConstantExpr *ConstantExpr::Create(const ASTContext &Context, Expr *E,
                                    ResultStorageKind StorageKind) {
   assert(!isa<ConstantExpr>(E));
   AssertResultStorageKind(StorageKind);
   unsigned Size = totalSizeToAlloc<APValue, uint64_t>(
       StorageKind == ConstantExpr::RSK_APValue,
       StorageKind == ConstantExpr::RSK_Int64);
   void *Mem = Context.Allocate(Size, alignof(ConstantExpr));
-  ConstantExpr *Self = new (Mem) ConstantExpr(E, StorageKind);
-  return Self;
+  return new (Mem) ConstantExpr(E, StorageKind);
 }
 
 ConstantExpr *ConstantExpr::Create(const ASTContext &Context, Expr *E,
                                    const APValue &Result) {
   ResultStorageKind StorageKind = getStorageKind(Result);
   ConstantExpr *Self = Create(Context, E, StorageKind);
   Self->SetResult(Result, Context);
   return Self;
unsigned Size = totalSizeToAlloc<APValue, uint64_t>(
       StorageKind == ConstantExpr::RSK_APValue,
       StorageKind == ConstantExpr::RSK_Int64);
   void *Mem = Context.Allocate(Size, alignof(ConstantExpr));
   ConstantExpr *Self = new (Mem) ConstantExpr(StorageKind, Empty);
   return Self;
 }
 
 void ConstantExpr::MoveIntoResult(APValue &Value, const ASTContext &Context) {
-  assert(getStorageKind(Value) == ConstantExprBits.ResultKind &&
+  assert(getStorageKind(Value) <= ConstantExprBits.ResultKind &&
          "Invalid storage for this value kind");
   ConstantExprBits.APValueKind = Value.getKind();
+  if (!Value.hasValue())
+    return;
   switch (ConstantExprBits.ResultKind) {
   case RSK_None:
     return;
   case RSK_Int64:
     Int64Result() = *Value.getInt().getRawData();
     ConstantExprBits.BitWidth = Value.getInt().getBitWidth();
     ConstantExprBits.IsUnsigned = Value.getInt().isUnsigned();
     return;
   case RSK_APValue:
     if (!ConstantExprBits.HasCleanup && Value.needsCleanup()) {
       ConstantExprBits.HasCleanup = true;
case ConstantExpr::RSK_Int64:
     return llvm::APSInt(llvm::APInt(ConstantExprBits.BitWidth, Int64Result()),
                         ConstantExprBits.IsUnsigned);
   default:
     llvm_unreachable("invalid Accessor");
   }
 }
 
 APValue ConstantExpr::getAPValueResult() const {
+  if (ConstantExprBits.APValueKind == APValue::None)
+    return APValue();
+  else if (ConstantExprBits.APValueKind == APValue::Indeterminate)
+    return APValue::IndeterminateValue();
   switch (ConstantExprBits.ResultKind) {
   case ConstantExpr::RSK_APValue:
     return APValueResult();
   case ConstantExpr::RSK_Int64:
     return APValue(
         llvm::APSInt(llvm::APInt(ConstantExprBits.BitWidth, Int64Result()),
                      ConstantExprBits.IsUnsigned));
   case ConstantExpr::RSK_None:

clang/lib/AST/TextNodeDumper.cpp

void TextNodeDumper::VisitCaseStmt(const CaseStmt *Node) {
   if (Node->caseStmtIsGNURange())
     OS << " gnu_range";
 }
 
 void TextNodeDumper::VisitConstantExpr(const ConstantExpr *Node) {
   if (Node->getResultAPValueKind() != APValue::None) {
     ColorScope Color(OS, ShowColors, ValueColor);
     OS << " ";
-    Node->getAPValueResult().dump(OS);
+    Node->getAPValueResult().dumpPretty(OS, Node->getType(), PrintPolicy);
   }
 }
 
 void TextNodeDumper::VisitCallExpr(const CallExpr *Node) {
   if (Node->usesADL())
     OS << " adl";
 }
 
 void TextNodeDumper::VisitCastExpr(const CastExpr *Node) {
   OS << " <";

clang/lib/Sema/SemaDecl.cpp

if (!VDecl->isInvalidDecl()) {
     if (FunctionScopeInfo *FSI = getCurFunction())
       if ((VDecl->getType().getObjCLifetime() == Qualifiers::OCL_Strong ||
            VDecl->getType().isNonWeakInMRRWithObjCWeak(Context)) &&
           !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak,
                            Init->getBeginLoc()))
         FSI->markSafeWeakUse(Init);
   }
 
+  if (VDecl->isConstexpr())
+    Init = ConstantExpr::Create(
+        Context, Init,
+        ConstantExpr::getStorageKind(VDecl->getType()->getAs<Type>(), Context));
+
   // The initialization is usually a full-expression.
   //
   // FIXME: If this is a braced initialization of an aggregate, it is not
   // an expression, and each individual field initializer is a separate
   // full-expression. For instance, in:
   //
   //   struct Temp { ~Temp(); };
   //   struct S { S(Temp); };
   //   struct T { S a, b; } t = { Temp(), Temp() }
   //
   // we should destroy the first Temp before constructing the second.
   ExprResult Result =
       ActOnFinishFullExpr(Init, VDecl->getLocation(),
                           /*DiscardedValue*/ false, VDecl->isConstexpr());
   if (Result.isInvalid()) {
     VDecl->setInvalidDecl();
     return;
   }
   Init = Result.get();
 
   // Attach the initializer to the decl.
   VDecl->setInit(Init);

clang/lib/Serialization/ASTReader.cpp

ReadFixedPointSemantics(const SmallVectorImpl<uint64_t> &Record,
   uint64_t Tmp = Record[Idx++];
   bool IsSigned = Tmp & 0x1;
   bool IsSaturated = Tmp & 0x2;
   bool HasUnsignedPadding = Tmp & 0x4;
   return FixedPointSemantics(Width, Scale, IsSigned, IsSaturated,
                              HasUnsignedPadding);
 }
 
-APValue ASTReader::ReadAPValue(const RecordData &Record, unsigned &Idx) {
-  unsigned Kind = Record[Idx++];
+APValue ASTReader::ReadAPValue(ModuleFile &F, const RecordData &Record,
+                               unsigned &RecordIdx) {
+  auto Kind = static_cast<APValue::ValueKind>(Record[RecordIdx++]);
   switch (Kind) {
   case APValue::None:
     return APValue();
   case APValue::Indeterminate:
     return APValue::IndeterminateValue();
   case APValue::Int:
-    return APValue(ReadAPSInt(Record, Idx));
+    return APValue(ReadAPSInt(Record, RecordIdx));
   case APValue::Float: {
     const llvm::fltSemantics &FloatSema = llvm::APFloatBase::EnumToSemantics(
-        static_cast<llvm::APFloatBase::Semantics>(Record[Idx++]));
-    return APValue(ReadAPFloat(Record, FloatSema, Idx));
+        static_cast<llvm::APFloatBase::Semantics>(Record[RecordIdx++]));
+    return APValue(ReadAPFloat(Record, FloatSema, RecordIdx));
   }
   case APValue::FixedPoint: {
-    FixedPointSemantics FPSema = ReadFixedPointSemantics(Record, Idx);
-    return APValue(APFixedPoint(ReadAPInt(Record, Idx), FPSema));
+    FixedPointSemantics FPSema = ReadFixedPointSemantics(Record, RecordIdx);
+    return APValue(APFixedPoint(ReadAPInt(Record, RecordIdx), FPSema));
   }
   case APValue::ComplexInt: {
-    llvm::APSInt First = ReadAPSInt(Record, Idx);
-    return APValue(std::move(First), ReadAPSInt(Record, Idx));
+    llvm::APSInt First = ReadAPSInt(Record, RecordIdx);
+    return APValue(std::move(First), ReadAPSInt(Record, RecordIdx));
   }
   case APValue::ComplexFloat: {
     const llvm::fltSemantics &FloatSema1 = llvm::APFloatBase::EnumToSemantics(
-        static_cast<llvm::APFloatBase::Semantics>(Record[Idx++]));
-    llvm::APFloat First = ReadAPFloat(Record, FloatSema1, Idx);
+        static_cast<llvm::APFloatBase::Semantics>(Record[RecordIdx++]));
+    llvm::APFloat First = ReadAPFloat(Record, FloatSema1, RecordIdx);
     const llvm::fltSemantics &FloatSema2 = llvm::APFloatBase::EnumToSemantics(
-        static_cast<llvm::APFloatBase::Semantics>(Record[Idx++]));
-    return APValue(std::move(First), ReadAPFloat(Record, FloatSema2, Idx));
+        static_cast<llvm::APFloatBase::Semantics>(Record[RecordIdx++]));
+    return APValue(std::move(First),
+                   ReadAPFloat(Record, FloatSema2, RecordIdx));
+  }
+  case APValue::Vector: {
+    APValue Result;
+    Result.MakeVector();
+    unsigned Length = Record[RecordIdx++];
+    Result.reserveVector(Length);
+    for (unsigned LoopIdx = 0; LoopIdx < Length; LoopIdx++)
+      Result.getVectorElt(LoopIdx) = ReadAPValue(F, Record, RecordIdx);
+    return Result;
+  }
+  case APValue::Array: {
+    APValue Result;
+    unsigned InitLength = Record[RecordIdx++];
+    unsigned TotalLength = Record[RecordIdx++];
+    Result.MakeArray(InitLength, TotalLength);
+    for (unsigned LoopIdx = 0; LoopIdx < InitLength; LoopIdx++)
+      Result.getArrayInitializedElt(LoopIdx) =
+          ReadAPValue(F, Record, RecordIdx);
+    return Result;
+  }
+  case APValue::Struct: {
+    APValue Result;
+    unsigned BasesLength = Record[RecordIdx++];
+    unsigned FieldsLength = Record[RecordIdx++];
+    Result.MakeStruct(BasesLength, FieldsLength);
+    for (unsigned LoopIdx = 0; LoopIdx < BasesLength; LoopIdx++)
+      Result.getStructBase(LoopIdx) = ReadAPValue(F, Record, RecordIdx);
+    for (unsigned LoopIdx = 0; LoopIdx < FieldsLength; LoopIdx++)
+      Result.getStructField(LoopIdx) = ReadAPValue(F, Record, RecordIdx);
+    return Result;
+  }
+  case APValue::Union: {
+    auto *FDecl = cast<FieldDecl>(GetDecl(ReadDeclID(F, Record, RecordIdx)));
+    APValue Value = ReadAPValue(F, Record, RecordIdx);
+    return APValue(FDecl, Value);
+  }
+  case APValue::AddrLabelDiff: {
+    auto *LHS = cast<AddrLabelExpr>(ReadExpr(F));
+    auto *RHS = cast<AddrLabelExpr>(ReadExpr(F));
+    return APValue(LHS, RHS);
+  }
+  case APValue::MemberPointer: {
+    APValue Result;
+    bool IsDerived = Record[RecordIdx++];
+    auto *Member = cast<ValueDecl>(GetDecl(ReadDeclID(F, Record, RecordIdx)));
+    unsigned PathSize = Record[RecordIdx++];
+    Result.MakeEmptyMemberPointer(Member, IsDerived, PathSize);
+    const CXXRecordDecl **PathArray = Result.getMemberPointerPathPtr();
+    for (unsigned LoopIdx = 0; LoopIdx < PathSize; LoopIdx++)
+      PathArray[LoopIdx] =
+          cast<const CXXRecordDecl>(GetDecl(ReadDeclID(F, Record, RecordIdx)));
+    return Result;
+  }
+  case APValue::LValue: {
+    uint64_t Bits = Record[RecordIdx++];
+    bool HasLValuePath = Bits & 0x1;
+    bool IsLValueOnePastTheEnd = Bits & 0x2;
+    bool IsExpr = Bits & 0x4;
+    bool IsTypeInfo = Bits & 0x8;
+    bool IsNullPtr = Bits & 0x10;
+    bool HasBase = Bits & 0x20;
+    APValue::LValueBase Base;
+    QualType ElemTy;
+    assert((!IsExpr || !IsTypeInfo) && "LValueBase cannot be both");
+    if (HasBase) {
+      if (!IsTypeInfo) {
+        unsigned CallIndex = Record[RecordIdx++];
+        unsigned Version = Record[RecordIdx++];
+        if (IsExpr) {
+          Base = APValue::LValueBase(ReadExpr(F), CallIndex, Version);
+          ElemTy = Base.get<const Expr *>()->getType();
+        } else {
+          Base = APValue::LValueBase(
+              cast<ValueDecl>(GetDecl(ReadDeclID(F, Record, RecordIdx))),
+              CallIndex, Version);
+          ElemTy = Base.get<const ValueDecl *>()->getType();
+        }
+      } else {
+        QualType TypeInfo = readType(F, Record, RecordIdx);
+        QualType Type = readType(F, Record, RecordIdx);
+        Base = APValue::LValueBase::getTypeInfo(
+            TypeInfoLValue(TypeInfo.getTypePtr()), Type);
+        Base.getTypeInfoType();
+      }
+    }
+    CharUnits Offset = CharUnits::fromQuantity(Record[RecordIdx++]);
+    unsigned PathLength = Record[RecordIdx++];
+    APValue Result;
+    Result.MakeLValue();
+    if (HasLValuePath) {
+      Result.setLValueEmptyPath(Base, Offset, PathLength, IsLValueOnePastTheEnd,
+                                IsNullPtr);
+      APValue::LValuePathEntry *Path = Result.getLValuePathPtr();
+      for (unsigned LoopIdx = 0; LoopIdx < PathLength; LoopIdx++) {
+        if (ElemTy->getAs<RecordType>()) {
+          unsigned Int = Record[RecordIdx++];
+          Decl *D = GetDecl(ReadDeclID(F, Record, RecordIdx));
+          if (auto *RD = dyn_cast<CXXRecordDecl>(D))
+            ElemTy = ContextObj->getRecordType(RD);
+          else
+            ElemTy = cast<ValueDecl>(D)->getType();
+          Path[LoopIdx] =
+              APValue::LValuePathEntry(APValue::BaseOrMemberType(D, Int));
+        } else {
+          ElemTy = ContextObj->getAsArrayType(ElemTy)->getElementType();
+          Path[LoopIdx] =
+              APValue::LValuePathEntry::ArrayIndex(Record[RecordIdx++]);
+        }
+      }
+    } else
+      Result.setLValue(Base, Offset, APValue::NoLValuePath{}, IsNullPtr);
+    return Result;
   }
-  case APValue::LValue:
-  case APValue::Vector:
-  case APValue::Array:
-  case APValue::Struct:
-  case APValue::Union:
-  case APValue::MemberPointer:
-  case APValue::AddrLabelDiff:
-    // TODO : Handle all these APValue::ValueKind.
-    return APValue();
   }
   llvm_unreachable("Invalid APValue::ValueKind");
 }
 
 /// Read an integral value
 llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
   unsigned BitWidth = Record[Idx++];
   unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
   llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);

           ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
                       VarSingleInitializer)
               << SecondName << (SecondInit == nullptr)
               << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
           Diagnosed = true;
           break;
         }
 
-        if (FirstInit && SecondInit &&
-            ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
-          ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
-                       VarDifferentInitializer)
-              << FirstName << FirstInit->getSourceRange();
-          ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
-                      VarDifferentInitializer)
-              << SecondName << SecondInit->getSourceRange();
-          Diagnosed = true;
-          break;
-        }
-
         const bool FirstIsConstexpr = FirstVD->isConstexpr();
         const bool SecondIsConstexpr = SecondVD->isConstexpr();
         if (FirstIsConstexpr != SecondIsConstexpr) {
           ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
                        VarConstexpr)
               << FirstName << FirstIsConstexpr;
           ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
                       VarConstexpr)
               << SecondName << SecondIsConstexpr;
           Diagnosed = true;
           break;
         }
+
+        if (FirstInit && SecondInit &&
+            ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
+          ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
+                       VarDifferentInitializer)
+              << FirstName << FirstInit->getSourceRange();
+          ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
+                      VarDifferentInitializer)
+              << SecondName << SecondInit->getSourceRange();
+          Diagnosed = true;
+          break;
+        }
+
         break;
       }
       case Friend: {
         FriendDecl *FirstFriend = cast<FriendDecl>(FirstDecl);
         FriendDecl *SecondFriend = cast<FriendDecl>(SecondDecl);
 
         NamedDecl *FirstND = FirstFriend->getFriendDecl();
         NamedDecl *SecondND = SecondFriend->getFriendDecl();

clang/lib/Serialization/ASTReaderStmt.cpp

 }
 
 void ASTStmtReader::VisitConstantExpr(ConstantExpr *E) {
   VisitExpr(E);
   E->ConstantExprBits.ResultKind = Record.readInt();
   switch (E->ConstantExprBits.ResultKind) {
   case ConstantExpr::RSK_Int64: {
     E->Int64Result() = Record.readInt();
-    uint64_t tmp = Record.readInt();
-    E->ConstantExprBits.IsUnsigned = tmp & 0x1;
-    E->ConstantExprBits.BitWidth = tmp >> 1;
+    uint64_t Bits = Record.readInt();
+    E->ConstantExprBits.IsUnsigned = Bits & 0x1;
+    E->ConstantExprBits.BitWidth = (Bits >> 1) & /*7 bottom bits set*/ 0x7f;
+    E->ConstantExprBits.APValueKind = Bits >> 8;
     break;
   }
   case ConstantExpr::RSK_APValue:
-    E->APValueResult() = Record.readAPValue();
+    E->SetResult(Record.readAPValue(), Record.getContext());
   }
   E->setSubExpr(Record.readSubExpr());
 }
 
 void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
   VisitExpr(E);
   bool HasFunctionName = Record.readInt();
   E->PredefinedExprBits.HasFunctionName = HasFunctionName;

clang/lib/Serialization/ASTWriter.cpp

case APValue::ComplexFloat: {
     push_back(static_cast<uint64_t>(llvm::APFloatBase::SemanticsToEnum(
         Value.getComplexFloatReal().getSemantics())));
     AddAPFloat(Value.getComplexFloatReal());
     push_back(static_cast<uint64_t>(llvm::APFloatBase::SemanticsToEnum(
         Value.getComplexFloatImag().getSemantics())));
     AddAPFloat(Value.getComplexFloatImag());
     return;
   }
-  case APValue::LValue:
   case APValue::Vector:
+    push_back(Value.getVectorLength());
+    for (unsigned Idx = 0; Idx < Value.getVectorLength(); Idx++)
+      AddAPValue(Value.getVectorElt(Idx));
+    return;
   case APValue::Array:
+    push_back(Value.getArrayInitializedElts());
+    push_back(Value.getArraySize());
+    for (unsigned Idx = 0; Idx < Value.getArrayInitializedElts(); Idx++)
+      AddAPValue(Value.getArrayInitializedElt(Idx));
+    return;
   case APValue::Struct:
+    push_back(Value.getStructNumBases());
+    push_back(Value.getStructNumFields());
+    for (unsigned Idx = 0; Idx < Value.getStructNumBases(); Idx++)
+      AddAPValue(Value.getStructBase(Idx));
+    for (unsigned Idx = 0; Idx < Value.getStructNumFields(); Idx++)
+      AddAPValue(Value.getStructField(Idx));
+    return;
   case APValue::Union:
-  case APValue::MemberPointer:
+    AddDeclRef(Value.getUnionField());
+    AddAPValue(Value.getUnionValue());
+    return;
   case APValue::AddrLabelDiff:
-    // TODO : Handle all these APValue::ValueKind.
+    AddStmt(const_cast<AddrLabelExpr *>(Value.getAddrLabelDiffLHS()));
+    AddStmt(const_cast<AddrLabelExpr *>(Value.getAddrLabelDiffRHS()));
+    return;
+  case APValue::MemberPointer: {
+    push_back(Value.isMemberPointerToDerivedMember());
+    AddDeclRef(Value.getMemberPointerDecl());
+    ArrayRef<const CXXRecordDecl *> RecordPath = Value.getMemberPointerPath();
+    push_back(RecordPath.size());
+    for (auto Elem : RecordPath)
+      AddDeclRef(Elem);
+    return;
+  }
+  case APValue::LValue: {
+    push_back(Value.hasLValuePath() | Value.isLValueOnePastTheEnd() << 1 |
+              Value.getLValueBase().is<const Expr *>() << 2 |
+              Value.getLValueBase().is<TypeInfoLValue>() << 3 |
+              Value.isNullPointer() << 4 |
+              static_cast<bool>(Value.getLValueBase()) << 5);
+    QualType ElemTy;
+    if (Value.getLValueBase()) {
+      if (!Value.getLValueBase().is<TypeInfoLValue>()) {
+        push_back(Value.getLValueBase().getCallIndex());
+        push_back(Value.getLValueBase().getVersion());
+        if (const auto *E = Value.getLValueBase().dyn_cast<const Expr *>()) {
+          AddStmt(const_cast<Expr *>(E));
+          ElemTy = E->getType();
+        } else {
+          AddDeclRef(Value.getLValueBase().get<const ValueDecl *>());
+          ElemTy = Value.getLValueBase().get<const ValueDecl *>()->getType();
+        }
+      } else {
+        AddTypeRef(
+            QualType(Value.getLValueBase().get<TypeInfoLValue>().getType(), 0));
+        AddTypeRef(Value.getLValueBase().getTypeInfoType());
+        ElemTy = Value.getLValueBase().getTypeInfoType();
+      }
+    }
+    push_back(Value.getLValueOffset().getQuantity());
+    push_back(Value.getLValuePath().size());
+    if (Value.hasLValuePath()) {
+      ArrayRef<APValue::LValuePathEntry> Path = Value.getLValuePath();
+      for (auto Elem : Path) {
+        if (ElemTy->getAs<RecordType>()) {
+          push_back(Elem.getAsBaseOrMember().getInt());
+          const Decl *BaseOrMember = Elem.getAsBaseOrMember().getPointer();
+          if (const auto *RD = dyn_cast<CXXRecordDecl>(BaseOrMember)) {
+            AddDeclRef(RD);
+            ElemTy = Writer->Context->getRecordType(RD);
+          } else {
+            const auto *VD = cast<ValueDecl>(BaseOrMember);
+            AddDeclRef(VD);
+            ElemTy = VD->getType();
+          }
+        } else {
+          push_back(Elem.getAsArrayIndex());
+          ElemTy = Writer->Context->getAsArrayType(ElemTy)->getElementType();
+        }
+      }
+    }
+  }
     return;
   }
   llvm_unreachable("Invalid APValue::ValueKind");
 }
 
 void ASTWriter::AddIdentifierRef(const IdentifierInfo *II, RecordDataImpl &Record) {
   Record.push_back(getIdentifierRef(II));
 }
 
 IdentID ASTWriter::getIdentifierRef(const IdentifierInfo *II) {
   if (!II)
     return 0;
 
   IdentID &ID = IdentifierIDs[II];

clang/lib/Serialization/ASTWriterStmt.cpp

class ASTStmtWriter : public StmtVisitor<ASTStmtWriter, void> {
     serialization::StmtCode Code;
     unsigned AbbrevToUse;
 
   public:
     ASTStmtWriter(ASTWriter &Writer, ASTWriter::RecordData &Record)
         : Writer(Writer), Record(Writer, Record),
           Code(serialization::STMT_NULL_PTR), AbbrevToUse(0) {}
 
     ASTStmtWriter(const ASTStmtWriter&) = delete;
 
     uint64_t Emit() {
       assert(Code != serialization::STMT_NULL_PTR &&
              "unhandled sub-statement writing AST file");
       return Record.EmitStmt(Code, AbbrevToUse);
     }
 
     void AddTemplateKWAndArgsInfo(const ASTTemplateKWAndArgsInfo &ArgInfo,

 
 void ASTStmtWriter::VisitConstantExpr(ConstantExpr *E) {
   VisitExpr(E);
   Record.push_back(static_cast<uint64_t>(E->ConstantExprBits.ResultKind));
   switch (E->ConstantExprBits.ResultKind) {
   case ConstantExpr::RSK_Int64:
     Record.push_back(E->Int64Result());
     Record.push_back(E->ConstantExprBits.IsUnsigned |
-                     E->ConstantExprBits.BitWidth << 1);
+                     E->ConstantExprBits.BitWidth << 1 |
+                     E->ConstantExprBits.APValueKind << 8);
     break;
   case ConstantExpr::RSK_APValue:
     Record.AddAPValue(E->APValueResult());
   }
   Record.AddStmt(E->getSubExpr());
   Code = serialization::EXPR_CONSTANT;
 }
 

clang/test/AST/ast-dump-color.cpp

 //CHECK: {{^}}[[Blue]]|     |-[[RESET]][[Blue]]TextComment[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:5:4[[RESET]]> Text=" "{{$}}
 //CHECK: {{^}}[[Blue]]|     `-[[RESET]][[Blue]]HTMLStartTagComment[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:5[[RESET]], [[Yellow]]col:8[[RESET]]> Name="br" SelfClosing{{$}}
 //CHECK: {{^}}[[Blue]]|-[[RESET]][[GREEN]]FunctionDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:9:1[[RESET]], [[Yellow]]line:16:1[[RESET]]> [[Yellow]]line:9:6[[RESET]][[CYAN]] TestAttributedStmt[[RESET]] [[Green]]'void ()'[[RESET]]{{$}}
 //CHECK: {{^}}[[Blue]]| |-[[RESET]][[MAGENTA:.\[0;1;35m]]CompoundStmt[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:27[[RESET]], [[Yellow]]line:16:1[[RESET]]>{{$}}
 //CHECK: {{^}}[[Blue]]| | `-[[RESET]][[MAGENTA]]SwitchStmt[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:10:3[[RESET]], [[Yellow]]line:15:3[[RESET]]>{{$}}
 //CHECK: {{^}}[[Blue]]| |   |-[[RESET]][[MAGENTA]]IntegerLiteral[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:10:11[[RESET]]> [[Green]]'int'[[RESET]][[Cyan:.\[0;36m]][[RESET]][[Cyan]][[RESET]][[CYAN]] 1[[RESET]]{{$}}
 //CHECK: {{^}}[[Blue]]| |   `-[[RESET]][[MAGENTA]]CompoundStmt[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:14[[RESET]], [[Yellow]]line:15:3[[RESET]]>{{$}}
 //CHECK: {{^}}[[Blue]]| |     |-[[RESET]][[MAGENTA]]CaseStmt[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:11:3[[RESET]], [[Yellow]]line:12:27[[RESET]]>{{$}}
-//CHECK: {{^}}[[Blue]]| |     | |-[[RESET]][[MAGENTA]]ConstantExpr[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:11:8[[RESET]]> [[Green]]'int'[[RESET]][[Cyan]][[RESET]][[Cyan]][[RESET]][[CYAN]] Int: 1[[RESET]]{{$}}
+//CHECK: {{^}}[[Blue]]| |     | |-[[RESET]][[MAGENTA]]ConstantExpr[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:11:8[[RESET]]> [[Green]]'int'[[RESET]][[Cyan]][[RESET]][[Cyan]][[RESET]][[CYAN]] 1[[RESET]]{{$}}
 //CHECK: {{^}}[[Blue]]| |     | | `-[[RESET]][[MAGENTA]]IntegerLiteral[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:8[[RESET]]> [[Green]]'int'[[RESET]][[Cyan]][[RESET]][[Cyan]][[RESET]][[CYAN]] 1[[RESET]]{{$}}
 //CHECK: {{^}}[[Blue]]| |     | `-[[RESET]][[MAGENTA]]AttributedStmt[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:12:5[[RESET]], [[Yellow]]col:27[[RESET]]>{{$}}
 //CHECK: {{^}}[[Blue]]| |     |   |-[[RESET]][[BLUE]]FallThroughAttr[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:7[[RESET]], [[Yellow]]col:14[[RESET]]>{{$}}
 //CHECK: {{^}}[[Blue]]| |     |   `-[[RESET]][[MAGENTA]]NullStmt[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:27[[RESET]]>{{$}}
 //CHECK: {{^}}[[Blue]]| |     `-[[RESET]][[MAGENTA]]CaseStmt[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:13:3[[RESET]], [[Yellow]]line:14:5[[RESET]]>{{$}}
-//CHECK: {{^}}[[Blue]]| |       |-[[RESET]][[MAGENTA]]ConstantExpr[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:13:8[[RESET]]> [[Green]]'int'[[RESET]][[Cyan]][[RESET]][[Cyan]][[RESET]][[CYAN]] Int: 2[[RESET]]{{$}}
+//CHECK: {{^}}[[Blue]]| |       |-[[RESET]][[MAGENTA]]ConstantExpr[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:13:8[[RESET]]> [[Green]]'int'[[RESET]][[Cyan]][[RESET]][[Cyan]][[RESET]][[CYAN]] 2[[RESET]]{{$}}
 //CHECK: {{^}}[[Blue]]| |       | `-[[RESET]][[MAGENTA]]IntegerLiteral[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:8[[RESET]]> [[Green]]'int'[[RESET]][[Cyan]][[RESET]][[Cyan]][[RESET]][[CYAN]] 2[[RESET]]{{$}}
 //CHECK: {{^}}[[Blue]]| |       `-[[RESET]][[MAGENTA]]NullStmt[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:14:5[[RESET]]>{{$}}
 //CHECK: {{^}}[[Blue]]| `-[[RESET]][[Blue]]FullComment[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:8:4[[RESET]], [[Yellow]]col:11[[RESET]]>{{$}}
 //CHECK: {{^}}[[Blue]]|   `-[[RESET]][[Blue]]ParagraphComment[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:4[[RESET]], [[Yellow]]col:11[[RESET]]>{{$}}
 //CHECK: {{^}}[[Blue]]|     `-[[RESET]][[Blue]]TextComment[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:4[[RESET]], [[Yellow]]col:11[[RESET]]> Text=" Comment"{{$}}
 //CHECK: {{^}}[[Blue]]|-[[RESET]][[GREEN]]CXXRecordDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:18:1[[RESET]], [[Yellow]]line:25:1[[RESET]]> [[Yellow]]line:18:33[[RESET]] class[[CYAN]] Mutex[[RESET]] definition{{$}}
 //CHECK: {{^}}[[Blue]]| |-[[RESET]][[BLUE]]CapabilityAttr[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:22[[RESET]]> capability "mutex"{{$}}
 //CHECK: {{^}}[[Blue]]| |-[[RESET]][[GREEN]]CXXRecordDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:1[[RESET]], [[Yellow]]col:33[[RESET]]> [[Yellow]]col:33[[RESET]] implicit class[[CYAN]] Mutex[[RESET]]{{$}}

clang/test/ASTMerge/APValue/APValue.cpp

+// RUN: %clang_cc1 -x c++ -std=gnu++2a -emit-pch %s -o %t.pch
+// RUN: %clang_cc1 -x c++ -std=gnu++2a -ast-merge %t.pch -ast-dump-all | FileCheck %s
+
+#ifndef EMIT
+#define EMIT
+
+namespace Integer {
+
+constexpr int Unique_Int = int(6789);
+//CHECK:      VarDecl {{.*}} Unique_Int
+//CHECK-NEXT: ConstantExpr {{.*}} 'int' 6789
+
+constexpr __uint128_t Unique_Int128 = ((__uint128_t)0x75f17d6b3588f843 << 64) | 0xb13dea7c9c324e51;
+//CHECK:      VarDecl {{.*}} Unique_Int128 
+//CHECK-NEXT: ConstantExpr {{.*}} 'unsigned __int128' 156773562844924187900898496343692168785
+
+}
+
+namespace FloatingPoint {
+
+constexpr double Unique_Double = double(567890.67890);
+//CHECK:      VarDecl {{.*}} Unique_Double
+//CHECK-NEXT: ConstantExpr {{.*}} 'double' 5.678907e+05
+
+}
+
+// FIXME: Add test for FixedPoint, ComplexInt, ComplexFloat, AddrLabelDiff.
+
+namespace Struct {
+
+struct B {
+  int i;
+  double d;
+};
+
+constexpr B Basic_Struct = B{1, 0.7};
+//CHECK:      VarDecl {{.*}} Basic_Struct
+//CHECK-NEXT: ConstantExpr {{.*}} 'const Struct::B' {1, 7.000000e-01}
+
+struct C {
+  int i = 9;
+};
+
+struct A : B {
+  int i;
+  double d;
+  C c;
+};
+
+constexpr A Advanced_Struct = A{Basic_Struct, 1, 79.789, {}};
+//CHECK:      VarDecl {{.*}} Advanced_Struct
+//CHECK-NEXT: ConstantExpr {{.*}} 'const Struct::A' {{[{][{]}}1, 7.000000e-01}, 1, 7.978900e+01, {9}}
+
+}
+
+namespace Vector {
+
+using v4si = int __attribute__((__vector_size__(16)));
+
+constexpr v4si Vector_Int = (v4si){8, 2, 3};
+//CHECK:      VarDecl {{.*}} Vector_Int
+//CHECK-NEXT: ConstantExpr {{.*}} 'Vector::v4si':'__attribute__((__vector_size__(4 * sizeof(int)))) int' {8, 2, 3, 0}
+
+}
+
+namespace Array {
+
+constexpr int Array_Int[] = {1, 2, 3, 4, 5, 6};
+//CHECK:      VarDecl {{.*}} Array_Int
+//CHECK-NEXT: ConstantExpr {{.*}} 'const int [6]' {1, 2, 3, 4, 5, 6}
+
+struct A {
+  int i = 789;
+  double d = 67890.09876;
+};
+
+constexpr A Array2_Struct[][3] = {{{}, {-45678, 9.8}, {9}}, {{}}};
+//CHECK:      VarDecl {{.*}} Array2_Struct
+//CHECK-NEXT: ConstantExpr {{.*}} 'Array::A const [2][3]' {{[{][{]}}{789, 6.789010e+04}, {-45678, 9.800000e+00}, {9, 6.789010e+04}}, {{[{][{]}}789, 6.789010e+04}, {789, 6.789010e+04}, {789, 6.789010e+04}}}
+
+using v4si = int __attribute__((__vector_size__(16)));
+
+constexpr v4si Array_Vector[] = {{1, 2, 3, 4}, {4, 5, 6, 7}};
+//CHECK:      VarDecl {{.*}} Array_Vector
+//CHECK-NEXT: ConstantExpr {{.*}} 'const Array::v4si [2]' {{[{][{]}}1, 2, 3, 4}, {4, 5, 6, 7}}
+
+}
+
+namespace Union {
+
+struct A {
+  int i = 6789;
+  float f = 987.9876;
+};
+
+union U {
+  int i;
+  A a{567890, 9876.5678f};
+};
+
+constexpr U Unique_Union1 = U{0};
+//CHECK:      VarDecl {{.*}} Unique_Union
+//CHECK-NEXT: ConstantExpr {{.*}} 'const Union::U' {.i = 0}
+
+constexpr U Unique_Union2 = U{};
+//CHECK:      VarDecl {{.*}} Unique_Union
+//CHECK-NEXT: ConstantExpr {{.*}} 'const Union::U' {.a = {567890, 9.876567e+03}}
+
+}
+
+namespace MemberPointer{
+
+struct A {
+  struct B {
+    struct C {
+      struct D {
+        struct E {
+          struct F {
+            struct G {
+              int i;
+            };
+          };
+        };
+      };
+    };
+  };
+};
+
+constexpr auto MemberPointer1 = &A::B::C::D::E::F::G::i;
+//CHECK:      VarDecl {{.*}} MemberPointer1
+//CHECK-NEXT: ConstantExpr {{.*}} 'int MemberPointer::A::B::C::D::E::F::G::*' &G::i
+
+struct A1 {
+  struct B1 {
+    int f() const {
+      return 0;
+    }
+  };
+
+};
+
+constexpr auto MemberPointer2 = &A1::B1::f;
+//CHECK:      VarDecl {{.*}} MemberPointer2
+//CHECK-NEXT: ConstantExpr {{.*}} 'int (MemberPointer::A1::B1::*)() const' &B1::f
+
+}
+
+namespace std {
+  struct type_info;
+};
+
+namespace LValue {
+
+constexpr int LValueInt = 0;
+constexpr const int& ConstIntRef = LValueInt;
+//CHECK:      VarDecl {{.*}} ConstIntRef
+//CHECK-NEXT: ConstantExpr {{.*}} 'const int' lvalue &LValueInt
+constexpr const int* IntPtr = &LValueInt;
+//CHECK:      VarDecl {{.*}} IntPtr
+//CHECK-NEXT: ConstantExpr {{.*}} 'const int *' &LValueInt
+
+constexpr const int* NullPtr = nullptr;
+//CHECK:      VarDecl {{.*}} NullPtr
+//CHECK-NEXT: ConstantExpr {{.*}} 'const int *const' nullptr
+
+struct A {
+  int Arr[6] = {0, 1, 3, 4, 5, 9};
+  int i = 0;
+};
+
+constexpr A Arr[] = {{}, {}};
+
+constexpr const int& ArrayStructRef1 = Arr[0].i;
+//CHECK:      VarDecl {{.*}} ArrayStructRef1
+//CHECK-NEXT: ConstantExpr {{.*}} 'const int' lvalue &Arr[0].i
+
+constexpr const int& ArrayStructRef2 = Arr[1].Arr[5];
+//CHECK:      VarDecl {{.*}} ArrayStructRef2
+//CHECK-NEXT: ConstantExpr {{.*}} 'const int' lvalue &Arr[1].Arr[5]
+
+constexpr const int* ArrayStructRef3 = &ArrayStructRef2;
+//CHECK:      VarDecl {{.*}} ArrayStructRef3
+//CHECK-NEXT: ConstantExpr {{.*}} 'const int *' &Arr[1].Arr[5]
+
+struct B : A {
+};
+
+struct C {
+  B b;
+};
+
+constexpr C c;
+
+constexpr const int& StructPathRef = c.b.i;
+//CHECK:      VarDecl {{.*}} StructPathRef
+//CHECK-NEXT: ConstantExpr {{.*}} 'const int' lvalue &c.b.A::i
+
+constexpr const std::type_info &TypeID = typeid(c);
+//CHECK:      VarDecl {{.*}} TypeID
+//CHECK-NEXT: ConstantExpr {{.*}} 'const std::type_info' lvalue &typeid(LValue::C)
+
+constexpr const std::type_info &TypeID2 = typeid(Arr[1].Arr[2]);
+//CHECK:      VarDecl {{.*}} TypeID2
+//CHECK-NEXT: ConstantExpr {{.*}} 'const std::type_info' lvalue &typeid(int)
+
+}
+
+#endif
+