[clang-repl] Introduce Value to capture expression results

[junaire]

Summary

This is the second part of the below RFC:
https://discourse.llvm.org/t/rfc-handle-execution-results-in-clang-repl/68493

This patch implements a Value class that can be used to carry expression
results in clang-repl. In other words, when we see a top expression
without semi, it will be captured and stored to a Value object. You can
explicitly specify where you want to store the object, like:

Value V;
llvm::cantFail(Interp->ParseAndExecute("int x = 42;"));
llvm::cantFail(Interp->ParseAndExecute("x", &V));

V now stores some useful infomation about x, you can get its real
value (42), it's clang::QualType or anything interesting.

However, if you don't specify the optional argument, it will be captured
to a local variable, and automatically called Value::dump, which is
not implemented yet in this patch.

Signed-off-by: Jun Zhang <[e-mail]>

[junaire]

dont include <new> if we don't have it

[junaire]

fix ci

[aaron.ballman]

I've not done a complete review yet, but I got started on it and have a handful of comments.

clang/include/clang/Basic/TokenKinds.def

941

Should we name this repl_input_end to make it clear this is generally expected to only be used for REPL input?

clang/include/clang/Interpreter/Interpreter.h

59

I think I'm surprised to see this as a data member of Interpreter but mostly because my brain keeps thinking this interpreter is to interpret whole programs, so the idea of a "last value" is a bit odd from that context. The name is probably fine as-is, but I figured it may be worth mentioning just the same.

61

Overload set for some better const correctness.

67

Hopefully this function isn't intending to mutate the passed object?

90–92

const overload here as well.

94

Any chance we can make this const correct as well? (I'll stop asking in this review -- can you take a pass through it to add const correctness where it isn't obnoxiously viral to do so?)

clang/include/clang/Interpreter/Value.h

18

Unused include can be removed.

44

Duplicates line 27, can be removed.

45

Move this up to the rest of the forward declarations (and probably keep them in alphabetical order).

47

Is this expected to be a complete list of builtin types? e.g., should this have char8_t and void and wchar_t, etc? Should this be including clang/include/clang/AST/BuiltinTypes.def instead of manually maintaining the list?

78

Fixing indentation

84

Why do these take void * instead of the expected type?

122

Do we have to worry about member function pointers where a single pointer value may not be sufficient?

144

This doesn't match the usual pattern used in Clang where the get variant returns nullptr and the cast variant asserts if the cast would be invalid. Should we go with a similar approach?

161–163

Why don't forward declares suffice if we're storing the information by pointer?

clang/lib/CodeGen/CodeGenModule.cpp

7226 ↗

