Cling looks like an interpreter and behaves like an interpreter, it follows the read-evaluate-print-loop (REPL) concept for C/C++.

1. Vassil VassilevVassil Vassilev
Cling – The LLVM-basedCling – The LLVM-based
InterpreterInterpreter

2. Why Do We Need Cling?
Cling's advantages:
 Full C++ support
 STL + templates
 Path to C++0x
 Planned massive reduction of dictionaries
 Easier and smoother transition between
interpreted and compiled code
 Easy maintenance

3. What Is Cling?
 An interpreter – looks like an interpreter and
behaves like an interpreter
Cling follows the read-evaluate-print-loop (repl) concept.
 More than interpreter – built on top of a compiler
(clang) and compiler framework (LLVM)
Contains interpreter parts and compiler parts. More of an interactive
compiler or an interactive compiler interface for clang

4. What Cling Depends On?
 LLVM
“The LLVM Project is a collection of modular and reusable compiler
and toolchain technologies...”
 More than 120 active contributors
Apple, ARM, Google, Qualcomm, QuIC, NVidia, AMD and more
 ~250 commits/week
 Clang
“The goal of the Clang project is to create a new C, C++, Objective C
and Objective C++ front-end for the LLVM compiler.“
 More than 100 active contributors
Apple, ARM, AMD and more
 ~150 commits/week
* Stats from last year until 14.10.2011

5. Cling's Codebase
LLVM – 430K SLOC*
Clang – 333K SLOC*
Cling – 7K SLOC*
* By 12.10.2011. No testsuites included. C and C++ only.
Credits: generated using David A. Wheeler's 'SLOCCount'
Cling's Codebase
LLVM
Clang
Cling
Other ROOT – 1400K SLOC*
CINT+Reflex – 230K SLOC*
Cling – 7K SLOC*
Cling's Codebase
ROOT
CINT
Cling

6. Additional Features
 Just-in-time compiler (JIT)
 Extra platform support
 World class performance and optimizations
 OpenCL
 Expressive diagnostics
 ...

7. Expressive Diagnostics
 Column numbers and caret diagnostics
CaretDiagnostics.C:4:13: warning: '.*' specified field precision is missing a
matching 'int' argument
printf("%.*d");
~~^~
 Range highlighting
RangeHighlight.C:14:39: error: invalid operands to binary expression ('int' and 'A')
return y + func(y ? ((SomeA.X + 40) + SomeA) / 42 + SomeA.X : SomeA.X);
~~~~~~~~~~~~ ^ ~~~~~~~
 Fix-it hints
FixItHints.C:7:27: warning: use of GNU old-style field designator extension
struct point origin = { x: 0.0, y: 0.0 };
^~
.x =

8. Improving Cling Step-By-Step
Cling prototype in 2010:
 Shortcomings of the existing prototype were
analyzed
Source-to-source manipulations, variable initializers not managed
correctly, redundant re-parsing, low efficiency, ...
 Redesign almost from scratch
 Resulted in complete rewrite

9. Advantages of the New Design
 Rely on the compiler libraries where possible
instead of custom implementations
Reduces the maintenance load. If the implementation is not too
specific and makes sense for a compiler we prefer putting it into the
compiler codebase and delegate the maintenance...
 More language independent
The necessary code injections and rewrites are directly in the internal
structures of the underlying compiler
 Stability
The new design enables the implementation of stable error recovery
 Better performance
Re-parsing only in very few cases

10. Challenges
 How to combine incompatible concepts like
compilation and interpretation
Many tasks that are trivial for an interpreter become a nightmare for a
compiler.
 How to make it user-friendly
First step should be to adopt the successful usability extensions from
CINT.

11. Challenges
How to make it user-friendly
First step should be to adopt the successful usability extensions from
CINT.
 Value printer
The interactive mode obeys the repl concept and there should be
easy, interactive and user-extensible access to types and values
 Expressions and statements
CINT-specific C++ extension improving the user interaction with the
interpreter from the terminal...
[cling]$ sin(1)
(double const) 0.841471
void wrapper() {
sin(1);
}

12. [cling]$
[cling]$
int i = 12; printf("%dn",i);
printf("%fn",sin(i));
Expressions and Statements
 Wrap the input
 Scan for declarations
 Extract the declarations one level up, as global
declarations
void wrapper1() {
int i = 12;
printf("%dn",i);
}
void wrapper2() {
printf("%fn", sin(i));
}
int i = 12;

13. Challenges
How to combine incompatible concepts like
compilation and interpretation
Many tasks that are trivial for an interpreter become a nightmare for a compiler.
 Initialization of global variables
Cling depends on global variables, which need to be initialized. However,
the global variables continue to be added (potentially) with every input line...
 Error recovery
