Cling does not report failed compilation (on MacOS)

[vepadulano]

Check duplicate issues.

• Checked for duplicates

Description

Cling does not provide a way to programmatically check for a compilation failure, see the reproducer. I tried ProcessLine, Calc and Evaluate but no API works. Run the reproducer below with any of the three functions I see the assertion being triggered.

Expected behaviour

There should be a way to query the interpreter to know whether the last compilation was successful or failed.

Reproducer

#include <TInterpreter.h>
#include <cassert>

void processline(){
    TInterpreter::EErrorCode error = TInterpreter::kNoError;
    gInterpreter->ProcessLine("rndm_stuff", &error);
    assert(error != TInterpreter::kNoError);
}

void calc(){
    TInterpreter::EErrorCode error = TInterpreter::kNoError;
    gInterpreter->Calc("rndm_stuff", &error);
    assert(error != TInterpreter::kNoError);
}

void evaluate(){
    std::unique_ptr<TInterpreterValue> v = gInterpreter->MakeInterpreterValue();
    auto ret = gInterpreter->Evaluate("rndm_stuff", *v);
    assert(ret == 0);
}

int main(){
    processline();
    calc();
    evaluate();
}

ROOT version

master

Installation method

Build from source

Operating system

MacOS

Additional context

No response

[ferdymercury]

Are you compiling the reproducer in debug mode? Otherwise assert is skipped. Or switch to throw?

[vepadulano]

Hi @ferdymercury , thanks for the reply! Yes, the example requires compilation such that NDEBUG is not defined. Although that's besides the point, the same would happen with an if condition.

[ferdymercury]

the same would happen with an if condition.

Not really, at least not on Ubuntu 22 with master debug build. See below modified reproducer:

which returns to me:

ProcessLine detected failure: 1
Calc detected failure: 1
Evaluate detected failure:  Error evaluating expression (rndm_stuff)

#include <TInterpreter.h>
#include <iostream>

void processline(){
    TInterpreter::EErrorCode error = TInterpreter::kNoError;
    gInterpreter->ProcessLine("rndm_stuff", &error);
    if (error != TInterpreter::kNoError) std::cerr << "ProcessLine detected failure: " << error << std::endl;
}

void calc(){
    TInterpreter::EErrorCode error = TInterpreter::kNoError;
    gInterpreter->Calc("rndm_stuff", &error);
    if (error != TInterpreter::kNoError) std::cerr << "Calc detected failure: " << error << std::endl;
}

void evaluate(){
    std::unique_ptr<TInterpreterValue> v = gInterpreter->MakeInterpreterValue();
    try {
        auto ret = gInterpreter->Evaluate("rndm_stuff", *v);
        std::cout << ret << std::endl;
    } catch (std::runtime_error &e) {
        std::cerr << "Evaluate detected failure: " << " " << e.what() << std::endl;
    }
}

int main(){
    processline();
    calc();
    evaluate();
}

[ferdymercury]

I see the assertion being triggered.

Or did you rather want to write

assert(error == TInterpreter::kNoError);

instead of

assert(error != TInterpreter::kNoError); ?

[vepadulano]

I copy-pasted your example, and I confirm the issue:

$ ./cling_repro_if.out
input_line_9:2:3: error: use of undeclared identifier 'rndm_stuff'
 (rndm_stuff)
  ^
input_line_11:2:3: error: use of undeclared identifier 'rndm_stuff'
 (rndm_stuff)
  ^
input_line_13:2:3: error: use of undeclared identifier 'rndm_stuff'
 (rndm_stuff)
  ^
1

Not really, at least not on Ubuntu 22

Since you wrote this, it can be that this issue only appears on MacOS

[ferdymercury]

it can be that this issue only appears on MacOS

Ahh right.

So maybe it's related to / dupe of #7541 by @hahnjo

On Ubuntu, the code throws Cling::CompilationExceptions or errors, see full output below, so maybe MacOs is not catching them properly?

input_line_9:2:3: error: use of undeclared identifier 'rndm_stuff'
 (rndm_stuff)
  ^
Error in <HandleInterpreterException>: Error evaluating expression (rndm_stuff)
Execution of your code was aborted.
ProcessLine detected failure: 1
input_line_11:2:3: error: use of undeclared identifier 'rndm_stuff'
 (rndm_stuff)
  ^
