IF YOU WOULD LIKE TO GET AN ACCOUNT, please write an
email to Administrator. User accounts are meant only to access repo
and report issues and/or generate pull requests.
This is a purpose-specific Git hosting for
BaseALT
projects. Thank you for your understanding!
Только зарегистрированные пользователи имеют доступ к сервису!
Для получения аккаунта, обратитесь к администратору.
This makes it possible to drop our custom CompilerInvocation::addOverlay
functionality (but the rest of the patch that introduced it is still
needed with LLVM 13, so it cannot be reverted for now).
According to feature_test_macros, this macro is obsolete and "glibc
has been thread-safe by default for many years." Other platforms
don't use it at all, for example FreeBSD.
Some parts of ROOT used it to determine if we are compiling with
-pthread, but this is essentially unused these days because the
CMake build always enables threading support and there exists no
option to turn it off.
This will be required for future LLVM upgrades that rely on a common
cmake/ directory next to clang/ and llvm/.
The bulk of this change is the result of the following commands:
$ mkdir interpreter/llvm-project/
$ git mv interpreter/llvm/src/tools/clang/ interpreter/llvm-project/clang/
$ git mv interpreter/llvm/src/ interpreter/llvm-project/llvm/
$ git mv interpreter/llvm/llvm-project.tag interpreter/llvm-project/llvm-project.tag
Prior to the upgrade to LLVM13, child interpreters used to also lookup symbols
in their parent.
This commit introduces a `DefinitionGenerator` that allows for symbol lookup
across different `IncrementalJIT` instances, which restores the old behavior.
This change fixes the following tests:
- CodeUnloading/AtExit.C
- MultipleInterpreters/MultipleInterpreters.C
Fixes#12455.
Do not use `ActOnReturnStmt()`, given that the scope returned by
`m_Sema->getCurScope()` might be == m_Sema->TUScope which obviously is
not a function scope.
This fixes the following crash:
```
1: #3 0x0000556b6a50389e clang::Sema::ActOnReturnStmt(clang::SourceLocation, clang::Expr*, clang::Scope*) (/home/jalopezg/CERN/repos/root/_build/interpreter/llvm/src/bin/cling+0x225389e)
1: #4 0x0000556b69215c56 cling::DeclExtractor::EnforceInitOrder(llvm::SmallVector<clang::Stmt*>&) (/home/jalopezg/CERN/repos/root/_build/interpreter/llvm/src/bin/cling+0xf65c56)
1: #5 0x0000556b69216788 cling::DeclExtractor::ExtractDecl(clang::FunctionDecl*) (/home/jalopezg/CERN/repos/root/_build/interpreter/llvm/src/bin/cling+0xf66788)
1: #6 0x0000556b69216a75 cling::DeclExtractor::Transform(clang::Decl*) (/home/jalopezg/CERN/repos/root/_build/interpreter/llvm/src/bin/cling+0xf66a75)
```
This diagnostic should always be promoted to error, regardless of the ignoring
state in `FilteringDiagConsumer`.
This fixes the SourceCall/ErrorMacro.C test.
The failure became visible after merging
https://github.com/root-project/root/pull/12654, given that `IgnorePromptDiags`
now defaults to 0 in `makeDefaultCompilationOptions()`.
The order in which declarations are removed makes a difference, e.g.
`MaybeRemoveDeclFromModule()` may require access to type information to
make up the mangled name.
Thus, we segregate declarations to be removed in `TagDecl`s (i.e., struct
/ union / class / enum) and other declarations. Removal of `TagDecl`s
is deferred until all the other declarations have been processed.
Declarations in each group are iterated in reverse order.
Fixes#12457.
In principle, for a TemplateDecl, `isDefinition()` issues a recursive
call passing the templated decl as a parameter. A `ConceptDecl` is
derived from `TemplateDecl`, however, it should always be considered
a definition.
Also, update the DeclShadowing test incorporating a C++20 concept.
Fixes#12779.
Make `FilteringDiagConsumer` also ignore -Wunused-result. Whether or not
such diagnostic is filtered depends on `CompilationOptions::IgnorePromptDiags`.
In particular, `IgnorePromptDiags` should _only_ be enabled for code parsed
via `Interpreter::EvaluateInternal()`. Thus, as of this commit `IgnorePromptDiags`
defaults to 0 in `makeDefaultCompilationOpts()`
The observable effect of this change is ignoring `-Wunused-result` for
wrapped code, e.g.
```c++
[[nodiscard]] int f() { return 0; }
// This yields `warning: ignoring return value of function declared with 'nodiscard' attribute [-Wunused-result]`
void g() { f(); }
f(); // but this should not
```
isysroot influences where clang will pick up libc++. Without this, and with
Xcode 14.3, cling will use libc++ from Xcode (or the command line tools) rather
than stdc++ from the macOS SDK, as clang would normally use. Passing the isysroot
(which point to the SDK) fixes this.
This solves build errors such as:
```
While building module 'Core':
While building module 'std' imported from input_line_1:1:
In file included from <module-includes>:17:
In file included from /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/math.h:309:
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits:462:1: error: cannot template a using declaration
using _BoolConstant _LIBCPP_NODEBUG_TYPE = integral_constant<bool, _Val>;
^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits:462:21: error: C++ requires a type specifier for all declarations
using _BoolConstant _LIBCPP_NODEBUG_TYPE = integral_constant<bool, _Val>;
^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits:462:68: error: use of undeclared identifier '_Val'
using _BoolConstant _LIBCPP_NODEBUG_TYPE = integral_constant<bool, _Val>;
^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits:462:73: error: expected '(' for function-style cast or type construction
using _BoolConstant _LIBCPP_NODEBUG_TYPE = integral_constant<bool, _Val>;
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^
```
Since the upgrade to LLVM 13, the JIT infrastructure takes ownership
of the Module. After JIT compilation, we get back a (const) pointer
to the compiled module.
This fixes the Cling test ErrorRecovery/StoredState.C.
These headers are part of cling, not user code, so starting
with the current directory is pointless and can actually be
counterproductive.
This helps with https://github.com/root-project/root/issues/12409
but not enough; any dictionary header will still try to access "./".
This is required on RISC-V where Linux uses the lp64d ABI that allows
the usage of floating point registers to pass arguments. It seems to
work out-of-the-box upstream in clang-repl which passes through the
function initTargetOptions in clang/lib/CodeGen/BackendUtil.cpp with
the same effect.
RuntimeDyld does not support RISC-V, so it makes sense to enable
JITLink by default. This also makes relocations work without support
for a large code model.
See the equivalent change upstream in https://reviews.llvm.org/D129092,
committed for LLVM 15 in a4e2c1f762
The routines __aarch64_* are defined in the static library libgcc.a
and not necessarily included in libCling or otherwise present in the
process, so the interpreter has a hard time finding them.
Fixes#12294
Otherwise LLJIT's constructor will ask the LLJITBuilder's JTMB to
create a DataLayout. As we don't propagate the JTMB (yet -- we
probably should!), this will be wrong if target features influence
the DataLayout.
This should fix#12293.
We know exactly which target triple and features the CompilerInstance
wants, we don't need to (and probably must not) second-guess that. This
brings us closer to upstream clang-repl and also includes the change of
https://reviews.llvm.org/D128853 which is crucial for RISC-V.
I missed this in commit 3ff7c1e8e2 and it seems to work by chance on
macOS, but this is needed on Linux: Before, CLING_JTLINK=1 on x86_64
complained about "Unspported personality pointer encoding 0x00" and
crashed entirely on RISC-V.
We introduce an enum which mirrors the type kind and we use it in the getAs and
castAs operations to allow the compiler/interpreter to see all of the functions
and potentially inline them.
This patch brings the performance to similar levels with what we have in the
master.
These interfaces assume we know the type and we should compare if the underlying
type is the one we expect when using the setters and getters. Unfortunately,
this is not the case and we need to further investigate.
This interface allows us to set a value and deduce its corresponding type very
efficiently. This is useful when we use cling::Value to model input arguments
for a function call in the JIT (eg. via TClingCallFunc).
That patch essentially makes cling::Value to hold a value and a type that
correctly models the compiled code.
The improvements are:
* We provide getX and setX interfaces instead of returning the address for the
non const methods. This allows us to be more consistent in terms of
lifetimes as now users cannot take the address of block of memory which can
be freed by the cling::Value.
* We remove the storage types and we rely on the clang::Type which we have in
the cling::Value.
Here we enumerate most of the builtin types and we the generate template
specializations for all of them which are capable to perform the correct
conversions.
The custom memory manager is only needed to avoid freeing the memory
segments; the default InProcessMemoryManager (which is mostly copied)
already does slab allocation to keep all segments together which is
needed for exception handling support.
A limitation of this rudimentary support is that CLING_DEBUG and
CLING_PROFILE do not work, they need to be registered as plugins.
The bits/ headers have different include behavior (mostly due to ranges)
that makes it significantly harder to find a configuration working for
C++14, 17, and 20. Instead, create a dedicated modulemap for C++20.
llvm IR naming of private constants (CodeGenModule::createUnnamedGlobalFrom(),
line 1136) will name private symbols without caring about possible name clashes.
We will create these name clashes by marking such private symbols as weak ones,
re-using previously emitted symbols (e.g. in JITDylib::defineImpl() where they
get added to MUDefsOverridden and thus re-used instead of re-emitted).
Let me see what happens when we keep private symbols private. In principle, the
interpreter should have no means fo accessing them from another transaction -
private symbols seem to be function-local ones.
Fixes https://github.com/root-project/root/pull/12183
UNIX terminals, e.g. vt100, send escape sequences for many special
key combinations. Entering the history search mode assigned a specific
meaning to the ESC character and disabled the processing of escape
sequences, thus accidentally printing some characters that are part
of a CSI.
As a workaround, avoid changing the meaning of ESC; users can still
use the well-known `ESC ESC` sequence (or any other editor command,
e.g. move left/right) to exit the history search mode.
This change only affects UNIX terminals.
Closes issue #10209.
These commands, bound respectively to `ESC l` and `ESC u`, should {lower,upper}case
the next word; however, only the first character was changed.
Fixes#10136.
This editor command (usually binded to Ctrl+T), transposes the character located
at the cursor and the one to its left.
However, its behavior was incorrect if the cursor was at end of the line,
invoking `std::string::operator[]()` passing an index that is out of bounds.
In that case, as per GNU Readline behavior, it should swap the two last
characters.
Closes#10133.
This change is equivalent to the popular GNU Readline keybinding
```
"\e[3;5~": kill-word
```
As a requirement, the `[3;5~` CSI was added in StreamReaderUnix.cpp. No
additional changes required to StreamReaderWin.cpp.
