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!
Только зарегистрированные пользователи имеют доступ к сервису!
Для получения аккаунта, обратитесь к администратору.
We have user library search paths which come from LD_LIBRARY_PATH or similar;
and system library search paths which are coming from the platform.
This patch enables external users performing symbol resolution to filter out
system search paths when they know the symbol cannot be there.
Now, TClingCallbacks can merge the modules vs non-modules code paths, where
the modules prebuilt path is essentially our LD_LIBRARY_PATH.
If the constructor of the contained object is not run (e.g. because
assembling its arguments triggered an exception), the dtor must not
be run when destructing the cling::Value. Detect this case by imprinting
canary bytes into the contained object bytes: if they have changed,
run the dtor, if not assume that the constructor has failed.
This will cause false positives in those cases where the constructor
is not modifying the first object bytes: in these cases, the dtor
is not run even though the ctor is run. That is still better than
the other case (where the dtor crashes because no ctor was run).
ACLiC now synthesizes a modulemap with a suffix _ACLiC_dict.modulemap. The file
contains the source file to be compiled and the corresponding library.
The modulemap is then passed to rootcling via -fmodule-map-file= flag to avoid
naming clashes with possibly existing other modulemap files.
This patch teaches cling to work with the -fmodule-map-file= flag.
ACLiC supports automatic inclusion of Rtypes.h (making ClassDef macro
available). Modules are built in isolation and are resilient to #include
of Rtypes.h at rootcling startup time. We make module Core (containing Rtypes.h)
visible via a newly implemented callback.
The transactions are useful to buffer Decls before sending them to CodeGen,
to verify semantic validity before emitting. If there is no codegen,
DeclCollecting them wastes CPU cycles during PCH generation time
because all headers are in one single transaction. Of course this also
speeds up regular rootcling invocations.
This patch moves the ROOT-specific rdict.pcm optimization in the EXTENSION_BLOCK
of a C++ module file.
This reduces the generated artifacts and simplifies the loading of a rdict pcm
file as it is now part of the C++ module file. This patch paves our way to
using the global module indexing.
This should solve the problem we have been seeing with cmsUnload. The problem stems from the fact that TCling::AutoParseImplRecurse
uses the address of the current transactions has an index/key when registering a class in fTransactionHeadersMap.
On some platforms TInterpreter.h is parsed late, i.e. during the compilation of:
gInterpreter->AutoParse("SiStripCluster");
consequently (as AutoParse does not create its own transaction), the transactions that contains
the parsin of TInterpreter is the last one committed before AutoParseImplRecurse is executed.
Without the parsing of TInterpreter.h then that transaction is return by fInterpreter->getCurrentTransaction().
With the parsing of TInterpreter.h, during the commit of the transaction of the callbacks are triggered
and one of the decl is a constant (kFALSE) and thus, in TCling::HandleNewDecl, provokes the execution of
if (gROOT->GetListOfGlobals()->FindObject(ND->getNameAsString().c_str()))
return;
which will triggered the creation of a Transaction, however since the last top level transaction was
just switch to the state 'Committed', the new transaction will not be nested and thus
IncrementalParser::endTransaction will set the current transaction to 'nullptr'.
And this value of nullptr for the key of fTransactionHeadersMap is neither guaranteed to be unique
nor handled properly by the rest of the code.
It is unclear why this problem have surfaced recently.
On a failing machine, rebuilding with a 2 month old commit (ad9e5c42cb) still exhibits the problem.
The implementation of class->library mapping makes a call to the
LookupHelper::findScope. This makes the recursive invocations to
LookupHelper::findScope -> ... -> LookupHelper::findScope happen more often.
Dropbox folders (among others) can contain parentheses.
Without this patch, ROOT and cling misinterpret those directories as arguments.
Instead, first find the end of the ".x" line.
If the previous token was a closing paren, we assume that the preceding
tokens (up to the non-nested opening paren) belong to the argument.
On my systems (RHEL7 and Android Termux) PAGE_SIZE is defined to 4096 in /usr/include/sys/user.h . The enum then produces a compile-term error.
Adding this change resolves this error for me.
The new release includes some improvements in both Forward and
Reverse mode:
* Extend the way to specify a dependent variables. Consider function,
`double f(double x, double y, double z) {...}`, `clad::differentiate(f, "z")`
is equivalent to `clad::differentiate(f, 2)`. `clad::gradient(f, "x, y")`
differentiates with respect to `x` and `y` but not `z`. The gradient results
are stored in a `_result` parameter in the same order as `x` and `y` were
specified. Namely, the result of `x` is stored in `_result[0]` and the result
of `y` in `_result[1]`. If we invert the arguments specified in the string to
`clad::gradient(f, "y, x")` the results will be stored inversely.
* Enable recursive differentiation.
* Support single- and multi-dimensional arrays -- works for arrays with constant
size like `double A[] = {1, 2, 3};`, `double A[3];` or `double A[1][2][3][4];`
See more at: https://github.com/vgvassilev/clad/blob/v0.5/docs/ReleaseNotes.md
From V.Vasilev, it fixes:
[ 72%] Building CXX object interpreter/llvm/src/tools/clang/lib/CodeGen/CMakeFiles/clangCodeGen.dir/CodeGenModule.cpp.o
While building module 'Cling_Interpreter' imported from /.../root/core/clingutils/src/RStl.cxx:25:
In file included from <module-includes>:5:
/.../root/interpreter/cling/include/cling/Interpreter/RuntimeUniverse.h:13:2: error: "This file must not be included by compiled programs."
#error "This file must not be included by compiled programs."
^
The getNameAsString interface causes a lot of temporary allocations.
The analysis if a decl is a cling-style wrapper can work only on a
simple declarations on the global scope.
This patch filters out complex declarations (eg in namespaces) and
checks only the identifier content.
The patch reduces the memory footprint difference shown in root-project/root#3012.
Duplicating Cling_Runtime and Cling_Runtime_Extra in both module.modulemap
and module.modulemap.build causes redefinition errors if -Dbuiltin_clang=Off.
We should not duplicate the cling runtime modules in both modulemaps.
The user might use utilities which print on cout and expects the output
to be shown immediately.
This patch automatically flushes std::cout after each execution of a wrapper.
This patch includes:
- Remove existing modulemap.overlay files
Cling now can generate virtual overlay files on-demand.
- Implement `-modulemap_overlay` flag to Cling
This flag is used to tell Cling the location of modulemaps to be
overlayed. (eg. stl.modulemap, libc.modulemap)
- Generate and load virtual modulemap in Cling
It is in Interpreter constructor, happens as part of cxxmodules
initialization step.
- Implement an interface to Clang CompilerInvocation which can take FileSystem pointer
Previously, Clang only took a "string of filenames" which clearly doesn't
work for our usecase. We already discussed this new interface at
modules meeting, so this change will land upstream.
- Add a file existence check in Clang
When compiling a pcm and when Clang saw the #include with which pcm was available
(or being generated implicitly), Clang was putting a notation of the full path to this pcm.
This caused an error when build directory was deleted, because the path didn't exist anymore.
This patch enables modules to be binary distributed, and to make it
work in CMSSW enviroment.