Error in <TInterpreter::Calc>: Error evaluating expression (rndm_stuff).
Evaluation of your expression was aborted.
Calc detected failure: 1
input_line_13:2:3: error: use of undeclared identifier 'rndm_stuff'
 (rndm_stuff)
  ^
Evaluate detected failure:  Error evaluating expression (rndm_stuff)

[vepadulano]

It should not rely on exceptions in the first place, that's why all interpreter APIs have error codes whether as input arguments or return values.

[dpiparo]

Is the problem being reported, especially after having merged #22352, the fact that TCling::Evaluate violates the contract it establishes with the user because it throws in case of problems instead of returning an adequate error code?
If yes, the problem is in cling::interpreter::evaluate, that violates its contract exactly in the same way, or at least in my opinion.
If all the above makes sense @vepadulano , wouldn't adding a try-catch block in TCling::Evaluate (here), given that it will work also on apple silicon?

[dpiparo]

I see processlineand calc work with master (LLVM22). I see evaluate triggering an exception, which is not caught and terminates the program!

[dpiparo]

I think, looking at the stack and code, that that is no real surprise (see below). An exception is thrown from within the interpreter, and it bubbles up in the program steering at high level the just in time compilation.
@vgvassilev @hahnjo do you know if this is by design? After all throwing is a legitimate measure in some cases...

Stack

* thread #1, queue = 'com.apple.main-thread', stop reason = signal SIGABRT
  * frame #0: 0x00000001820c65e8 libsystem_kernel.dylib`__pthread_kill + 8
    frame #1: 0x00000001821018d8 libsystem_pthread.dylib`pthread_kill + 296
    frame #2: 0x0000000182008644 libsystem_c.dylib`abort + 148
    frame #3: 0x00000001820b872c libc++abi.dylib`__abort_message + 132
    frame #4: 0x00000001820a5570 libc++abi.dylib`demangling_terminate_handler() + 272
    frame #5: 0x0000000181cc08a4 libobjc.A.dylib`_objc_terminate() + 172
    frame #6: 0x00000001820b575c libc++abi.dylib`std::__terminate(void (*)()) + 16
    frame #7: 0x00000001820b7be4 libc++abi.dylib`__cxxabiv1::failed_throw(__cxxabiv1::__cxa_exception*) + 88
    frame #8: 0x00000001820a409c libc++abi.dylib`__cxa_throw + 92
    frame #9: 0x000000011df47fe4 libCling.so`cling::CompilationException::throwingHandler((null)=0x0000000000000000, reason="Error evaluating expression (rndm_stuff)", (null)=false) at Exception.cpp:107:5
    frame #10: 0x000000011dfda8ac libCling.so`cling::runtime::internal::EvaluateDynamicExpression(interp=0x0000000103e5be70, DEI=0x00000007fa07e220, DC=0x00000007fc7337a8) at Interpreter.cpp:1842:11
    frame #11: 0x0000000101320114 
    frame #12: 0x00000001046c409c 
    frame #13: 0x000000011df85fe4 libCling.so`cling::IncrementalExecutor::executeWrapper(this=0x00000007fb920500, function=(Data = "_Z15__cling_Un1Qu34Pv", Length = 21), returnValue=0x00000007fab010b8) const at IncrementalExecutor.cpp:218:3
    frame #14: 0x000000011dfd7a74 libCling.so`cling::Interpreter::RunFunction(this=0x0000000103e5be70, FD=0x00000007fc733760, res=0x00000007fab010b8) at Interpreter.cpp:1158:20
    frame #15: 0x000000011dfd6174 libCling.so`cling::Interpreter::EvaluateInternal(this=0x0000000103e5be70, input="rndm_stuff", CO=CompilationOptions @ 0x000000016fdfe5f8, V=0x00000007fab010b8, (null)=0x0000000000000000, wrapPoint=44) at Interpreter.cpp:1410:29
    frame #16: 0x000000011dfd6ee0 libCling.so`cling::Interpreter::evaluate(this=0x0000000103e5be70, input="rndm_stuff", V=0x00000007fab010b8) at Interpreter.cpp:1024:12
    frame #17: 0x000000011d89f924 libCling.so`TCling::Evaluate(this=0x0000000103e5b870, code="rndm_stuff", value=0x00000007fab010b0) at TCling.cxx:7834:33
    frame #18: 0x0000000100000b78 a`evaluate() at a.cpp:19:30
    frame #19: 0x0000000100000d9c a`main at a.cpp:29:5
    frame #20: 0x0000000181d43e00 dyld`start + 6992