Even though the user has typed wrong input at the prompt cling must
survive, i.e issue an error and continue to work...
 Late binding
Cling needs to provide a way for symbols unavailable at compile-time a
second chance to be provided at runtime...

14. Error Recovery
 Filled input-by-input from the command line
 Incorrect inputs must be discarded as a whole

15. Late Binding
{
TFile F;
if (is_day_of_month_even())
F.setName("even.root");
else
F.setName("odd.root");
F.Open();
hist->Draw();
hist->Fill(1.5);
hist->SetFillColor(46);
}
hist->Draw();
 Defined in the
root file
 The root file is gone.
Issue an error.
 Opens a dynamic scope. It
tells the compiler that cling
will take over the resolution
of possible unknown
symbols

16. Late Binding
 Tell the compiler the symbol will be resolved at
runtime
 Wrap it into valid C++ code
 Partially recompile at runtime
{
TFile F;
if (is_day_of_month_even())
F.setName("even.root");
else
F.setName("odd.root");
F.Open();
gCling->EvaluateT<void>("hist->Draw()", ...);
...
}
hist->Draw();

17. Challenges
 Error recovery
Even though the user has typed wrong input at the prompt cling must survive, i.e
issue an error and continue to work...
 Initialization of global variables
Cling depends on global variables, which need to be initialized. However, the global
variables continue to be added (potentially) with every input line...
 Late binding
Cling needs to provide a way for symbols unavailable at compile-time a second
chance to be provided at runtime...
 Value printer
The interactive mode obeys the repl concept and there should be way of easy print
value and type of expression in a user-extensible way...
 Expressions and statements
CINT-specific C++ extension improving the user interaction with the interpreter from
the terminal...

18. Dictionaries
 No reflection information in C++
There is no way a C++ interpreter could know what are the detailed
contents of a compiled program
 CINT and Reflex dictionaries:
 Take large fraction
of libraries
 Multiple copies of
the dictionary
data in the memory

19. Dictionaries in Cling
 Now the compiler is an interpreter as well!
 JIT enables native calls into libraries
 Query the reflection data from compiler libraries
 Compiled dictionaries should be no longer
needed
 Middle term: Everything but ClassDef goes away!
 Long term: No dictionaries at all

20. Library Calls in Cling
 Load the lib
 #include the header containing the function
definition
 Make the call
Can we repackage a
library's headers?
Can we avoid re-
parsing again and
again?

21. Cling @ the LLVM Community
 On 25.07.2011 cling was announced on clang's
mailing list as a working C++ interpreter
 People were thrilled and enthusiastic about it
 Lots of excellent comment and suggestions

22. The Road Ahead

23. Integration into ROOT
Ongoing and continuous process that needs:
Experience with ROOT
Knowledge about cling and clang
interfaces

24. Future: Code Unloading
[cling]$
[cling]$
[cling]$
[cling]$
[cling]$
[cling]$
[cling]$
[cling]$
[cling]$
.L Calculator.h
Calculator calc;
calc.Add(3, 1)
2
.U Calculator.h
.L Calculator.h
Calculator calc;
calc.Add(3, 1)
4
// Calculator.h
class Calculator {
int Add(int a, int b) {
return a + b;
}
...
};
// Calculator.h
class Calculator {
int Add(int a, int b) {
return a - b;
}
...
};

25. Future: Code Unloading
 Fundamental requirement for ROOT
This is what drives the rapid development in ROOT...
 Extremely difficult for a compiler
Teaching an elephant to dance...
 Requires in-depth knowledge of clang internals
Different phases in the compiler, advanced AST manipulations, inter-
procedural analysis, knowledge about LLVM intermediate representation
(bitcode), JIT internals, bitcode recompilation...
 Thinking out-of-the-box
Not often seen problem needs novel way of understanding the compiler
libraries...
 We know how to do it!
Watermarks, dependency analysis, annotation of the corresponding
bitcode, generated for the high-level internal structures,...

26. Cling in ROOT
Lots of interest from experiments and
physicists
The prototype will be included in the
source package of ROOT (the November
release)
The prototype will be an optional
interpreter for ROOT

27. Demo:Demo:
C N GC N G

28. Thank you!Thank you!

29. Backup slidesBackup slides

30. Pre-Compiled Headers
Carefully crafted data structures designed to
improve translator's performance:
 Reduce lexical, syntax and semantic analysis
 Loaded “lazily” on demand

31. Pre-Compiled Headers
Design advantages:
 Loading PCH is significantly faster
than re-parsing
 Minimize the cost of reading
 Read times don't depend on PCH
size
 Cost of generating PCH isn't large