maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/test/Interpreter/execute.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

23 lines
736 B
C++
Raw Normal View History

[clang-repl] Support destructors of global objects. Supports destructors of global objects by properly calling jitdylib deinitialize which calls the global dtors of ir modules. This supersedes https://reviews.llvm.org/D127945. There was an issue when calling deinitialize on windows but it got fixed by https://reviews.llvm.org/D128037. Reviewed By: v.g.vassilev Differential Revision: https://reviews.llvm.org/D128589
2022-07-29 01:37:16 +08:00
// clang-format off
Reland "[clang-repl] Recover the lookup tables of the primary context." The asan issue was fixed in llvm/llvm-project@7bc00ce5cd41 This reverts commit 575e297fcb289f0a9b0ac4b01d1d0fa051f5cc29. Differential revision: https://reviews.llvm.org/D123674
2022-06-24 15:17:20 +08:00
// RUN: clang-repl "int x = 10;" "int y=7; err;" "int y = 10;"
Reland "[clang-repl] Allow passing in code as positional arguments." This reverts commit 3ec88ca60b24 which reverted e386871e1d21 due to a asan build failure. This patch removes the new lines in the test case which seem to introduce the failure. Differential revision: https://reviews.llvm.org/D104898
2021-07-11 01:50:41 +08:00
// 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
[AIX][clang-repl][test] Mark unsupported pending XCOFF64 integrated-as This patch replaces the `powerpc64` token with the `system-aix` one in the UNSUPPORTED line of a test. The `powerpc64` token was originally added temporarily in 71a0609a2b53. If AIX uses integrated-as by default and it works both for 32-bit and 64-bit objects, then the issues encountered so far (see comments in D96033) would be mostly solved. As it is, marking the test as expected-to-fail (as opposed to unsupported) on AIX might cause more trouble in the form of 32-bit versus 64-bit differences. I am not aware of other situations where LIT tests are dependent on whether the LLVM build is 64-bit or 32-bit. Reviewed By: jsji Differential Revision: https://reviews.llvm.org/D102560
2021-05-16 10:38:42 +08:00
// UNSUPPORTED: system-aix
Reland "[clang-repl] Allow passing in code as positional arguments." This reverts commit 3ec88ca60b24 which reverted e386871e1d21 due to a asan build failure. This patch removes the new lines in the test case which seem to introduce the failure. Differential revision: https://reviews.llvm.org/D104898
2021-07-11 01:50:41 +08:00
// CHECK-DRIVER: i = 10
// RUN: cat %s | clang-repl | FileCheck %s
[CodeGen] Consider MangleCtx when move lazy emission States Also move MangleCtx when moving some lazy emission states in CodeGenModule. Without this patch clang-repl hits an invalid address access when passing `-Xcc -O2` flag. Signed-off-by: Jun Zhang <jun@junz.org> Differential Revision: https://reviews.llvm.org/D130420
2022-07-23 13:55:10 +08:00
// RUN: cat %s | clang-repl -Xcc -O2 | FileCheck %s
[clang-repl] Recommit "Land initial infrastructure for incremental parsing" Original commit message: In http://lists.llvm.org/pipermail/llvm-dev/2020-July/143257.html we have mentioned our plans to make some of the incremental compilation facilities available in llvm mainline. This patch proposes a minimal version of a repl, clang-repl, which enables interpreter-like interaction for C++. For instance: ./bin/clang-repl clang-repl> int i = 42; clang-repl> extern "C" int printf(const char*,...); clang-repl> auto r1 = printf("i=%d\n", i); i=42 clang-repl> quit The patch allows very limited functionality, for example, it crashes on invalid C++. The design of the proposed patch follows closely the design of cling. The idea is to gather feedback and gradually evolve both clang-repl and cling to what the community agrees upon. The IncrementalParser class is responsible for driving the clang parser and codegen and allows the compiler infrastructure to process more than one input. Every input adds to the “ever-growing” translation unit. That model is enabled by an IncrementalAction which prevents teardown when HandleTranslationUnit. The IncrementalExecutor class hides some of the underlying implementation details of the concrete JIT infrastructure. It exposes the minimal set of functionality required by our incremental compiler/interpreter. The Transaction class keeps track of the AST and the LLVM IR for each incremental input. That tracking information will be later used to implement error recovery. The Interpreter class orchestrates the IncrementalParser and the IncrementalExecutor to model interpreter-like behavior. It provides the public API which can be used (in future) when using the interpreter library. Differential revision: https://reviews.llvm.org/D96033
2021-05-13 13:41:44 +08:00
extern "C" int printf(const char *, ...);
int i = 42;
auto r1 = printf("i = %d\n", i);
// CHECK: i = 42
struct S { float f = 1.0; S *m = nullptr;} s;
auto r2 = printf("S[f=%f, m=0x%llx]\n", s.f, reinterpret_cast<unsigned long long>(s.m));
// CHECK-NEXT: S[f=1.000000, m=0x0]
Reland "[CodeGen] Keep track info of lazy-emitted symbols in ModuleBuilder" This reverts commits: d3ddc251acae631bf5ab4da13878f7e8b5b5a451 d90eecff5c9e7e9f8263de6cd72d70322400829f It turned out there're some options turned on that leaks the memory intentionally, which fires the asan builds after the patch being applied. The issue has been fixed in 7bc00ce5cd41aad5fd0775f58c8e85a0a8d9ee56, so reland it. Below is the original commit message: The intent of this patch is to selectively carry some states over to the Builder so we won't lose the information of the previous symbols. This used to be several downstream patches of Cling, it aims to fix errors in Clang Interpreter when trying to use inline functions. Before this patch: clang-repl> inline int foo() { return 42;} clang-repl> int x = foo(); JIT session error: Symbols not found: [ _Z3foov ] error: Failed to materialize symbols: { (main, { x, $.incr_module_1.__inits.0, __orc_init_func.incr_module_1 }) } Co-authored-by: Axel Naumann <Axel.Naumann@cern.ch> Signed-off-by: Jun Zhang <jun@junz.org>
2022-06-18 19:53:11 +08:00
inline int foo() { return 42; }
int r3 = foo();
[clang-repl] Implement code undo. In interactive C++ it is convenient to roll back to a previous state of the compiler. For example: clang-repl> int x = 42; clang-repl> %undo clang-repl> float x = 24 // not an error To support this, the patch extends the functionality used to recover from errors and adds functionality to recover the low-level execution infrastructure. The current implementation is based on watermarks. It exploits the fact that at each incremental input the underlying compiler infrastructure is in a valid state. We can only go N incremental inputs back to a previous valid state. We do not need and do not do any further dependency tracking. This patch was co-developed with V. Vassilev, relies on the past work of Purva Chaudhari in clang-repl and is inspired by the past work on the same feature in the Cling interpreter. Co-authored-by: Purva-Chaudhari <purva.chaudhari02@gmail.com> Co-authored-by: Vassil Vassilev <v.g.vassilev@gmail.com> Signed-off-by: Jun Zhang <jun@junz.org>
2022-06-19 10:39:03 +08:00
%quit