(On Diff #510885)

+1 -- the codegen code owners should weigh in on whether this is reasonable as a temporary measure or not.

clang/lib/Interpreter/CMakeLists.txt

14–16

Probably should be kept alphabetical.

clang/lib/Interpreter/IncrementalParser.h

35

Alphabetical order

[sgraenitz]

This looks a lot better already than the implementation I know from Cling. Well done!

OTOH it's a challenge to review since the patch is really big. Is there no way to break it up and test in isolation? Or strip away details that could be added in iterations? I had a short look and some comments, but I won't find the time in the coming weeks to give it the attention it deserves.

My biggest conceptual concern is that Value is part of the Interpreter library. This is going to be a showstopper for out-of-process execution. Conceptually, it should move into a runtime library (like the ORC runtime in compiler-rt) and this won't get easier the more it is entangled with the interpreter. I do see that this adds significant complexity and I guess it's ok to keep this for later, but I do wonder what would be the best way to prepare for it. Essentially, all communication with the interpreter will be asynchronous. Is this something we can do already?

clang/include/clang/Interpreter/Interpreter.h

75

Most of the Orc and JITLink moved away from JITTargetAddress already and uses ExecutorAddr nowadays. I think we should use ExecutorAddr from the beginning in this patch.

clang/include/clang/Interpreter/Value.h

99

Can we make this private and try not to introduce more dependencies on the interpreter instance?

The inherent problem is that we will have to wire these through Orc RPC in the future once we want to support out-of-process execution.

clang/lib/Interpreter/Interpreter.cpp

343

In Orc we are usually prefixing such functions with the namespace and class name from where they are used. While it can impact readability, it gives these names a structure and does prevent collisions, e.g.:
__clang_Interpreter_SetValueNoAlloc.

471

Is this a leftover from an old default label?

clang/lib/Interpreter/Value.cpp

92

Can we add a comment with an explanation of the magic numbers please?

[junaire]

Address some comments

[junaire]

clang/include/clang/Interpreter/Interpreter.h

67

Unfortunately Sema::LookupDestructor ask for a non-const pointer... (https://github.com/llvm/llvm-project/blob/26e164fada3721b0939e6b7c2dfe1793d95229bb/clang/lib/Sema/SemaLookup.cpp#L3625)

94

FindRuntimeInterface mutates ValuePrintingInfo vector so it can't be const afaict.

clang/include/clang/Interpreter/Value.h

18

uintptr_t comes from this header so it's not unused.

78

It's already formatted by clang-format and if I change this arc doesn't even allow me to upload the diff. I believe it's a bug in clang-format and I have filed https://github.com/llvm/llvm-project/issues/60535 So I'd like to fix this when I commit this :)

clang/lib/Interpreter/Interpreter.cpp

471

there's no default label since we handle all the cases here. But indeed it looks a bit ugly and I removed it.

clang/lib/Interpreter/Value.cpp

92

I'm uncertain if these numbers actually have specific meanings, I just copied them from Cling directly.

[junaire]

clang/include/clang/Interpreter/Interpreter.h

75

Thanks, I've created https://reviews.llvm.org/D148434

[v.g.vassilev]

clang/lib/CodeGen/CodeGenModule.cpp

7226 ↗

(On Diff #510885)

https://reviews.llvm.org/D148435

[junaire]

Address more comments

[junaire]

clang/include/clang/Interpreter/Value.h

84

Yeah for the first parameter, we could just use Interpreter* but the second one is an opaque type so I think we should keep it?

[junaire]

Rebase

[junaire]

clang/include/clang/Interpreter/Value.h

99

Ughh, I don't understand can you elaborate a bit? We can't make these accessors private since they are meaningful API? it will be used intensively in ValuePrinter.cpp (the second patch), and the end users may want to use them as well.

144

These APIs are adopted in Cling and Cling will remove the old implementation and use the upstream version of the value printing feature at some point in the future. So @v.g.vassilev hope we can keep these APIs close to Cling's variants as much as we can. I don't have a strong opinion here, what's your take here? @v.g.vassilev

[v.g.vassilev]

I added some of background and historical notes. I hope that helps.

clang/include/clang/Interpreter/Interpreter.h

59

One way to think of this is every repl has some way to access the last result it created when executed its last chunk of input. In python that's the _ value. In the debugger it is the %N where N is some number. Here this variable would enable implementing a similar to these in future.

clang/include/clang/Interpreter/Value.h

47

This is used for various things including storing the bits into a big-endian agnostic way. For void we have a special case in the Value and we cannot define a union of a void type. We can include the others that you suggest. All the relevant ones are described in clang::BuiltinType::getName.

We cannot use BuiltinTypes.def because we want to have a mapping between the type as written in the language (eg, bool, unsigned, etc) and its underlying type name. That mapping is not available in BuiltinTypes.def. Ideally we should extend BuiltinTypes.def somehow but I'd prefer outside of this patch. One of the challenges is that some of the types depend on the language options (eg. _Bool vs bool) and I am not sure this can be resolved by tablegen.

On a broader perspective, the Value class is responsible for two things: (a) get a value from the interpreter to compiled code (see test case); (b) set a value from compiled code to the interpreter. The second case is not yet covered (I can open soon another patch). The major use-case is calling at runtime functions and taking input parameters from compiled code.

FWIW, we should probably move all of these entities in a separate namespace. I'd suggest caas (compiler-as-a-service) and possibly rename the Value to InterpreterValue since Value is very generic and there are already a couple of classes with that name in llvm and clang.

84

See my previous comments on performance. We cannot include anything bulky in the header file.

99

I think what @sgraenitz means here is that the Value class combines two things. Essential information about what happened in the JIT and its higher-level type representation by the language it came from.

In theory, and I don't know how, we could split this somehow into two. The first part would become a pure JIT thing which only cares about putting bits in and out of the JIT and the second part would be the one that attach the exact meaning of what these bits are in the high-level language.

This would allow us to run C++ on small devices which cannot fit the entire clang-repl/jit/llvm infrastructure. That would happen by creating an out-of-process execution which then communicates with the host with the Value class. That would be a critical component to have, however, I'd prefer to land this and then do some research how to make this happen. This patch is critical for several projects already and I don't think we can wait too much. The lack of this patch makes clang-repl non-functional.

I believe @sgraenitz described the out-of-process execution in his talk here: https://compiler-research.org/meetings/#caas_10Mar2022 @sgraenitz please feel free to correct me if my interpretation of your words incorrect.

122

I am not sure if I understand your comment correctly. We only store objects and not function/member pointers (perhaps in some pathological way one could do that but I'd say it is not supported). Here we want to know if we stored it as a non-builtin type we need to make the pointer-like casts. My take is that for now we shouldn't worry about member function pointers.

144

I probably see the confusion. The getAs<T> operation is only relevant for pointer types. For example we stored object of type UserClass as a pointer. For instance, I don't see how getAs<float> can return a nullptr. We can probably inline the implementation of getAs for non-pointer types into castAs and leave getAs unimplemented relying only on the explicit specialization bellow for pointers.

The castAs operation means take a valid bit representation and transforms it into the requested one. I don't think it can or should be ever invalid. Here we are reshuffling bits.

These changes are very subtle and if we decide to make changes we should open a pull request against the ROOT project to make sure we are not breaking some important case. The reference implementation is here: https://github.com/root-project/root/blob/master/interpreter/cling/include/cling/Interpreter/Value.h

161–163

This is a performance-critical class. We literally measure the instruction count for it. We practically cannot include anything in this header file because the class needs to included as part of the interpreter runtime. For example:

#include <clang/Interpreter/Value.h>
Value ResultV;
gInterpreter->evaluate("float i = 12.3; i++", &V);
printf("Value is %d\n", ResultV.castAs<int>());

This is how you can do things in Cling. This not yet there but that's our next step.

For performance reasons we have the ValueKind optimization which allows us to perform most of the operations we need very fast. There are some operations such as printing the concrete type which need the actual QualType and so on but they are outside of the performance critical paths and it is okay to resort back to the real types providing the level of accuracy we need.

[lhames]

OTOH it's a challenge to review since the patch is really big. Is there no way to break it up and test in isolation? Or strip away details that could be added in iterations? I had a short look and some comments, but I won't find the time in the coming weeks to give it the attention it deserves.

My biggest conceptual concern is that Value is part of the Interpreter library. This is going to be a showstopper for out-of-process execution. Conceptually, it should move into a runtime library (like the ORC runtime in compiler-rt) and this won't get easier the more it is entangled with the interpreter. I do see that this adds significant complexity and I guess it's ok to keep this for later, but I do wonder what would be the best way to prepare for it. Essentially, all communication with the interpreter will be asynchronous. Is this something we can do already?

Similar thoughts here. In particular, is there a way to break the IsSemiMissing/ repl_input_end parts out from the Value part?

It sounds like it would be helpful for clang-repl to land this as-is, but we should have a plan to replace this with something compatible with out-of-process execution in the longer term. At a guess I think that would mean using regular global variable instances to manage the storage on the executor side, an extended MemoryAccess interface to read/write the value from the REPL side when needed (e.g. for printing), and emitting glue functions to pass the variable's value in to callers.

[junaire]

Break the IsSemiMissing/ repl_input_end parts out from the Value part

[junaire]

Rebuild, please.

[junaire]

fix windows buildbots

[aaron.ballman]

clang/include/clang/Interpreter/Interpreter.h

86

It looks like this can be private?

Also, just a note (not something you have to deal with in this review), the local naming convention seems to have decided that if the function starts with get then it's camel case and otherwise the name is pascal case.

clang/include/clang/Interpreter/Value.h

47

We can include the others that you suggest. All the relevant ones are described in clang::BuiltinType::getName.

Okay, so the plan is to handle all the builtin types (_BitInt, _Complex, various floating point formats, etc)? Will that be part of this patch or in follow-up work? (My intuition is that we should consider it up front because some of the builtin types are interesting -- like _BitInt because it's parameterized, which makes it novel compared to the other types.)

We cannot use BuiltinTypes.def because we want to have a mapping between the type as written in the language (eg, bool, unsigned, etc) and its underlying type name. That mapping is not available in BuiltinTypes.def. Ideally we should extend BuiltinTypes.def somehow but I'd prefer outside of this patch. One of the challenges is that some of the types depend on the language options (eg. _Bool vs bool) and I am not sure this can be resolved by tablegen.

Thanks for the explanation! BuiltinTypes.def works well enough for times when we want to use macros and include the file to generate switch cases and the likes, but you're right that it's not well-suited for this. One thing to consider is whether we should change BuiltinTypes.def to be BuiltinTypes.td instead and use tablegen to generate the macro/include dance form as well as other output (such as for your needs, that can then consider language options or more complex predicates).

FWIW, we should probably move all of these entities in a separate namespace. I'd suggest caas (compiler-as-a-service) and possibly rename the Value to InterpreterValue since Value is very generic and there are already a couple of classes with that name in llvm and clang.

I'm not in love with the name caas because that's not really a common acronym or abbreviation (and it looks like a typo due to aa). However, we already have an interp namespace in Clang for one of the other interpreters (constant expression evaluation), so that's not available for use. How about repl though?

As for considering changing the name from Value because of how many other Value types we have already... that's both a reason to rename and reason not to rename. I think I'm fine leaving it as Value so long as it's in a novel namespace.

78

Totally fine to fix this on commit, thank you for filing the issue!

84

I think I understand why the design is the way it is, but it still makes me uneasy. The constructor takes a pointer to some bucket of bytes... no size information, no type information, etc. Just "here's a random pointer". And then later, we hope the user calls setKind() in a way that makes sense.

We need it to be fast, but we also need it to be correct -- the type system is the best tool for helping with that.

105–109

If we can't get type safety through construction, should we consider adding assertions here that a value's kind and opaque type agree, or that we're not changing the type or kind without also changing the pointer?

122

Given:

struct Foo {
struct Base {
  virtual int bar();
};

struct Foo : Base {
  int bar() { return 12; }
};

int (Foo::*bar_ptr)() = &Foo::bar;

The object bar_ptr requires two pointers of space to represent: https://godbolt.org/z/o81sbjKM6, so I'm wondering whether Value can represent bar_ptr

144

I think castAs can be invalid -- if you have the bits for a float and you try to cast it as a pointer, that's not going to lead to good things, right?

My point is largely that the names getAs and castAs have meaning within Clang already and this seems to assign slightly different meaning to them, which might trip folks up. It might be worth considering renaming them to something like bitCast and pointerCast (or something else, I'm not tied to these names)?

161–163

That sounds like it's going to lead to maintenance problems in the long term, right? I can't think of another header file we say "don't touch this because it may impact runtime performance", and so I can easily imagine someone breaking your expectation that this file can't include anything else.

Is there a long-term plan for addressing this?

clang/lib/Interpreter/IncrementalParser.cpp

22

Does it? This file is in clang/lib/Interpreter so including other things from clang/Interpreter would not be a layering violation normally.

[junaire]

Partially address some comments

clang/include/clang/Interpreter/Interpreter.h

86

Fixed.

clang/include/clang/Interpreter/Value.h

84

Not really... The user doesn't need to call setKind() explicitly to construct a Value, the constructor will handle it automatically. See ConvertQualTypeToKind in Value.cpp. So if the pointer is just some garbage data, the constructor should fail before yielding out a valid instance.

clang/lib/Interpreter/IncrementalParser.cpp

22

That's an old comment, already fixed and marked it as done :)

[junaire]

Add unittests for void & member pointers types

[v.g.vassilev]

Thanks again for your efforts pushing this patch. It has gone a long way and I believe we are getting there.

clang/include/clang/Interpreter/Value.h

47

We can include the others that you suggest. All the relevant ones are described in clang::BuiltinType::getName.

Okay, so the plan is to handle all the builtin types (_BitInt, _Complex, various floating point formats, etc)? Will that be part of this patch or in follow-up work? (My intuition is that we should consider it up front because some of the builtin types are interesting -- like _BitInt because it's parameterized, which makes it novel compared to the other types.)

That's a good point. I think the current patch offers a new capability and it is probably fine to not address all at once. My concern is that @junaire has a month to work on these things and this patch is the first out of two patches. The risk here is to drop the ball on that altogether if we add more work as a requirement for that patch to go in.

We cannot use BuiltinTypes.def because we want to have a mapping between the type as written in the language (eg, bool, unsigned, etc) and its underlying type name. That mapping is not available in BuiltinTypes.def. Ideally we should extend BuiltinTypes.def somehow but I'd prefer outside of this patch. One of the challenges is that some of the types depend on the language options (eg. _Bool vs bool) and I am not sure this can be resolved by tablegen.

Thanks for the explanation! BuiltinTypes.def works well enough for times when we want to use macros and include the file to generate switch cases and the likes, but you're right that it's not well-suited for this. One thing to consider is whether we should change BuiltinTypes.def to be BuiltinTypes.td instead and use tablegen to generate the macro/include dance form as well as other output (such as for your needs, that can then consider language options or more complex predicates).

I am totally with you here. I am not sure how to do this since as of now some of the types and their form as written are decided with a flag (IIRC the various char flavors).

FWIW, we should probably move all of these entities in a separate namespace. I'd suggest caas (compiler-as-a-service) and possibly rename the Value to InterpreterValue since Value is very generic and there are already a couple of classes with that name in llvm and clang.

I'm not in love with the name caas because that's not really a common acronym or abbreviation (and it looks like a typo due to aa). However, we already have an interp namespace in Clang for one of the other interpreters (constant expression evaluation), so that's not available for use. How about repl though?

The only problem I have with repl is misleading. repl usually means to people something that you run at your prompt and can type some expressions in and see some results. However, here we are building a foundational primitive to allow embedding an interpreter as part of your static program and be able to cross the compiler/interpreter boundary. The compiler-as-a-service (caas) is probably the closest I could find in CS research terminology to describe that. Would adding some solid bits of documentation to the entire approach make you more comfortable with that naming?

FWIW, the namespace comment should not be a requirement for this particular patch. I think it is totally fine to keep it as it is and do the change outside of this patch to help the review. Moreover, we will probably need to move some of the existing components already.

As for considering changing the name from Value because of how many other Value types we have already... that's both a reason to rename and reason not to rename. I think I'm fine leaving it as Value so long as it's in a novel namespace.

Ok, if that's not confusing, then let's keep it the way it was. That way it should be easier to adopt that downstream for sure!

161–163

We have a few components like the Lexer that are extremely prone to performance regressions.

In terms for a longer-term plan in addressing this there are some steps could help IMO. First, this component is relatively standalone and very few changes will be required over time, for these I am hoping to be listed as a reviewer. Second, we can add a comment in the include area, making a note that including anything here will degrade the performance of almost all interpreted code. Third, we will find out about this in our downstream use-cases as the things get significantly slower.

Neither is silver bullet but that's probably the best we could do at that time. Btw, we might be able to add a test that's part of LLVM's performance analysis infrastructure.

clang/lib/Interpreter/Interpreter.cpp

207

Can you add an #ifdef __cplusplus and add a value printing tests that run in clang-repl in C mode?

[junaire]

Only enable __clang_Interpreter_SetValueCopyArr support in C++ mode.

[junaire]

.

[junaire]

clang/include/clang/Interpreter/Value.h

122

I added a test case for this.

144

We want to rename:
getAs --> as
castAs --> convertTo

Does these look good to you?

[junaire]

.

[junaire]

.

[junaire]

clang/lib/Interpreter/Interpreter.cpp

207

After a private chat, we decide to disable the feature in C mode because it sounds like a bad idea to give C incomplete value printing support.

[aaron.ballman]

clang/include/clang/Interpreter/Value.h

47

We can include the others that you suggest. All the relevant ones are described in clang::BuiltinType::getName.

Okay, so the plan is to handle all the builtin types (_BitInt, _Complex, various floating point formats, etc)? Will that be part of this patch or in follow-up work? (My intuition is that we should consider it up front because some of the builtin types are interesting -- like _BitInt because it's parameterized, which makes it novel compared to the other types.)

That's a good point. I think the current patch offers a new capability and it is probably fine to not address all at once. My concern is that @junaire has a month to work on these things and this patch is the first out of two patches. The risk here is to drop the ball on that altogether if we add more work as a requirement for that patch to go in.

Yeah, the current patch is incremental progress, so I think it's defensible to leave this to follow-up work. But I worry that follow-up work is going to be hampered by the design choices made here, and I mostly want to avoid a situation where this works inconsistently and that's "good enough" for an extended period of time. It feels a bit like working with any builtin type is part of the MVP. However, I don't insist because this is still useful forward progress for a lot of use cases.

The only problem I have with repl is misleading. repl usually means to people something that you run at your prompt and can type some expressions in and see some results. However, here we are building a foundational primitive to allow embedding an interpreter as part of your static program and be able to cross the compiler/interpreter boundary. The compiler-as-a-service (caas) is probably the closest I could find in CS research terminology to describe that. Would adding some solid bits of documentation to the entire approach make you more comfortable with that naming?

On the one hand, if we have to document what the name means, the name isn't very meaningful. On the other hand, we use ento for the static analyzer (because of "entomologist", one who studies bugs...), so I don't think users routinely get hung up by not understanding the namespace identifier. If you think caas is the best name for this, then let's go with that unless someone has a better suggestion.

FWIW, the namespace comment should not be a requirement for this particular patch. I think it is totally fine to keep it as it is and do the change outside of this patch to help the review. Moreover, we will probably need to move some of the existing components already.

Agreed.

84

Yeah, that's a fair point, except nothing actually validates that the opaque pointer you are handed is actually valid for anything because it eventually just does a reinterpret_cast, so I don't think the constructor will fail.

122

Thank you for the test case!

144

Yeah, I think those are good replacements, thank you!

161–163

Neither is silver bullet but that's probably the best we could do at that time. Btw, we might be able to add a test that's part of LLVM's performance analysis infrastructure.

Yeah, we should probably consider doing that. But to make sure I understand the performance concerns... when we change functionality in the lexer, we (potentially) slow down the lexing phase of compilation. That's straightforward and unsurprising. But in this case, it sounds like the act of including another header file in this header file will cause a runtime performance concern, even if no other changes are made. If I'm correct, I can't think of anything else in the compiler that works like that.

clang/lib/Interpreter/Interpreter.cpp

207

Is that disable happening in this patch, or is it in a different patch?

443

The ArrSize argument is being passed for Ptr in the call... is that correct? (It makes sense to me, but I don't get why the parameter is named Ptr to begin with.)

clang/lib/Interpreter/InterpreterUtils.cpp

19 ↗

(On Diff #518450)

This question applies more generally than just this function, but should we be requiring these interfaces to supply a SourceLocation rather than hard-coding no location information? That can make it easier to see what's going on when dumping the AST for debugging purposes, etc even if it's not necessary for diagnostics or other reasons. (I don't insist, just a speculative question about the interface.)

55–58 ↗

(On Diff #518450)

clang/lib/Interpreter/InterpreterUtils.h

38 ↗

(On Diff #518450)

What is Ptr pointing to?

Should this be renamed to UIntPtrTLiteralExpr with a comment that says it creates an integer literal whose type is uinptr_t?

clang/lib/Interpreter/Value.cpp

92

That's all the more reason to document the numbers -- should they stay in sync with Cling?

100

103

Then reuse BT below instead of converting it again. (It's usually a code smell to have isa<> followed by cast<> operations.)

[junaire]

Address comments from @aaron.ballman, thanks!

clang/include/clang/Interpreter/Value.h

47

Thanks for the comments from @aaron.ballman & @v.g.vassilev. So IIUC we'll handle the builtin types in later patches and add a namespace (caas) for the entire libclangInterpreter infrastructure.

161–163

I believe what @v.g.vassilev means is that the repl itself might include Value.h as a part of *runtime*, so if the header is heavy, you can notice the repl is slowed down. (That's obvious) So keep in mind we're breaking the boundary between the compiled code and interpreted code (It's kinda confusing) here it actually impacts interpreted code.

clang/lib/Interpreter/Interpreter.cpp

207

In https://reviews.llvm.org/D148997, See ParseStmt.cpp:551

443

Sorry, my bad. I renamed the argument name, it should make sense now. (Pass ArrSize as an interger literal`)

clang/lib/Interpreter/InterpreterUtils.cpp

19 ↗

(On Diff #518450)

Keep in mind these helpers are actually used for *synthesizing* AST nodes, so there are no SourceLocations available here. If you dumped the AST, you probably will see something like:

CallExpr 0x621000093270 'void'
|-ImplicitCastExpr 0x621000093250 'void (*)(void *, void *, void *, unsigned long long)' <FunctionToPointerDecay>
| `-DeclRefExpr 0x6210000931f8 'void (void *, void *, void *, unsigned long long)' lvalue Function 0x62100008fd98 '__clang_Interpreter_SetValueNoAlloc' 'void (void *, void *, void *, unsigned long long)'
|-CStyleCastExpr 0x621000093060 'void *' <IntegralToPointer>
| `-IntegerLiteral 0x621000093020 'unsigned long' 106515188942880
|-CStyleCastExpr 0x6210000930d0 'void *' <IntegralToPointer>
| `-IntegerLiteral 0x621000093090 'unsigned long' 106515188942912
|-CStyleCastExpr 0x621000093140 'void *' <IntegralToPointer>
| `-IntegerLiteral 0x621000093100 'unsigned long' 107820859101728
`-CStyleCastExpr 0x6210000931c8 'unsigned long long' <NoOp>
  `-ImplicitCastExpr 0x6210000931a8 'unsigned long long' <IntegralCast> part_of_explicit_cast
    `-ImplicitCastExpr 0x621000093188 'int' <LValueToRValue> part_of_explicit_cast
      `-DeclRefExpr 0x621000092ec0 'int' lvalue Var 0x621000092d50 'x' 'int'

Horrible, but that's all we can do :(

clang/lib/Interpreter/InterpreterUtils.h

38 ↗

(On Diff #518450)

I think it should be uint64_t. Fixed.

[junaire]

Add more comments.

clang/include/clang/Interpreter/Interpreter.h

59

I added some comments.

clang/include/clang/Interpreter/Value.h

84

OK, let me try to answer why we're passing QualType in an opaque pointer way. So the Value is *constructed* in __clang_Interpreter_SetValue* variants, and these functions (let's call them runtime interfaces) are synthesized when we want to do value printing (like we have a x without semi). So it makes things pretty hard if we use a complete type (How can we synthesize that type? That dramatically complicated the code) In addition, we want Value.h, which is part of the runtime, as lightweight as possible, so we can't use the complete type in its constructor, or we have to include the corresponding header file.

[junaire]

Fix typos

[aaron.ballman]

clang/include/clang/Interpreter/Value.h

47

That matches my understanding.

84

Okay, I think I was getting hung up on your second point:

In addition, we want Value.h, which is part of the runtime, as lightweight as possible, so we can't use the complete type in its constructor, or we have to include the corresponding header file.")

while forgetting your first point:

So the Value is *constructed* in __clang_Interpreter_SetValue* variants, and these functions (let's call them runtime interfaces) are synthesized when we want to do value printing (like we have a x without semi). So it makes things pretty hard if we use a complete type (How can we synthesize that type? That dramatically complicated the code)

The first point makes sense to me and is pretty reasonable rationale for why we pass void *, thanks! The second point still isn't particularly compelling to me (more on that below).

161–163

I believe what @v.g.vassilev means is that the repl itself might include Value.h as a part of *runtime*, so if the header is heavy, you can notice the repl is slowed down. (That's obvious) So keep in mind we're breaking the boundary between the compiled code and interpreted code (It's kinda confusing) here it actually impacts interpreted code.

I'm not certain that's a reasonable design choice to make. Or, stated somewhat differently, I'm really uncomfortable with having header files we can't maintain because changing them impacts runtime performance in surprising ways. That's not a sustainable design even if we think this header will be reasonably stable. We need *some* amount of abstraction here so that we can have a clean design for the REPL interpreter without NFC code changes impacting performance. Otherwise, people will be discouraged from adding comments to this file (those take time to lex, after all), or using long identifiers (longer identifiers take longer to lex than shorter ones), or including what is used instead of using void * (as being discussed here), and so on.

This is quite probably something you've already thought about plenty, but... could we add an abstraction layer so that the interpreter side of things has a "low-token-count" interface that dispatches through to the actual implementation?

clang/lib/Interpreter/InterpreterUtils.cpp

19 ↗

(On Diff #518450)

Ah, that's true, this is all synthesized.

19 ↗

(On Diff #518961)

So now this interface takes a uint64_t but it creates a uintptr_t literal; should this be making a uint64_t literal instead?

clang/lib/Interpreter/InterpreterUtils.h

38 ↗

(On Diff #518450)

I'm still seeing IntegerLiteral *IntegerLiteralExpr(ASTContext &C, uintptr_t Ptr); for the declaration (the definition is using uint64_t though).

[v.g.vassilev]

clang/include/clang/Interpreter/Value.h

161–163

I believe what @v.g.vassilev means is that the repl itself might include Value.h as a part of *runtime*, so if the header is heavy, you can notice the repl is slowed down. (That's obvious) So keep in mind we're breaking the boundary between the compiled code and interpreted code (It's kinda confusing) here it actually impacts interpreted code.

I'm not certain that's a reasonable design choice to make. Or, stated somewhat differently, I'm really uncomfortable with having header files we can't maintain because changing them impacts runtime performance in surprising ways. That's not a sustainable design even if we think this header will be reasonably stable. We need *some* amount of abstraction here so that we can have a clean design for the REPL interpreter without NFC code changes impacting performance. Otherwise, people will be discouraged from adding comments to this file (those take time to lex, after all), or using long identifiers (longer identifiers take longer to lex than shorter ones), or including what is used instead of using void * (as being discussed here), and so on.

All valid points. I guess we have seen some changes related to compilation speed in the past in the STLExtras.h (iirc, although I cannot find the right commit). We did particular changes to the header file to reduce the compilation time of some large TU builds. I'd think that's more like the case of stddef.h and similar headers in the resource directory. The more we add the worse becomes the compiler startup time.

This is quite probably something you've already thought about plenty, but... could we add an abstraction layer so that the interpreter side of things has a "low-token-count" interface that dispatches through to the actual implementation?

Yes, I have a plan that's quite ambitious (and a draft RFC): basically the idea is any #include to become a no-op for the compiler unless something is actually needed.

I understand your concern here but I don't really know how to address it in this particular patch.

clang/lib/Interpreter/InterpreterUtils.cpp

19 ↗

(On Diff #518450)

Outside of this review, we've been entertaining the idea of providing a source location scratch area which represents some memory region of the decompiled to text synthesized AST. That can solve a number of general issues with synthesized code but we have not got around to experiment with it.

clang/lib/Interpreter/Value.cpp

92

I believe the explanation is at the use in isAlive:

// Check whether the storage is valid by validating the canary bits.
// If someone accidentally write some invalid bits in the storage, the canary
// will be changed first, and `IsAlive` will return false then.

I'd suggest here we can say that these are random numbers that allow us to detect if someone wrote bits in our storage accidentally. Or actually refer the the documentation in isAlive.

[sgraenitz]

In D141215#4272538, @lhames wrote:

using regular global variable instances to manage the storage on the executor side, an extended MemoryAccess interface to read/write the value from the REPL side when needed (e.g. for printing), and emitting glue functions to pass the variable's value in to callers.

Agree, that's probably the better solution. Just for the record: Values couldn't be temporaries and access must be synchronized with execution to avoid races. I guess both is easily acceptable.

clang/include/clang/Interpreter/Value.h

161–163

[...] include Value.h as a part of *runtime*, so if the header is heavy, you can notice the repl is slowed down. (That's obvious) So keep in mind we're breaking the boundary between the compiled code and interpreted code (It's kinda confusing) here it actually impacts interpreted code.

I'm really uncomfortable with having header files we can't maintain because changing them impacts runtime performance in surprising ways. [...] could we add an abstraction layer so that the interpreter side of things has a "low-token-count" interface that dispatches through to the actual implementation?

Agree. What about splitting this up in 3 parts?
(1) Private API: interface as consumed by the libclangInterpreter
(2) Public API: interface as consumed by tools, other LLVM projects and out-of-tree
(3) Client API: the actual runtime-only parts with low-token-count etc.

(1) and (2) would be here in the source-tree. (3) is a resource file similar to intrinsics headers, I believe they have very similar requirements on performance, maintenance and versioning.

clang/lib/Interpreter/Interpreter.cpp

471

Perfect

[v.g.vassilev]

clang/include/clang/Interpreter/Value.h

161–163

I agree with this suggestion. We have actually tried (3) and discovered that it is challenging to write unit tests for it. The main issue is that the clang tests have been designed to avoid relying on the resource directory, which is relative to the clang binary. Moreover, some builds redefine the location of the resource directory during compilation, making it difficult to locate and pass to a unit test whose location is independent of the clang binary's location...

[junaire]

Rebase + Update

[junaire]

.

[junaire]

clang/include/clang/Interpreter/Value.h

161–163

Hi @aaron.ballman, I would like to try to explain why we don't have a better approach again.

Value is very special, it's not a regular runtime that would only be used by the REPL, instead, it acts like a messager, and connects the compiled code and the interpreted code. That said both sides need to reference it. so it can't be put into the resource directory, or the host compiler that is used for compiling clang-repl can't find it, then we fail to compile. What's more, it can't be put into compiler-rt too, same reason, Interpreter.h needs to include the header. The only possible location I can think of is the regular include/clang/Interpter.

When it comes to maintenance issues, I believe that's fine. IIUC your main concern is that people will be afraid to touch this file since it has a surprising performance impact. However, the whole header is only about the declaration of Value class and it should only be used for this purpose. So unless someone is working on clang-repl, it's unlikely for them to touch it. Another thing I would like to mention is that the performance is only noticeably dropped if we pulled some large headers, like <string>, <memory>, or something like that. NFC changes like fixing typos, adding comments, and adjusting function names are totally fine. (They can't simply refactor the void* thing, or the whole program simplify fail to compile)

We could also add some comments to indicate the specificity of this header, and why people should be cautious when touching it.

[aaron.ballman]

clang/include/clang/Interpreter/Value.h

161–163

I had a nice off-list conversation with @v.g.vassilev about my concerns and we think we've got a path forward to get you unblocked.

Put a gigantic, obvious note at the top of Value.h saying that 1) changes to this file impact *runtime* performance of the interpreter and so extreme caution should be used when making changes to the file, especially when including new headers., 2) A FIXME comment that explains why this design is a problem and what the very vague idea is for addressing the issue, and that the contents of this file are experimental and subject to change.

#1 helps code reviewers remember that this file is special right now, and #2 makes it clear that nobody should rely on the API being stable because we're hopefully going to make significant changes to it in the relatively near future.

(Note: one of the conversation topics was that there is interest in running the interpreter on embedded systems, which is another compelling reason that we'll need a less token-heavy interface for the performance sensitive parts.)

[junaire]

Add comments

[v.g.vassilev]

clang/include/clang/Interpreter/Value.h

24

I would move the note right after the only #include we got.

[junaire]

Address comment from Vassil, thx

[v.g.vassilev]

I believe we are at the stage of better is enemy of good now. This looks good to me. I'd recommend to wait for @aaron.ballman's final review.

[aaron.ballman]

LGTM aside from a teeny tiny whitespace nit.

clang/include/clang/Interpreter/Value.h

28

[junaire]

remove whitespace

[junaire]

Because I have edited the commit messages several times so I forgot to include the revision link. Sorry. I have landed it as https://reviews.llvm.org/rGa423b7f1d7ca8b263af85944f57a69aa08fc942c

clang/include/clang/Basic/TokenKinds.def

 ANNOTATION(module_include)
 ANNOTATION(module_begin)
 ANNOTATION(module_end)
 
 // Annotation for a header_name token that has been looked up and transformed
 // into the name of a header unit.
 ANNOTATION(header_unit)
 
+// Annotation for end of input in clang-repl.
+ANNOTATION(input_end)
+
 #undef PRAGMA_ANNOTATION
 #undef ANNOTATION
 #undef TESTING_KEYWORD
 #undef OBJC_AT_KEYWORD
 #undef CXX_KEYWORD_OPERATOR
 #undef PPKEYWORD
 #undef ALIAS
 #undef EXPRESSION_TRAIT

clang/include/clang/Interpreter/Interpreter.h

 //===--- Interpreter.h - Incremental Compilation and Execution---*- 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 component which performs incremental code
 // compilation and execution.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_INTERPRETER_INTERPRETER_H
 #define LLVM_CLANG_INTERPRETER_INTERPRETER_H
 
-#include "clang/Interpreter/PartialTranslationUnit.h"
-
+#include "clang/AST/Decl.h"
 #include "clang/AST/GlobalDecl.h"
+#include "clang/Interpreter/PartialTranslationUnit.h"
+#include "clang/Interpreter/Value.h"
 
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ExecutionEngine/JITSymbol.h"
 #include "llvm/Support/Error.h"
 
 #include <memory>
 #include <vector>
 
 namespace llvm {
 namespace orc {
 class LLJIT;
 class ThreadSafeContext;
 }
 } // namespace llvm
 
 namespace clang {
 
 class CompilerInstance;
 class IncrementalExecutor;
 class IncrementalParser;
 
 /// Create a pre-configured \c CompilerInstance for incremental processing.
 class IncrementalCompilerBuilder {
 public:
   static llvm::Expected<std::unique_ptr<CompilerInstance>>
   create(std::vector<const char *> &ClangArgv);
 };
 
 /// Provides top-level interfaces for incremental compilation and execution.
 class Interpreter {
   std::unique_ptr<llvm::orc::ThreadSafeContext> TSCtx;
   std::unique_ptr<IncrementalParser> IncrParser;
   std::unique_ptr<IncrementalExecutor> IncrExecutor;
 
   Interpreter(std::unique_ptr<CompilerInstance> CI, llvm::Error &Err);
 
 public:
   ~Interpreter();
   static llvm::Expected<std::unique_ptr<Interpreter>>
   create(std::unique_ptr<CompilerInstance> CI);
+  ASTContext &getASTContext() const;
   const CompilerInstance *getCompilerInstance() const;
   const llvm::orc::LLJIT *getExecutionEngine() const;
   llvm::Expected<PartialTranslationUnit &> Parse(llvm::StringRef Code);
   llvm::Error Execute(PartialTranslationUnit &T);
-  llvm::Error ParseAndExecute(llvm::StringRef Code) {
-    auto PTU = Parse(Code);
-    if (!PTU)
-      return PTU.takeError();
-    if (PTU->TheModule)
-      return Execute(*PTU);
-    return llvm::Error::success();
-  }
+  llvm::Error ParseAndExecute(llvm::StringRef Code, Value *V = nullptr);
+  llvm::Expected<void *> CompileDtorCall(const RecordDecl *RD);
 
   /// Undo N previous incremental inputs.
   llvm::Error Undo(unsigned N = 1);
 
   /// \returns the \c JITTargetAddress of a \c GlobalDecl. This interface uses
   /// the CodeGenModule's internal mangling cache to avoid recomputing the
   /// mangled name.
   llvm::Expected<llvm::JITTargetAddress> getSymbolAddress(GlobalDecl GD) const;
 
   /// \returns the \c JITTargetAddress of a given name as written in the IR.
   llvm::Expected<llvm::JITTargetAddress>
   getSymbolAddress(llvm::StringRef IRName) const;
 
   /// \returns the \c JITTargetAddress of a given name as written in the object
   /// file.
   llvm::Expected<llvm::JITTargetAddress>
   getSymbolAddressFromLinkerName(llvm::StringRef LinkerName) const;
+
+  // FIXME: Make it private.
+  Expr *RuntimeNoAllocInterface = nullptr;
+  Expr *RuntimeAllocInterface = nullptr;
+
+private:
+  llvm::Expected<Expr *> CaptureExpr(TranslationUnitDecl &TU);
+
+  bool FindRuntimeInterface();
+
+  std::pair<llvm::Expected<PartialTranslationUnit &>, FunctionDecl *>
+  SynthesizePTU(clang::Expr *E);
+
+  llvm::Error GenerateValue(TranslationUnitDecl &TU, Value *V);
+
+  llvm::DenseMap<const RecordDecl *, void *> Dtors;
 };
 } // namespace clang
 
 #endif // LLVM_CLANG_INTERPRETER_INTERPRETER_H

clang/include/clang/Interpreter/Value.h

+//===--- Interpreter.h - Incremental Compiation and Execution---*- 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 class that used to represent a value in incremental
+// C++.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_INTERPRETER_VALUE_H
+#define LLVM_CLANG_INTERPRETER_VALUE_H
+
+#include "llvm/Support/Compiler.h"
+#include <cassert>
+
+namespace llvm {
+class raw_ostream;
+
+} // namespace llvm
+
+namespace clang {
+
+class ASTContext;
+class Interpreter;
+
+#if __has_attribute(visibility) &&                                             \
+    (!(defined(_WIN32) || defined(__CYGWIN__)) ||                              \
+     (defined(__MINGW32__) && defined(__clang__)))
+#if defined(LLVM_BUILD_LLVM_DYLIB) || defined(LLVM_BUILD_SHARED_LIBS)
+#define REPL_EXTERNAL_VISIBILITY __attribute__((visibility("default")))
+#else
+#define REPL_EXTERNAL_VISIBILITY
+#endif
+#else
+#if defined(_WIN32)
+#define REPL_EXTERNAL_VISIBILITY __declspec(dllexport)
+#endif
+#endif
+
+class Interpreter;
+class QualType;
+
+#define BUILTIN_TYPES                                                          \
+  X(bool, Bool)                                                                \
+  X(char, Char)                                                                \
+  X(signed char, SChar)                                                        \
+  X(unsigned char, UChar)                                                      \
+  X(short, Short)                                                              \
+  X(unsigned short, UShort)                                                    \
+  X(int, Int)                                                                  \
+  X(unsigned int, UInt)                                                        \
+  X(long, Long)                                                                \
+  X(unsigned long, ULong)                                                      \
+  X(long long, LongLong)                                                       \
+  X(unsigned long long, ULongLong)                                             \
+  X(float, Float)                                                              \
+  X(double, Double)
+
+class REPL_EXTERNAL_VISIBILITY Value {
+  union Storage {
+#define X(type, name) type m_##name;
+    BUILTIN_TYPES
+#undef X
+    void *m_Ptr;
+  };
+
+public:
+  enum Kind {
+#define X(type, name) K_##name,
+    BUILTIN_TYPES
+#undef X
+
+        K_Void,
+    K_PtrOrObj,
+    K_Unspecified
+  };
+
+  Value() = default;
+  Value(void /*Interpreter*/ *In, void /*QualType*/ *Ty, Kind K);
+  Value(const Value &RHS);
+  Value(Value &&RHS) noexcept;
+  Value &operator=(const Value &RHS);
+  Value &operator=(Value &&RHS) noexcept;
+  ~Value();
+
+  void print(llvm::raw_ostream &Out) const;
+  void dump() const;
+
+  ASTContext &getASTContext();
+  QualType getType() const;
+  Interpreter &getInterpreter();
+
+  bool isValid() const { return ValueKind != K_Unspecified; }
+  bool isVoid() const { return ValueKind == K_Void; }
+  Kind getKind() const { return ValueKind; }
+  void setKind(Kind K) { ValueKind = K; }
+  void setOpaqueType(void *Ty) { OpaqueType = Ty; }
+
+  void setPtr(void *Ptr) { Data.m_Ptr = Ptr; }
+
+  void *getPtr() const {
+    assert(ValueKind == K_PtrOrObj);
+    return Data.m_Ptr;
+  }
+
+#define X(type, name)                                                          \
+  void set##name(type Val) {                                                   \
+    Data.m_##name = Val;                                                       \
+    ValueKind = K_##name;                                                      \
+  }                                                                            \
+  type get##name() const {                                                     \
+    assert(ValueKind == K_##name);                                             \
+    return Data.m_##name;                                                      \
+  }
+  BUILTIN_TYPES
+#undef X
+
+  template <typename T> T getAs();
+
+// Allows us to have overloads for each builtin type, plus one that goes via
+// void*
+#define X(type, name)                                                          \
+  template <> type getAs() {                                                   \
+    assert(ValueKind == K_##name);                                             \
+    return (type)Data.m_##name;                                                \
+  }
+  BUILTIN_TYPES
+#undef X
+
+private:
+  // Interpreter, QualType are stored as void* to reduce dependencies.
+  void *Interp = nullptr;
+  void *OpaqueType = nullptr;
+  Storage Data;
+  Kind ValueKind = K_Unspecified;
+  bool IsManuallyAlloc = false;
+};
+
+} // namespace clang
+#endif

clang/include/clang/Parse/Parser.h

enum class ParsedStmtContext {
     LLVM_MARK_AS_BITMASK_ENUM(InStmtExpr)
   };
 
   /// Act on an expression statement that might be the last statement in a
   /// GNU statement expression. Checks whether we are actually at the end of
   /// a statement expression and builds a suitable expression statement.
   StmtResult handleExprStmt(ExprResult E, ParsedStmtContext StmtCtx);
 
+  /// A flag that indicate if we run into something that need to pretty print.
+  /// Note this should only be used in incremental C++ (clang-repl).
+  bool PrettyPrintMode = false;
+
 public:
   Parser(Preprocessor &PP, Sema &Actions, bool SkipFunctionBodies);
   ~Parser() override;
 
   const LangOptions &getLangOpts() const { return PP.getLangOpts(); }
   const TargetInfo &getTargetInfo() const { return PP.getTargetInfo(); }
   Preprocessor &getPreprocessor() const { return PP; }
   Sema &getActions() const { return Actions; }
   AttributeFactory &getAttrFactory() { return AttrFactory; }
 
   const Token &getCurToken() const { return Tok; }
   Scope *getCurScope() const { return Actions.getCurScope(); }
   void incrementMSManglingNumber() const {
     return Actions.incrementMSManglingNumber();
   }
 
   ObjCContainerDecl *getObjCDeclContext() const {
     return Actions.getObjCDeclContext();
   }
 
+  bool isPrettyPrintMode() const {
+    assert(PP.isIncrementalProcessingEnabled() &&
+           "This should only be used in incremental C++");
+    return PrettyPrintMode;
+  }
+  void setPrettyPrintMode(bool Mode = true) {
+    assert(PP.isIncrementalProcessingEnabled() &&
+           "This should only be used in incremental C++");
+    PrettyPrintMode = Mode;
+  }
+
   // Type forwarding.  All of these are statically 'void*', but they may all be
   // different actual classes based on the actions in place.
   typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy;
   typedef OpaquePtr<TemplateName> TemplateTy;
 
   typedef SmallVector<TemplateParameterList *, 4> TemplateParameterLists;
 
   typedef Sema::FullExprArg FullExprArg;
void cutOffParsing() {
     Tok.setKind(tok::eof);
   }
 
   /// Determine if we're at the end of the file or at a transition
   /// between modules.
   bool isEofOrEom() {
     tok::TokenKind Kind = Tok.getKind();
     return Kind == tok::eof || Kind == tok::annot_module_begin ||
-           Kind == tok::annot_module_end || Kind == tok::annot_module_include;
+           Kind == tok::annot_module_end || Kind == tok::annot_module_include ||
+           Kind == tok::annot_input_end;
   }
 
   /// Checks if the \p Level is valid for use in a fold expression.
   bool isFoldOperator(prec::Level Level) const;
 
   /// Checks if the \p Kind is a valid operator for fold expressions.
   bool isFoldOperator(tok::TokenKind Kind) const;
 

clang/lib/Frontend/PrintPreprocessedOutput.cpp

 
 void PrintPPOutputPPCallbacks::HandleWhitespaceBeforeTok(const Token &Tok,
                                                          bool RequireSpace,
                                                          bool RequireSameLine) {
   // These tokens are not expanded to anything and don't need whitespace before
   // them.
   if (Tok.is(tok::eof) ||
       (Tok.isAnnotation() && !Tok.is(tok::annot_header_unit) &&
-       !Tok.is(tok::annot_module_begin) && !Tok.is(tok::annot_module_end)))
+       !Tok.is(tok::annot_module_begin) && !Tok.is(tok::annot_module_end) &&
+       !Tok.is(tok::annot_input_end)))
     return;
 
   // EmittedDirectiveOnThisLine takes priority over RequireSameLine.
   if ((!RequireSameLine || EmittedDirectiveOnThisLine) &&
       MoveToLine(Tok, /*RequireStartOfLine=*/EmittedDirectiveOnThisLine)) {
     if (MinimizeWhitespace) {
       // Avoid interpreting hash as a directive under -fpreprocessed.
       if (Tok.is(tok::hash))
Callbacks->HandleWhitespaceBeforeTok(Tok, /*RequireSpace=*/false,
                                          /*RequireSameLine=*/!IsStartOfLine);
 
     if (DropComments && Tok.is(tok::comment)) {
       // Skip comments. Normally the preprocessor does not generate
       // tok::comment nodes at all when not keeping comments, but under
       // -traditional-cpp the lexer keeps /all/ whitespace, including comments.
       PP.Lex(Tok);
       continue;
+    } else if (Tok.is(tok::annot_input_end)) {
+      PP.Lex(Tok);
+      continue;
     } else if (Tok.is(tok::eod)) {
       // Don't print end of directive tokens, since they are typically newlines
       // that mess up our line tracking. These come from unknown pre-processor
       // directives or hash-prefixed comments in standalone assembly files.
       PP.Lex(Tok);
       // FIXME: The token on the next line after #include should have
       // Tok.isAtStartOfLine() set.
       IsStartOfLine = true;

clang/lib/Interpreter/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
    core
    native
    Option
    OrcJit
    Support
    Target
    TargetParser
   )
 
 add_clang_library(clangInterpreter
   IncrementalExecutor.cpp
   IncrementalParser.cpp
   Interpreter.cpp
+  Value.cpp
 
   DEPENDS
   intrinsics_gen
   ClangDriverOptions
 
   LINK_LIBS
   clangAST
   clangAnalysis
   clangBasic

clang/lib/Interpreter/IncrementalParser.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_LIB_INTERPRETER_INCREMENTALPARSER_H
 #define LLVM_CLANG_LIB_INTERPRETER_INCREMENTALPARSER_H
 
 #include "clang/Interpreter/PartialTranslationUnit.h"
 
 #include "clang/AST/GlobalDecl.h"
-
+#include "clang/Parse/Parser.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 
 #include <list>
 #include <memory>
 namespace llvm {
 class LLVMContext;
 }
 
 namespace clang {
 class ASTConsumer;
 class CompilerInstance;
 class IncrementalAction;
 class Parser;
-
+class Interpreter;
 /// Provides support for incremental compilation. Keeps track of the state
 /// changes between the subsequent incremental input.
 ///
 class IncrementalParser {
   /// Long-lived, incremental parsing action.
   std::unique_ptr<IncrementalAction> Act;
 
   /// Compiler instance performing the incremental compilation.
public:
 
   const CompilerInstance *getCI() const { return CI.get(); }
 
   /// Parses incremental input by creating an in-memory file.
   ///\returns a \c PartialTranslationUnit which holds information about the
   /// \c TranslationUnitDecl and \c llvm::Module corresponding to the input.
   llvm::Expected<PartialTranslationUnit &> Parse(llvm::StringRef Input);
 
+  llvm::Expected<PartialTranslationUnit &> Parse(Parser::DeclGroupPtrTy D);
+
   /// Uses the CodeGenModule mangled name cache and avoids recomputing.
   ///\returns the mangled name of a \c GD.
   llvm::StringRef GetMangledName(GlobalDecl GD) const;
 
   void CleanUpPTU(PartialTranslationUnit &PTU);
 
   std::list<PartialTranslationUnit> &getPTUs() { return PTUs; }
 
-private:
-  llvm::Expected<PartialTranslationUnit &> ParseOrWrapTopLevelDecl();
+  llvm::Expected<PartialTranslationUnit &>
+  ParseOrWrapTopLevelDecl(Parser::DeclGroupPtrTy SynthesizedDecl = nullptr);
+
+  bool isPrettyPrintMode() const { return P->isPrettyPrintMode(); }
+  void setPrettyPrintMode(bool Mode = true) { P->setPrettyPrintMode(Mode); }
 };
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_INTERPRETER_INCREMENTALPARSER_H

clang/lib/Interpreter/IncrementalParser.cpp

 
 #include "clang/AST/DeclContextInternals.h"
 #include "clang/CodeGen/BackendUtil.h"
 #include "clang/CodeGen/CodeGenAction.h"
 #include "clang/CodeGen/ModuleBuilder.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendAction.h"
 #include "clang/FrontendTool/Utils.h"
+#include "clang/Interpreter/Interpreter.h"
 #include "clang/Parse/Parser.h"
 #include "clang/Sema/Sema.h"
-
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Timer.h"
 
 #include <sstream>
 
 namespace clang {

 }
 
 IncrementalParser::~IncrementalParser() {
   P.reset();
   Act->FinalizeAction();
 }
 
 llvm::Expected<PartialTranslationUnit &>
-IncrementalParser::ParseOrWrapTopLevelDecl() {
+IncrementalParser::ParseOrWrapTopLevelDecl(
+    Parser::DeclGroupPtrTy SynthesizedDecl) {
   // Recover resources if we crash before exiting this method.
   Sema &S = CI->getSema();
   llvm::CrashRecoveryContextCleanupRegistrar<Sema> CleanupSema(&S);
   Sema::GlobalEagerInstantiationScope GlobalInstantiations(S, /*Enabled=*/true);
   Sema::LocalEagerInstantiationScope LocalInstantiations(S);
 
   PTUs.emplace_back(PartialTranslationUnit());
   PartialTranslationUnit &LastPTU = PTUs.back();
   // Add a new PTU.
   ASTContext &C = S.getASTContext();
   C.addTranslationUnitDecl();
   LastPTU.TUPart = C.getTranslationUnitDecl();
 
   // Skip previous eof due to last incremental input.
-  if (P->getCurToken().is(tok::eof)) {
-    P->ConsumeToken();
+  if (P->getCurToken().is(tok::annot_input_end)) {
+    P->ConsumeAnyToken();
     // FIXME: Clang does not call ExitScope on finalizing the regular TU, we
     // might want to do that around HandleEndOfTranslationUnit.
     P->ExitScope();
     S.CurContext = nullptr;
     // Start a new PTU.
     P->EnterScope(Scope::DeclScope);
     S.ActOnTranslationUnitScope(P->getCurScope());
   }
 
+  if (SynthesizedDecl) {
+    if (!Consumer->HandleTopLevelDecl(SynthesizedDecl.get())) {
+      return llvm::make_error<llvm::StringError>(
+          "Parsing failed. "
+          "The consumer rejected the synthesized decl",
+          std::error_code());
+    }
+  } else {
     Parser::DeclGroupPtrTy ADecl;
     Sema::ModuleImportState ImportState;
     for (bool AtEOF = P->ParseFirstTopLevelDecl(ADecl, ImportState); !AtEOF;
          AtEOF = P->ParseTopLevelDecl(ADecl, ImportState)) {
       if (ADecl && !Consumer->HandleTopLevelDecl(ADecl.get()))
-      return llvm::make_error<llvm::StringError>("Parsing failed. "
-                                                 "The consumer rejected a decl",
-                                                 std::error_code());
+        return llvm::make_error<llvm::StringError>(
+            "Parsing failed. "
     }
+  }
 
   DiagnosticsEngine &Diags = getCI()->getDiagnostics();
   if (Diags.hasErrorOccurred()) {
     PartialTranslationUnit MostRecentPTU = {C.getTranslationUnitDecl(),
                                             nullptr};
     CleanUpPTU(MostRecentPTU);
 
     Diags.Reset(/*soft=*/true);
IncrementalParser::Parse(llvm::StringRef input) {
   if (PP.getLangOpts().DelayedTemplateParsing) {
     // Microsoft-specific:
     // Late parsed templates can leave unswallowed "macro"-like tokens.
     // They will seriously confuse the Parser when entering the next
     // source file. So lex until we are EOF.
     Token Tok;
     do {
       PP.Lex(Tok);
-    } while (Tok.isNot(tok::eof));
+    } while (Tok.isNot(tok::annot_input_end));
   }
 
   Token AssertTok;
   PP.Lex(AssertTok);
-  assert(AssertTok.is(tok::eof) &&
+  assert(AssertTok.is(tok::annot_input_end) &&
          "Lexer must be EOF when starting incremental parse!");
 
   if (CodeGenerator *CG = getCodeGen(Act.get())) {
     std::unique_ptr<llvm::Module> M(CG->ReleaseModule());
     CG->StartModule("incr_module_" + std::to_string(PTUs.size()),
                     M->getContext());
 
     PTU->TheModule = std::move(M);
   }
 
   return PTU;
 }
 
+llvm::Expected<PartialTranslationUnit &>
+IncrementalParser::Parse(Parser::DeclGroupPtrTy D) {
+  llvm::Expected<PartialTranslationUnit &> PTUOrErr =
+      ParseOrWrapTopLevelDecl(D);
+  if (!PTUOrErr) {
+    return PTUOrErr.takeError();
+  }
+  if (CodeGenerator *CG = getCodeGen(Act.get())) {
+    std::unique_ptr<llvm::Module> M(CG->ReleaseModule());
+    CG->StartModule("incr_module_" + std::to_string(PTUs.size()),
+                    M->getContext());
+
+    PTUOrErr.get().TheModule = std::move(M);
+  }
+
+  return PTUOrErr;
+}
+
 void IncrementalParser::CleanUpPTU(PartialTranslationUnit &PTU) {
   TranslationUnitDecl *MostRecentTU = PTU.TUPart;
   TranslationUnitDecl *FirstTU = MostRecentTU->getFirstDecl();
   if (StoredDeclsMap *Map = FirstTU->getPrimaryContext()->getLookupPtr()) {
     for (auto I = Map->begin(); I != Map->end(); ++I) {
       StoredDeclsList &List = I->second;
       DeclContextLookupResult R = List.getLookupResult();
       for (NamedDecl *D : R) {

clang/lib/Interpreter/Interpreter.cpp

 //===----------------------------------------------------------------------===//
 
 #include "clang/Interpreter/Interpreter.h"
 
 #include "IncrementalExecutor.h"
 #include "IncrementalParser.h"
 
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/Mangle.h"
+#include "clang/AST/TypeVisitor.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/CodeGen/ModuleBuilder.h"
 #include "clang/CodeGen/ObjectFilePCHContainerOperations.h"
 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/Job.h"
 #include "clang/Driver/Options.h"
 #include "clang/Driver/Tool.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/TextDiagnosticBuffer.h"
 #include "clang/Lex/PreprocessorOptions.h"
 
+#include "clang/Sema/Lookup.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/TargetParser/Host.h"
 
 using namespace clang;
 
 // FIXME: Figure out how to unify with namespace init_convenience from
 //        tools/clang-import-test/clang-import-test.cpp
if (IncrExecutor) {
     if (llvm::Error Err = IncrExecutor->cleanUp())
       llvm::report_fatal_error(
           llvm::Twine("Failed to clean up IncrementalExecutor: ") +
           toString(std::move(Err)));
   }
 }
 
 llvm::Expected<std::unique_ptr<Interpreter>>
 Interpreter::create(std::unique_ptr<CompilerInstance> CI) {
   llvm::Error Err = llvm::Error::success();
   auto Interp =
       std::unique_ptr<Interpreter>(new Interpreter(std::move(CI), Err));
   if (Err)
     return std::move(Err);
   return std::move(Interp);
 }
 
 const CompilerInstance *Interpreter::getCompilerInstance() const {
   return IncrParser->getCI();
 }
 
+ASTContext &Interpreter::getASTContext() const {
+  return getCompilerInstance()->getASTContext();
+}
+
 const llvm::orc::LLJIT *Interpreter::getExecutionEngine() const {
   if (IncrExecutor)
     return IncrExecutor->getExecutionEngine();
   return nullptr;
 }
 
 llvm::Expected<PartialTranslationUnit &>
 Interpreter::Parse(llvm::StringRef Code) {
if (auto Err = IncrExecutor->addModule(T))
     return Err;
 
   if (auto Err = IncrExecutor->runCtors())
     return Err;
 
   return llvm::Error::success();
 }
 
+llvm::Error Interpreter::ParseAndExecute(llvm::StringRef Code, Value *V) {
+  auto PTU = Parse(Code);
+  if (!PTU)
+    return PTU.takeError();
+  if (IncrParser->isPrettyPrintMode()) {
+    IncrParser->setPrettyPrintMode(false);
+
+    // The user ask for a value, return it directly.
+    if (V)
+      if (llvm::Error Err = GenerateValue(*PTU->TUPart, V))
+        return Err;
+
+    // Presumbly we need to perform pretty print.
+    Value DefaultValue;
+    if (llvm::Error Err = GenerateValue(*PTU->TUPart, &DefaultValue))
+      return Err;
+    DefaultValue.dump();
+    return llvm::Error::success();
+  }
+
+  if (PTU->TheModule)
+    return Execute(*PTU);
+  return llvm::Error::success();
+}
+
 llvm::Expected<llvm::JITTargetAddress>
 Interpreter::getSymbolAddress(GlobalDecl GD) const {
   if (!IncrExecutor)
     return llvm::make_error<llvm::StringError>("Operation failed. "
                                                "No execution engine",
                                                std::error_code());
   llvm::StringRef MangledName = IncrParser->GetMangledName(GD);
   return getSymbolAddress(MangledName);
return llvm::make_error<llvm::StringError>("Operation failed. "
                                                std::error_code());
 
   return IncrExecutor->getSymbolAddress(Name, IncrementalExecutor::LinkerName);
 }
 
 llvm::Error Interpreter::Undo(unsigned N) {
 
   std::list<PartialTranslationUnit> &PTUs = IncrParser->getPTUs();
   if (N > PTUs.size())
     return llvm::make_error<llvm::StringError>("Operation failed. "
                                                "Too many undos",
                                                std::error_code());
   for (unsigned I = 0; I < N; I++) {
     if (IncrExecutor) {
       if (llvm::Error Err = IncrExecutor->removeModule(PTUs.back()))
         return Err;
     }
 
     IncrParser->CleanUpPTU(PTUs.back());
     PTUs.pop_back();
   }
   return llvm::Error::success();
 }
+
+static IntegerLiteral *IntegerLiteralExpr(ASTContext &C, uintptr_t Ptr) {
+  const llvm::APInt Addr(8 * sizeof(void *), Ptr);
+  return IntegerLiteral::Create(C, Addr, C.getUIntPtrType(), SourceLocation());
+}
+
+static Expr *CStyleCastPtrExpr(Sema &S, QualType Ty, Expr *E) {
+  ASTContext &Ctx = S.getASTContext();
+  if (!Ty->isPointerType())
+    Ty = Ctx.getPointerType(Ty);
+
+  TypeSourceInfo *TSI = Ctx.getTrivialTypeSourceInfo(Ty, SourceLocation());
+  Expr *Result =
+      S.BuildCStyleCastExpr(SourceLocation(), TSI, SourceLocation(), E).get();
+  assert(Result && "Cannot create CStyleCastPtrExpr");
+  return Result;
+}
+
+static Expr *CStyleCastPtrExpr(Sema &S, QualType Ty, uintptr_t Ptr) {
+  ASTContext &Ctx = S.getASTContext();
+  return CStyleCastPtrExpr(S, Ty, IntegerLiteralExpr(Ctx, Ptr));
+}
+
+static Sema::DeclGroupPtrTy CreateDGPtrFrom(Sema &S, Decl *D) {
+  SmallVector<Decl *, 1> DeclsInGroup;
+  DeclsInGroup.push_back(D);
+  Sema::DeclGroupPtrTy DeclGroupPtr = S.BuildDeclaratorGroup(DeclsInGroup);
+  return DeclGroupPtr;
+}
+
+static std::string GetUniqueName(std::string Base) {
+  static int I = 0;
+  Base += std::to_string(I);
+  I += 1;
+  return Base;
+}
+
+llvm::Error Interpreter::GenerateValue(TranslationUnitDecl &TU, Value *V) {
+  // Capture the expression we want to print.
+  auto ExprOrErr = CaptureExpr(TU);
+  if (!ExprOrErr)
+    return ExprOrErr.takeError();
+  // Generate a PartialTranslationUnit.
+  std::pair<llvm::Expected<clang::PartialTranslationUnit &>, FunctionDecl *>
+      SynthesizedPTUOrErr = SynthesizePTU(*ExprOrErr);
+  if (!SynthesizedPTUOrErr.first)
+    return SynthesizedPTUOrErr.first.takeError();
+
+  if (SynthesizedPTUOrErr.first->TheModule)
+    if (llvm::Error Err = Execute(*SynthesizedPTUOrErr.first))
+      return Err;
+
+  ASTNameGenerator ASTNameGen(getCompilerInstance()->getASTContext());
+  llvm::Expected<llvm::JITTargetAddress> AddrOrErr =
+      getSymbolAddressFromLinkerName(
+          ASTNameGen.getName(SynthesizedPTUOrErr.second));
+  if (!AddrOrErr)
+    return AddrOrErr.takeError();
+
+  if (auto *Main = llvm::jitTargetAddressToPointer<void (*)(void *, void *)>(
+          AddrOrErr.get()))
+    (*Main)((void *)this, (void *)V);
+  return llvm::Error::success();
+}
+
+static std::string GetTypeName(ASTContext &Ctx, QualType QT) {
+  PrintingPolicy Policy(Ctx.getPrintingPolicy());
+  Policy.SuppressScope = false;
+  Policy.AnonymousTagLocations = false;
+  return QT.getAsString(Policy);
+}
+
+// Capture the last expression in the interpreter. We assume the user only
+// inputted a top level statement.
+llvm::Expected<Expr *> Interpreter::CaptureExpr(TranslationUnitDecl &TU) {
+  assert(std::distance(TU.decls_begin(), TU.decls_end()) > 0 &&
+         "Cannot capture Expr* in empty TranslationUnitDecl");
+
+  auto Size = std::distance(TU.decls_begin(), TU.decls_end());
+  auto Last = TU.decls_begin();
+  while (Size-- != 1)
+    Last++;
+
+  if (const auto *S = llvm::dyn_cast<clang::TopLevelStmtDecl>(*Last))
+    if (const auto *E = llvm::dyn_cast<clang::Expr>(S->getStmt()))
+      return const_cast<Expr *>(E);
+
+  return llvm::make_error<llvm::StringError>("Can not capture any Expr*!",
+                                             std::error_code());
+}
+llvm::Expected<void *> Interpreter::CompileDtorCall(const RecordDecl *RD) {
+  if (auto Dtor = Dtors.find(RD); Dtor != Dtors.end())
+    return Dtor->getSecond();
+
+  // No need to generate the destructor if it has no semantic effects.
+  if (const CXXRecordDecl *CXXRD = llvm::dyn_cast<CXXRecordDecl>(RD);
+      CXXRD->hasIrrelevantDestructor())
+    return nullptr;
+
+  // Generate AST.
+  //
+  // extern "C" void __InterpreterDtorT(void* obj) {
+  //   ((T*)obj)->~T();
+  // }
+  //
+  QualType QT(RD->getTypeForDecl(), 0);
+
+  std::string TypeName =
+      GetTypeName(getCompilerInstance()->getASTContext(), QT);
+
+  const char *CodeTemplate = R"(
+    extern "C" void __InterpreterDtor{0}(void* obj) {
+      (({0}*)obj)->~{0}();
+    }
+  )";
+  std::string Code = llvm::formatv(CodeTemplate, TypeName);
+  std::string DtorName = llvm::formatv("__InterpreterDtor{0}", TypeName);
+  llvm::Expected<PartialTranslationUnit &> PTUOrErr = Parse(Code);
+  // FIXME: Can't we just synthesize the AST directly?
+#if 0
+  Sema &S = getCompilerInstance()->getSema();
+  ASTContext &Ctx = S.getASTContext();
+
+  QualType QT(RD->getTypeForDecl(), 0);
+  std::string DtorName = "__InterpreterDtor" + QT.getAsString();
+
+  QualType RetTy = Ctx.VoidTy;
+  QualType ArgTy = Ctx.VoidPtrTy;
+
+  QualType FunctionTy = Ctx.getFunctionType(RetTy, {ArgTy}, {});
+  IdentifierInfo *II = &Ctx.Idents.get(DtorName);
+  // Extern "C" ?
+  auto *FD = FunctionDecl::Create(
+      S.getASTContext(), Ctx.getTranslationUnitDecl(), SourceLocation(),
+      SourceLocation(), II, FunctionTy, /*TInfo=*/nullptr, SC_Extern);
+  auto *ObjParm = ParmVarDecl::Create(
+      Ctx, FD, SourceLocation(), SourceLocation(), /*Id=*/nullptr, ArgTy,
+      Ctx.getTrivialTypeSourceInfo(ArgTy, SourceLocation()), SC_None,
+      /*DefArg=*/nullptr);
+  FD->setParams({ObjParm});
+
+  // The function Body.
+  auto *Obj = DeclRefExpr::Create(Ctx, NestedNameSpecifierLoc(),
+                                  SourceLocation(), ObjParm,
+                                  /*RefersToEnclosingVariableOrCapture=*/false,
+                                  SourceLocation(), ArgTy, VK_PRValue);
+  // Force cast it to the right type.
+  Expr *CastedExpr = CStyleCastPtrExpr(S, QT, Obj);
+
+  ExprResult DtorCall = nullptr;
+
+  assert(!DtorCall.isInvalid() && "Can't create the destructor call!");
+
+  FD->setBody(DtorCall.get());
+  // Compile it.
+  llvm::Expected<PartialTranslationUnit &> PTUOrErr =
+      IncrParser->Parse(CreateDGPtrFrom(S, FD));
+#endif
+  if (!PTUOrErr)
+    return PTUOrErr.takeError();
+  if (PTUOrErr->TheModule)
+    if (llvm::Error Err = Execute(*PTUOrErr))
+      return Err;
+
+  // Look up the function address in the JIT.
+  if (llvm::Expected<llvm::JITTargetAddress> AddrOrErr =
+          getSymbolAddressFromLinkerName(DtorName)) {
+    void *Dtor = (void *)*AddrOrErr;
+    Dtors[RD] = Dtor;
+    return Dtor;
+  }
+  return nullptr;
+}
+
+static constexpr llvm::StringRef MagicRuntimeInterface[] = {
+    "__InterpreterSetValueNoAlloc", "__InterpreterSetValueWithAlloc"};
+
+bool Interpreter::FindRuntimeInterface() {
+  if (RuntimeAllocInterface && RuntimeNoAllocInterface)
+    return true;
+
+  Sema &S = getCompilerInstance()->getSema();
+  ASTContext &Ctx = S.getASTContext();
+
+  auto LookupInterface = [&](Expr *&Interface, llvm::StringRef Name) {
+    LookupResult R(S, &Ctx.Idents.get(Name), SourceLocation(),
+                   Sema::LookupOrdinaryName, Sema::ForVisibleRedeclaration);
+    S.LookupQualifiedName(R, Ctx.getTranslationUnitDecl());
+    if (R.empty())
+      return false;
+
+    CXXScopeSpec CSS;
+    Interface = S.BuildDeclarationNameExpr(CSS, R, /*ADL=*/false).get();
+    return true;
+  };
+
+  if (!LookupInterface(RuntimeNoAllocInterface, MagicRuntimeInterface[0]))
+    return false;
+  if (!LookupInterface(RuntimeAllocInterface, MagicRuntimeInterface[1]))
+    return false;
+  return true;
+}
+
+namespace {
+
+class RuntimeInterfaceBuilder
+    : public TypeVisitor<RuntimeInterfaceBuilder, bool> {
+  clang::Interpreter &Interp;
+  ASTContext &Ctx;
+  Sema &S;
+  Expr *E;
+  llvm::SmallVector<Expr *, 3> Args;
+
+public:
+  RuntimeInterfaceBuilder(clang::Interpreter &In, ASTContext &C, Sema &SemaRef,
+                          Expr *VE, ArrayRef<Expr *> FixedArgs)
+      : Interp(In), Ctx(C), S(SemaRef), E(VE) {
+    // The Interpreter* parameter and the out parameter `OutVal`.
+    for (Expr *E : FixedArgs)
+      Args.push_back(E);
+
+    // Get rid of ExprWithCleanups.
+    if (auto *EWC = llvm::dyn_cast_if_present<ExprWithCleanups>(E))
+      E = EWC->getSubExpr();
+  }
+
+  ExprResult getCall() {
+    QualType Ty = E->getType();
+    Expr *TypeArg =
+        CStyleCastPtrExpr(S, Ctx.VoidPtrTy, (uintptr_t)Ty.getAsOpaquePtr());
+    // The QualType parameter `OpaqueType`, represented as `void*`.
+    Args.push_back(TypeArg);
+
+    QualType DesugaredTy = Ty.getDesugaredType(Ctx);
+    // For lvalue struct, we treat it as a reference.
+    if (DesugaredTy->isRecordType() && E->isLValue()) {
+      DesugaredTy = Ctx.getLValueReferenceType(DesugaredTy);
+      Ty = Ctx.getLValueReferenceType(Ty);
+    }
+
+    // We push the last parameter based on the type of the Expr. Note we need
+    // special care for rvalue struct.
+    if (Visit(&*DesugaredTy)) {
+      ExprResult AllocCall =
+          S.ActOnCallExpr(/*Scope=*/nullptr, Interp.RuntimeAllocInterface,
+                          E->getBeginLoc(), Args, E->getEndLoc());
+      assert(!AllocCall.isInvalid() && "Can't create runtime interface call!");
+
+      TypeSourceInfo *TSI = Ctx.getTrivialTypeSourceInfo(Ty, SourceLocation());
+
+      Expr *Args2[] = {AllocCall.get()};
+
+      ExprResult CXXNewCall = S.BuildCXXNew(
+          E->getSourceRange(),
+          /*UseGlobal=*/true, /*PlacementLParen=*/SourceLocation(), Args2,
+          /*PlacementRParen=*/SourceLocation(), /*TypeIdParens=*/SourceRange(),
+          TSI->getType(), TSI, std::nullopt, E->getSourceRange(), E);
+
+      assert(!CXXNewCall.isInvalid() &&
+             "Can't create runtime placement new call!");
+
+      return S.ActOnFinishFullExpr(CXXNewCall.get(), /*DiscardedValue=*/false);
+    }
+
+    return S.ActOnCallExpr(/*Scope=*/nullptr, Interp.RuntimeNoAllocInterface,
+                           E->getBeginLoc(), Args, E->getEndLoc());
+  }
+
+  bool VisitRecordType(const RecordType *Ty) { return true; }
+
+  bool VisitMemberPointerType(const MemberPointerType *Ty) {
+    llvm_unreachable("Not implemented yet");
+  }
+  bool VisitConstantArrayType(const ConstantArrayType *Ty) {
+    llvm_unreachable("Not implemented yet");
+  }
+
+  bool VisitPointerType(const PointerType *Ty) {
+    TypeSourceInfo *TSI =
+        Ctx.getTrivialTypeSourceInfo(Ctx.VoidPtrTy, SourceLocation());
+    ExprResult CastedExpr =
+        S.BuildCStyleCastExpr(SourceLocation(), TSI, SourceLocation(), E);
+    assert(!CastedExpr.isInvalid() && "Can not create cstyle cast expression");
+    Args.push_back(CastedExpr.get());
+    return false;
+  }
+
+  bool VisitReferenceType(const ReferenceType *Ty) {
+    ExprResult AddrOfE = S.CreateBuiltinUnaryOp(SourceLocation(), UO_AddrOf, E);
+    assert(!AddrOfE.isInvalid() && "Can not create unary expression");
+    Args.push_back(AddrOfE.get());
+    return false;
+  }
+
+  bool VisitBuiltinType(const BuiltinType *Ty) {
+    if (Ty->isNullPtrType())
+      Args.push_back(E);
+    else if (Ty->isFloatingType())
+      Args.push_back(E);
+    else if (Ty->isVoidType()) {
+      llvm_unreachable("Not implemented yet");
+    } else if (Ty->isIntegralOrEnumerationType()) {
+      // If we want to reduce the number of the overloads, we should cast it to
+      // uint64.
+      Args.push_back(E);
+    }
+    return false;
+  }
+};
+} // namespace
+
+static constexpr const char *const ValueGetter = "__InterpreterValueGetter";
+
+// This synthesizes a wrapper function that used in passing the Value object to
+// the interpreter. Inside the wrapper we synthesize another call to a speciall
+// function that is responsible for generating the Value.
+// In general, we transform:
+//   clang-repl> x
+// To:
+// void __InterpreterValueGetter(void* ThisInterp, void* OpaqueValue) {
+//   // 1. If x is a built-in type like int, float.
+//   __InterpreterSetValueNoAlloc(ThisInterp, OpaqueValue, xQualType, x);
+//   // 2. If x is a struct, and a lvalue.
+//   __InterpreterSetValueNoAlloc(ThisInterp, OpaqueValue, xQualType, &x);
+//   // 3. If x is a struct, but a rvalue.
+//   new (__InterpreterSetValueWithAlloc(ThisInterp, OpaqueValue, xQualType))
+//   (x);
+// }
+std::pair<llvm::Expected<PartialTranslationUnit &>, FunctionDecl *>
+Interpreter::SynthesizePTU(clang::Expr *E) {
+  Sema &S = getCompilerInstance()->getSema();
+  ASTContext &Ctx = S.getASTContext();
+
+  QualType Void = Ctx.VoidTy;
+  QualType VoidPtr = Ctx.VoidPtrTy;
+
+  // Synthesize function `__InterpreterValueGetter`.
+  QualType FunctionTy = Ctx.getFunctionType(Void, {VoidPtr, VoidPtr}, {});
+  IdentifierInfo *II = &Ctx.Idents.get(GetUniqueName(ValueGetter));
+  auto *FD = FunctionDecl::Create(
+      S.getASTContext(), Ctx.getTranslationUnitDecl(), SourceLocation(),
+      SourceLocation(), II, FunctionTy, /*TInfo=*/nullptr, SC_None);
+
+  // The two parameters:
+  //   1. void* OpaqueInterp
+  //   2. void* OpaqueValue
+  auto *OpaqueInterp = ParmVarDecl::Create(
+      Ctx, FD, SourceLocation(), SourceLocation(), /*Id=*/nullptr, VoidPtr,
+      Ctx.getTrivialTypeSourceInfo(VoidPtr, SourceLocation()), SC_None,
+      /*DefArg=*/nullptr);
+  auto *OpaqueValue = ParmVarDecl::Create(
+      Ctx, FD, SourceLocation(), SourceLocation(), /*Id=*/nullptr, VoidPtr,
+      Ctx.getTrivialTypeSourceInfo(VoidPtr, SourceLocation()), SC_None,
+      /*DefArg=*/nullptr);
+  FD->setParams({OpaqueInterp, OpaqueValue});
+
+  if (!FindRuntimeInterface())
+    llvm_unreachable("We can't find the runtime iterface for pretty print!");
+
+  // Create parameter `ThisInterp` for `__InterpreterSetValue*`
+  auto *ThisInterp = DeclRefExpr::Create(
+      Ctx, NestedNameSpecifierLoc(), SourceLocation(), OpaqueInterp,
+      /*RefersToEnclosingVariableOrCapture=*/false, SourceLocation(),
+      Ctx.VoidPtrTy, VK_PRValue);
+
+  // Create parameter `OutVal` for `__InterpreterSetValue*`
+  auto *OutValue = DeclRefExpr::Create(
+      Ctx, NestedNameSpecifierLoc(), SourceLocation(), OpaqueValue,
+      /*RefersToEnclosingVariableOrCapture=*/false, SourceLocation(),
+      Ctx.VoidPtrTy, VK_PRValue);
+
+  // Build `__InterpreterSetValue*` call.
+  RuntimeInterfaceBuilder Builder(*this, Ctx, S, E, {ThisInterp, OutValue});
+
+  ExprResult Result = Builder.getCall();
+  assert(!Result.isInvalid() && "Failed to generate the CallExpr!");
+  FD->setBody(Result.get());
+
+  // Feed the generated AST to the parser.
+  return {IncrParser->Parse(CreateDGPtrFrom(S, FD)), FD};
+}
+
+// Temporary rvalue struct that need special care.
+void *REPL_EXTERNAL_VISIBILITY
+__InterpreterSetValueWithAlloc(void *This, void *OutVal, void *OpaqueType) {
+  Value &V = *reinterpret_cast<Value *>(OutVal);
+  V = Value(This, OpaqueType, Value::K_PtrOrObj);
+  return V.getPtr();
+}
+
+// Pointers, lvalue struct that can take as a reference.
+void REPL_EXTERNAL_VISIBILITY __InterpreterSetValueNoAlloc(void *This,
+                                                           void *OutVal,
+                                                           void *OpaqueType,
+                                                           void *Val) {
+  Value &V = *reinterpret_cast<Value *>(OutVal);
+  V = Value(This, OpaqueType, Value::K_PtrOrObj);
+  V.setPtr(Val);
+}
+
+// All builtin types that are cheap to copy.
+#define X(type, name)                                                          \
+  void REPL_EXTERNAL_VISIBILITY __InterpreterSetValueNoAlloc(                  \
+      void *This, void *OutVal, void *OpaqueType, type Val) {                  \
+    Value &V = *reinterpret_cast<Value *>(OutVal);                             \
+    V = Value(This, OpaqueType, Value::K_##name);                              \
+    V.set##name(Val);                                                          \
+  }
+BUILTIN_TYPES
+#undef X

clang/lib/Interpreter/Value.cpp

+#include "clang/Interpreter/Value.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/Type.h"
+#include "clang/Interpreter/Interpreter.h"
+#include "llvm/Support/raw_os_ostream.h"
+#include <cassert>
+#include <utility>
+
+using namespace clang;
+
+namespace {
+
+// This is internal buffer maintained by Value, used to hold temporaries.
+class ValueStorage {
+public:
+  using DtorFunc = void (*)(void *);
+
+  static unsigned char *CreatePayload(void *DtorF, size_t AllocSize,
+                                      size_t ElementsSize) {
+    unsigned char *Buf = new unsigned char[1024];
+    ValueStorage *VS = new (Buf) ValueStorage(DtorF, AllocSize, ElementsSize);
+    return VS->getPayload();
+  }
+
+  unsigned char *getPayload() { return Storage; }
+  const unsigned char *getPayload() const { return Storage; }
+
+  static unsigned getPayloadOffset() {
+    static ValueStorage Dummy(nullptr, 0, 0);
+    return Dummy.getPayload() - reinterpret_cast<unsigned char *>(&Dummy);
+  }
+
+  static ValueStorage *getFromPayload(void *Payload) {
+    return reinterpret_cast<ValueStorage *>((unsigned char *)Payload -
+                                            getPayloadOffset());
+  }
+
+  void Retain() { ++RefCnt; }
+
+  void Release() {
+    assert(RefCnt == 0 && "Can't release if reference count is already zero");
+    if (--RefCnt == 0) {
+      // We hace a non-trivial dtor.
+      if (Dtor) {
+        size_t Stride = AllocSize / Elements;
+        for (size_t Idx = 0; Idx < Elements; ++Idx)
+          (*Dtor)(getPayload() + Idx * Stride);
+      }
+      delete[] reinterpret_cast<unsigned char *>(this);
+    }
+  }
+
+private:
+  ValueStorage(void *DtorF, size_t AllocSize, size_t ElementsNum)
+      : RefCnt(1), AllocSize(AllocSize), Elements(ElementsNum),
+        Dtor(reinterpret_cast<DtorFunc>(DtorF)) {}
+
+  mutable unsigned RefCnt;
+  size_t AllocSize = 0;
+  size_t Elements = 0;
+  unsigned char Storage[1];
+  DtorFunc Dtor = nullptr;
+};
+} // namespace
+
+Value::Value(void *In, void *Ty, Kind K)
+    : Interp(In), OpaqueType(Ty), ValueKind(K) {
+  if (ValueKind == K_PtrOrObj) {
+    QualType Canon = getType().getCanonicalType();
+    if ((Canon->isPointerType() || Canon->isObjectType() ||
+         Canon->isReferenceType()) &&
+        (Canon->isRecordType() || Canon->isConstantArrayType() ||
+         Canon->isMemberPointerType())) {
+      // Compile dtor function.
+      Interpreter &Interp = getInterpreter();
+      void *DtorF = nullptr;
+      // FIXME: Arrays
+      if (const auto *RT = getType()->getAs<RecordType>())
+        // FIXME: How to handle errors in a constructor?
+        DtorF = llvm::cantFail(Interp.CompileDtorCall(RT->getDecl()));
+
+      size_t AllocSize =
+          getASTContext().getTypeSizeInChars(getType()).getQuantity();
+      size_t ElementsSize = 1;
+      setPtr(ValueStorage::CreatePayload(DtorF, AllocSize, ElementsSize));
+    }
+  }
+}
+
+Value::Value(const Value &RHS)
+    : Interp(RHS.Interp), OpaqueType(RHS.OpaqueType), ValueKind(RHS.ValueKind),
+      IsManuallyAlloc(RHS.IsManuallyAlloc) {
+  if (IsManuallyAlloc)
+    ValueStorage::getFromPayload(getPtr())->Retain();
+}
+
+Value::Value(Value &&RHS) noexcept {
+  Interp = std::exchange(RHS.Interp, nullptr);
+  OpaqueType = std::exchange(RHS.Interp, nullptr);
+  ValueKind = std::exchange(RHS.ValueKind, K_Unspecified);
+
+  IsManuallyAlloc = RHS.IsManuallyAlloc;
+  if (IsManuallyAlloc)
+    ValueStorage::getFromPayload(getPtr())->Release();
+}
+
+Value &Value::operator=(const Value &RHS) {
+  if (IsManuallyAlloc)
+    ValueStorage::getFromPayload(getPtr())->Release();
+
+  Interp = RHS.Interp;
+  OpaqueType = RHS.Interp;
+  ValueKind = RHS.ValueKind;
+  IsManuallyAlloc = RHS.IsManuallyAlloc;
+
+  if (IsManuallyAlloc)
+    ValueStorage::getFromPayload(getPtr())->Retain();
+
+  return *this;
+}
+
+Value &Value::operator=(Value &&RHS) noexcept {
+  if (IsManuallyAlloc)
+    ValueStorage::getFromPayload(getPtr())->Release();
+
+  Interp = std::exchange(RHS.Interp, nullptr);
+  OpaqueType = std::exchange(RHS.OpaqueType, nullptr);
+  ValueKind = std::exchange(RHS.ValueKind, K_Unspecified);
+  IsManuallyAlloc = RHS.IsManuallyAlloc;
+
+  return *this;
+}
+
+Value::~Value() {
+  if (IsManuallyAlloc)
+    ValueStorage::getFromPayload(getPtr())->Release();
+}
+
+QualType Value::getType() const {
+  return QualType::getFromOpaquePtr(OpaqueType);
+}
+
+Interpreter &Value::getInterpreter() {
+  assert(Interp != nullptr &&
+         "Can't get interpreter from a default constructed value");
+  return *reinterpret_cast<Interpreter *>(Interp);
+}
+
+ASTContext &Value::getASTContext() { return getInterpreter().getASTContext(); }
+
+void Value::print(llvm::raw_ostream &Out) const {
+  assert(OpaqueType != nullptr && "Can't print default Value");
+  Out << "(" << getType().getAsString() << ") ";
+  switch (getKind()) {
+  case K_Unspecified:
+    assert(false);
+  case K_Void:
+    Out << " \n";
+    break;
+  case K_PtrOrObj:
+    Out << getPtr() << "\n";
+    break;
+#define X(type, name)                                                          \
+  case K_##name:                                                               \
+    Out << get##name() << "\n";                                                \
+    break;
+    BUILTIN_TYPES
+#undef X
+  }
+}
+
+void Value::dump() const { print(llvm::outs()); }

clang/lib/Lex/PPLexerChange.cpp

if (!isEndOfMacro && CurPPLexer && FoundPCHThroughHeader &&
       // Leaving the through header. Continue directly to end of main file
       // processing.
       LeavingPCHThroughHeader = true;
     } else {
       // Client should lex another token unless we generated an EOM.
       return LeavingSubmodule;
     }
   }
-
   // If this is the end of the main file, form an EOF token.
   assert(CurLexer && "Got EOF but no current lexer set!");
   const char *EndPos = getCurLexerEndPos();
   Result.startToken();
   CurLexer->BufferPtr = EndPos;
+
+  if (isIncrementalProcessingEnabled()) {
+    CurLexer->FormTokenWithChars(Result, EndPos, tok::annot_input_end);
+    Result.setAnnotationEndLoc(Result.getLocation());
+    Result.setAnnotationValue(nullptr);
+  } else {
     CurLexer->FormTokenWithChars(Result, EndPos, tok::eof);
+  }
 
   if (isCodeCompletionEnabled()) {
     // Inserting the code-completion point increases the source buffer by 1,
     // but the main FileID was created before inserting the point.
     // Compensate by reducing the EOF location by 1, otherwise the location
     // will point to the next FileID.
     // FIXME: This is hacky, the code-completion point should probably be
     // inserted before the main FileID is created.

clang/lib/Parse/ParseCXXInlineMethods.cpp

if (Tok.is(T1) || Tok.is(T2)) {
       return true;
     }
 
     switch (Tok.getKind()) {
     case tok::eof:
     case tok::annot_module_begin:
     case tok::annot_module_end:
     case tok::annot_module_include:
+    case tok::annot_input_end:
       // Ran out of tokens.
       return false;
 
     case tok::l_paren:
       // Recursively consume properly-nested parens.
       Toks.push_back(Tok);
       ConsumeParen();
       ConsumeAndStoreUntil(tok::r_paren, Toks, /*StopAtSemi=*/false);
case tok::comma:
       // Keep going. We know we're inside a template argument list now.
       ++KnownTemplateCount;
       goto consume_token;
 
     case tok::eof:
     case tok::annot_module_begin:
     case tok::annot_module_end:
     case tok::annot_module_include:
+    case tok::annot_input_end:
       // Ran out of tokens.
       return false;
 
     case tok::less:
       // FIXME: A '<' can only start a template-id if it's preceded by an
       // identifier, an operator-function-id, or a literal-operator-id.
       ++AngleCount;
       goto consume_token;

clang/lib/Parse/ParseDecl.cpp

case tok::plus:
       if (Tok.isAtStartOfLine() && ParsingInObjCContainer)
         return;
       break;
 
     case tok::eof:
     case tok::annot_module_begin:
     case tok::annot_module_end:
     case tok::annot_module_include:
+    case tok::annot_input_end:
       return;
 
     default:
       break;
     }
 
     ConsumeAnyToken();
   }

clang/lib/Parse/ParseStmt.cpp

if (Tok.is(tok::colon) && getCurScope()->isSwitchScope() &&
     // suggest a missing case keyword.
     Diag(OldToken, diag::err_expected_case_before_expression)
       << FixItHint::CreateInsertion(OldToken.getLocation(), "case ");
 
     // Recover parsing as a case statement.
     return ParseCaseStatement(StmtCtx, /*MissingCase=*/true, Expr);
   }
 
+  if (PP.isIncrementalProcessingEnabled() && Tok.is(tok::annot_input_end)) {
+    // If we're parsing an ExprStmt and the last semicolon is missing and the
+    // incremental externsion is enabled and we're reaching the end, consider we
+    // want to do value printing.
+    ConsumeAnyToken();
+    setPrettyPrintMode();
+  } else {
     // Otherwise, eat the semicolon.
     ExpectAndConsumeSemi(diag::err_expected_semi_after_expr);
+  }
   return handleExprStmt(Expr, StmtCtx);
 }
 
 /// ParseSEHTryBlockCommon
 ///
 /// seh-try-block:
 ///   '__try' compound-statement seh-handler
 ///

clang/lib/Parse/Parser.cpp

case tok::annot_pragma_openmp_end:
       // Stop before an OpenMP pragma boundary.
       if (OpenMPDirectiveParsing)
         return false;
       ConsumeAnnotationToken();
       break;
     case tok::annot_module_begin:
     case tok::annot_module_end:
     case tok::annot_module_include:
+    case tok::annot_input_end:
       // Stop before we change submodules. They generally indicate a "good"
       // place to pick up parsing again (except in the special case where
       // we're trying to skip to EOF).
       return false;
 
     case tok::code_completion:
       if (!HasFlagsSet(Flags, StopAtCodeCompletion))
         handleUnexpectedCodeCompletionToken();

 ///           declaration
 /// [C++20]   module-import-declaration
 bool Parser::ParseTopLevelDecl(DeclGroupPtrTy &Result,
                                Sema::ModuleImportState &ImportState) {
   DestroyTemplateIdAnnotationsRAIIObj CleanupRAII(*this);
 
   // Skip over the EOF token, flagging end of previous input for incremental
   // processing
-  if (PP.isIncrementalProcessingEnabled() && Tok.is(tok::eof))
-    ConsumeToken();
+  if (PP.isIncrementalProcessingEnabled() && Tok.is(tok::annot_input_end))
+    ConsumeAnyToken();
 
   Result = nullptr;
   switch (Tok.getKind()) {
   case tok::annot_pragma_unused:
     HandlePragmaUnused();
     return false;
 
   case tok::kw_export:
bool Parser::ParseTopLevelDecl(DeclGroupPtrTy &Result,
   case tok::annot_module_end:
     Actions.ActOnModuleEnd(Tok.getLocation(), reinterpret_cast<Module *>(
                                                   Tok.getAnnotationValue()));
     ConsumeAnnotationToken();
     ImportState = Sema::ModuleImportState::NotACXX20Module;
     return false;
 
   case tok::eof:
+  case tok::annot_input_end:
     // Check whether -fmax-tokens= was reached.
     if (PP.getMaxTokens() != 0 && PP.getTokenCount() > PP.getMaxTokens()) {
       PP.Diag(Tok.getLocation(), diag::warn_max_tokens_total)
           << PP.getTokenCount() << PP.getMaxTokens();
       SourceLocation OverrideLoc = PP.getMaxTokensOverrideLoc();
       if (OverrideLoc.isValid()) {
         PP.Diag(OverrideLoc, diag::note_max_tokens_total_override);
       }

clang/test/Interpreter/pretty-print.cpp

+// RUN: clang-repl "int i = 10;" 'extern "C" int printf(const char*,...);' \
+// RUN:            'auto r1 = printf("i = %d\n", i);' | FileCheck --check-prefix=CHECK-DRIVER %s
+// UNSUPPORTED: system-aix
+// CHECK-DRIVER: i = 10
+// RUN: cat %s | clang-repl | FileCheck %s
+char c = 'a';
+c
+// CHECK: (char) a
+
+int x = 42;
+x
+// CHECK-NEXT: (int) 42
+
+x - 2
+// CHECK-NEXT: (int) 40
+
+float f = 4.2f;
+f
+// CHECK-NEXT: (float) 4.2
+
+double d = 4.21;
+d
+// CHECK-NEXT: (double) 4.21
+
+struct S{};
+S s;
+s
+// CHECK-NEXT: (S) [[Addr:0x.*]]
+
+S{}
+// CHECK-NEXT: (S) [[Addr:0x.*]]
+
+struct SS { ~SS() {} };
+SS{}
+// CHECK-NEXT: (SS) [[Addr:0x.*]]
+
+%quit
+

clang/tools/clang-repl/CMakeLists.txt

 set( LLVM_LINK_COMPONENTS
   ${LLVM_TARGETS_TO_BUILD}
   Core
   LineEditor
   Option
   OrcJIT
   Support
   )
 
 add_clang_tool(clang-repl
   ClangRepl.cpp
   )
 
 clang_target_link_libraries(clang-repl PRIVATE
+  clangAST
   clangBasic
   clangFrontend
   clangInterpreter
   clangTooling
   )
 
 # Support plugins.
 if(CLANG_PLUGIN_SUPPORT)
   export_executable_symbols_for_plugins(clang-repl)
 endif()

clang/tools/clang-repl/ClangRepl.cpp

if (CI->getDiagnosticOpts().VerifyDiagnostics) {
     Errs = Client->getNumErrors();
 
     // The interpreter expects BeginSourceFile/EndSourceFiles to be balanced.
     Client->BeginSourceFile(CI->getLangOpts(), &CI->getPreprocessor());
   }
   return (Errs || HasError) ? EXIT_FAILURE : EXIT_SUCCESS;
 }
 
+static void DeclareMagicFunctions(clang::Interpreter &Interp) {
+  std::vector<llvm::StringRef> MagicFunctions = {
+      "void __InterpreterSetValueNoAlloc(void*, void*, void*, bool);",
+      "void __InterpreterSetValueNoAlloc(void*, void*, void*, char);",
+      "void __InterpreterSetValueNoAlloc(void*, void*, void*, signed char);",
+      "void __InterpreterSetValueNoAlloc(void*, void*, void*, short);",
+      "void __InterpreterSetValueNoAlloc(void*, void*, void*, int);",
+      "void __InterpreterSetValueNoAlloc(void*, void*, void*, long);",
+      "void __InterpreterSetValueNoAlloc(void*, void*, void*, long long);",
+      "void __InterpreterSetValueNoAlloc(void*, void*, void*, unsigned char);",
+      "void __InterpreterSetValueNoAlloc(void*, void*, void*, unsigned short);",
+      "void __InterpreterSetValueNoAlloc(void*, void*, void*, unsigned int);",
+      "void __InterpreterSetValueNoAlloc(void*, void*, void*, unsigned long);",
+      "void __InterpreterSetValueNoAlloc(void*, void*, void*, unsigned long "
+      "long);",
+      "void __InterpreterSetValueNoAlloc(void*, void*, void*, float);",
+      "void __InterpreterSetValueNoAlloc(void*, void*, void*, double);",
+      "void __InterpreterSetValueNoAlloc(void*, void*, void*, void*);",
+      "void* __InterpreterSetValueWithAlloc(void*, void*, void*);"};
+
+  for (llvm::StringRef Function : MagicFunctions) {
+    llvm::cantFail(Interp.ParseAndExecute(Function));
+  }
+  llvm::cantFail(Interp.ParseAndExecute("#include <new>"));
+}
+
 llvm::ExitOnError ExitOnErr;
 int main(int argc, const char **argv) {
   ExitOnErr.setBanner("clang-repl: ");
   llvm::cl::ParseCommandLineOptions(argc, argv);
 
   llvm::llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
 
   std::vector<const char *> ClangArgv(ClangArgs.size());
int main(int argc, const char **argv) {
   auto Interp = ExitOnErr(clang::Interpreter::create(std::move(CI)));
   for (const std::string &input : OptInputs) {
     if (auto Err = Interp->ParseAndExecute(input))
       llvm::logAllUnhandledErrors(std::move(Err), llvm::errs(), "error: ");
   }
 
   bool HasError = false;
 
+  DeclareMagicFunctions(*Interp);
   if (OptInputs.empty()) {
     llvm::LineEditor LE("clang-repl");
     // FIXME: Add LE.setListCompleter
     while (std::optional<std::string> Line = LE.readLine()) {
       if (*Line == R"(%quit)")
         break;
       if (*Line == R"(%undo)") {
         if (auto Err = Interp->Undo()) {