I have a number of projects built using CMake and I&#39;d like to be able to easily switch between using GCC or Clang/LLVM to compile them. I believe (please correct me if I&#39;m mistaken!) that to use Clang I need to set the following:

        SET (CMAKE_C_COMPILER             &quot;/usr/bin/clang&quot;)
        SET (CMAKE_C_FLAGS                &quot;-Wall -std=c99&quot;)
        SET (CMAKE_C_FLAGS_DEBUG          &quot;-g&quot;)
        SET (CMAKE_C_FLAGS_MINSIZEREL     &quot;-Os -DNDEBUG&quot;)
        SET (CMAKE_C_FLAGS_RELEASE        &quot;-O4 -DNDEBUG&quot;)
        SET (CMAKE_C_FLAGS_RELWITHDEBINFO &quot;-O2 -g&quot;)
        
        SET (CMAKE_CXX_COMPILER             &quot;/usr/bin/clang++&quot;)
        SET (CMAKE_CXX_FLAGS                &quot;-Wall&quot;)
        SET (CMAKE_CXX_FLAGS_DEBUG          &quot;-g&quot;)
        SET (CMAKE_CXX_FLAGS_MINSIZEREL     &quot;-Os -DNDEBUG&quot;)
        SET (CMAKE_CXX_FLAGS_RELEASE        &quot;-O4 -DNDEBUG&quot;)
        SET (CMAKE_CXX_FLAGS_RELWITHDEBINFO &quot;-O2 -g&quot;)
        
        SET (CMAKE_AR      &quot;/usr/bin/llvm-ar&quot;)
        SET (CMAKE_LINKER  &quot;/usr/bin/llvm-ld&quot;)
        SET (CMAKE_NM      &quot;/usr/bin/llvm-nm&quot;)
        SET (CMAKE_OBJDUMP &quot;/usr/bin/llvm-objdump&quot;)
        SET (CMAKE_RANLIB  &quot;/usr/bin/llvm-ranlib&quot;)

Is there an easy way of switching between these and the default GCC variables, preferably as a system-wide change rather than project specific (i.e. not just adding them into a project&#39;s CMakeLists.txt)?

Also, is it necessary to use the `llvm-*` programs rather than the system defaults when compiling using clang instead of gcc? What&#39;s the difference?

Switching between GCC and Clang/LLVM using CMake

Many dynamic languages implement (or want to implement) a JIT Compiler in order to speed up their execution times. Inevitably, someone from the peanut gallery asks why they don&#39;t use LLVM. The answer is often, &quot;LLVM is unsuitable for building a JIT.&quot; (For Example, Armin Rigo&#39;s comment [here.][1])

**Why is LLVM Unsuitable for building a JIT?**

Note: I know LLVM has its own JIT. If LLVM used to be unsuitable, but now is suitable, please say what changed. I&#39;m not talking about running LLVM Bytecode on the LLVM JIT, I&#39;m talking about using the LLVM libraries to implement a JIT for a dynamic language.


  [1]: http://morepypy.blogspot.com/2008/04/float-operations-for-jit.html?showComment=1208773800000#c6322995253226647458

Why is llvm considered unsuitable for implementing a JIT?

I&#39;m a newbie in `clang`. I have read a paper about source to source transformation from `cuda` to `opencl` using `clang` compiler front end.

Can anyone tell me why the option `-cc1` is sometimes used?


What does the clang -cc1 option do?

In Haskell [LLVM bindings](https://github.com/bos/llvm), I am trying to define a function with a variable number of arguments (actually I mean a constant number that is not known at compile time). I found [this question](https://stackoverflow.com/questions/6448705/adding-a-function-in-llvm-haskell-bindings-when-the-number-of-parameters-is-no) and I am trying to follow the answer.

I do not want to fall back completely to using the FFI for generating LLVM, I want to use the DSL as much as I could and use FFI to only do the things I cannot do via the DSL.

I managed to define a type via functionType, I am still unable to add a function to a module created by calling &lt;code&gt;defineModule&lt;/code&gt;. I also think that the next step is to add the basic blocks to the function via &lt;code&gt;FFI.appendBasicBlock&lt;/code&gt; which I think is easy, but how do I get the arguments via &lt;code&gt;FFI.getParam&lt;/code&gt; inside of a do block in the &lt;code&gt;CodeGenFunction&lt;/code&gt; monad.

Binding FFI and DSL

I just built clang 5.0.0 on a Redhat 6 machine and tried to run clang-format. I&#39;m unable to get the -style option to read in a style file. Here&#39;s an example of a set of commands that I think should work:

    ./clang-format -style=llvm -dump-config &gt; .llvm-format
    ./clang-format -style=.llvm-format ~/myFile.cc

When I run this command I get the following error:

    Invalid value for -style

It appears to find and use .clang-format when placed in a parent directory as expect. The built-in types also work:

    ./clang-format -style=Mozilla ~/myFile.cc

The problem, then, is that I can&#39;t specify explicitly a .clang-format file to use. Is this a problem with my build or am I misusing clang-format oir misunderstanding the documentation?

How do I specify a clang-format file?

As I&#39;ve pointed out - [here](https://stackoverflow.com/questions/5587140/any-tutorial-on-how-to-use-clang-for-syntax-highlighting-and-code-completion/7250322#7250322) - it seems clang&#39;s [libclang]() should be great for implementing the hard task that is C/C++ code analysis and modifications ([check out video presentation and slides](https://stackoverflow.com/questions/5587140/any-tutorial-on-how-to-use-clang-for-syntax-highlighting-and-code-completion/7250322#7250322)).

Do you know of **any** C/C++ refactoring tool based on libclang ?

&quot;Any&quot; includes even simple alpha state project, with support of one refactoristation technique. It can be without preprocessor support. As an example of the functionally about which I&#39;m talking: changing method names, whether it supports multiple files or only one file at a time. You might be wondering what the goal is of asking for even small working examples My thought is that *creating a list of code examples and small tools that are in one place will provide a better resource to learn how to implement refactorisation with libclang*. I believe that from simple projects might grow bigger projects - in a proper opensource manner :).

any C/C++ refactoring tool based on libclang? (even simplest &quot;toy example&quot; )

I am trying to use lldb for c++ debugging and I want to halt if an exception is thrown, like gdb&#39;s `catch throw`, and I cannot find an equivalent in the lldb documentation.

lldb: Breakpoint on exceptions (equivalent of gdb&#39;s catch throw)

(Preface: I&#39;m pretty new to C/C++ and I don&#39;t really know how debugging in native code actually works.)

Some sources say that gdb and lldb can debug [any program compiled to machine code](http://www.lego.com/en-us/mindstorms/products/fan-made-bonus-robots/ev3meg). Others say that to debug with gdb you **must** compile in gcc [with the `-g` flag](http://tedlab.mit.edu/~dr/gdbintro.html). The documentation for gcc itself suggests this is optional, and that in fact if you use it, it can cause problems for debuggers _other than_ gdb. Clang also has a `-g` flag and the documentation basically just says &quot;Generate debug information.&quot;

So are these debuggers restricted to their own toolchains (GNU and LLVM), or are they somehow independent of the compiler used?

Is it possible to debug a gcc-compiled program using lldb, or debug a clang-compiled program using gdb?

It&#39;s always been possible to create NSArrays (and NSDictionaries/NSNumber) with vararg method calls, like:

    [NSArray arrayWithObjects: @&quot;a&quot;, @&quot;b&quot;, @&quot;c&quot;, nil];

Can these be created with in-line literals in a new improvement to LLVM and Clang?

Is there some literal dictionary or array syntax in Objective-C?

*Update 2017-05-17. I no longer work for the company where this question originated, and do not have access to Delphi XEx. While I was there, the problem was solved by migrating to mixed FPC+GCC (Pascal+C), with NEON intrinsics for some routines where it made a difference. (FPC+GCC is highly recommended also because it enables using standard tools, particularly Valgrind.) If someone can demonstrate, with credible examples, how they are actually able to produce optimized ARM code from Delphi XEx, I&#39;m happy to accept the answer.*

______


Embarcadero&#39;s Delphi compilers use an LLVM backend to produce native ARM code for Android devices. I have large amounts of Pascal code that I need to compile into Android applications and I would like to know how to make Delphi generate more efficient code. Right now, I&#39;m not even talking about advanced features like automatic SIMD optimizations, just about producing reasonable code. Surely there must be a way to pass parameters to the LLVM side, or somehow affect the result? Usually, any compiler will have many options to affect code compilation and optimization, but Delphi&#39;s ARM targets seem to be just &quot;optimization on/off&quot; and that&#39;s it.

LLVM is supposed to be capable of producing reasonably tight and sensible code, but it seems that Delphi is using its facilities in a weird way. Delphi wants to use the stack very heavily, and it generally only utilizes the processor&#39;s registers r0-r3 as temporary variables. Perhaps the craziest of all, it seems to be loading normal 32 bit integers as four 1-byte load operations. How to make Delphi produce better ARM code, and without the byte-by-byte hassle it is making for Android? 

At first I thought the byte-by-byte loading was for swapping byte order from big-endian, but that was not the case, it is really just loading a 32 bit number with 4 single-byte loads.*  It might be to load the full 32 bits without doing an unaligned word-sized memory load. (whether it SHOULD avoid that is another thing, which would hint to the whole thing being a compiler bug)*

Let&#39;s look at this simple function:

&lt;!-- language: lang-pascal --&gt;
    
    function ReadInteger(APInteger : PInteger) : Integer;
    begin
      Result := APInteger^;
    end;

Even with optimizations switched on, Delphi XE7 with update pack 1, as well as XE6, produce the following ARM assembly code for that function:

&lt;!-- language: lang-asm --&gt;
    
    Disassembly of section .text._ZN16Uarmcodetestform11ReadIntegerEPi:
    
    00000000 &lt;_ZN16Uarmcodetestform11ReadIntegerEPi&gt;:
       0:	b580      	push	{r7, lr}
       2:	466f      	mov	r7, sp
       4:	b083      	sub	sp, #12
       6:	9002      	str	r0, [sp, #8]
       8:	78c1      	ldrb	r1, [r0, #3]
       a:	7882      	ldrb	r2, [r0, #2]
       c:	ea42 2101 	orr.w	r1, r2, r1, lsl #8
      10:	7842      	ldrb	r2, [r0, #1]
      12:	7803      	ldrb	r3, [r0, #0]
      14:	ea43 2202 	orr.w	r2, r3, r2, lsl #8
      18:	ea42 4101 	orr.w	r1, r2, r1, lsl #16
      1c:	9101      	str	r1, [sp, #4]
      1e:	9000      	str	r0, [sp, #0]
      20:	4608      	mov	r0, r1
      22:	b003      	add	sp, #12
      24:	bd80      	pop	{r7, pc}


Just count the number of instructions and memory accesses Delphi needs for that. And constructing a 32 bit integer from 4 single-byte loads... If I change the function a little bit and use a var parameter instead of a pointer, it is slightly less convoluted:

&lt;!-- language: lang-asm --&gt;
    
    Disassembly of section .text._ZN16Uarmcodetestform14ReadIntegerVarERi:
    
    00000000 &lt;_ZN16Uarmcodetestform14ReadIntegerVarERi&gt;:
       0:	b580      	push	{r7, lr}
       2:	466f      	mov	r7, sp
       4:	b083      	sub	sp, #12
       6:	9002      	str	r0, [sp, #8]
       8:	6801      	ldr	r1, [r0, #0]
       a:	9101      	str	r1, [sp, #4]
       c:	9000      	str	r0, [sp, #0]
       e:	4608      	mov	r0, r1
      10:	b003      	add	sp, #12
      12:	bd80      	pop	{r7, pc}

I won&#39;t include the disassembly here, but for iOS, Delphi produces identical code for the pointer and var parameter versions, and they are almost but not exactly the same as the Android var parameter version. 
*Edit: to clarify, the byte-by-byte loading is only on Android. And only on Android, the pointer and var parameter versions differ from each other. On iOS both versions generate exactly the same code.*

For comparison, here&#39;s what FPC 2.7.1 (SVN trunk version from March 2014) thinks of the function with optimization level -O2. The pointer and var parameter versions are exactly the same.

&lt;!-- language: lang-asm --&gt;
    
    Disassembly of section .text.n_p$armcodetest_$$_readinteger$pinteger$$longint:

    00000000 &lt;P$ARMCODETEST_$$_READINTEGER$PINTEGER$$LONGINT&gt;:
    
       0:	6800      	ldr	r0, [r0, #0]
       2:	46f7      	mov	pc, lr

I also tested an equivalent C function with the C compiler that comes with the Android NDK.

&lt;!-- language: lang-c --&gt;

    int ReadInteger(int *APInteger)
    {
    	return *APInteger;
    }

And this compiles into essentially the same thing FPC made:

&lt;!-- language: lang-asm --&gt;
    
    Disassembly of section .text._Z11ReadIntegerPi:
    
    00000000 &lt;_Z11ReadIntegerPi&gt;:
       0:	6800      	ldr	r0, [r0, #0]
       2:	4770      	bx	lr

How to affect Delphi XEx code generation for Android/ARM targets?

I want clang to compile my C/C++ code to LLVM bitcode rather than a binary executable. How can I achieve that?

And if I have the LLVM bitcode, how can I further compile it to a binary executable?

I want to add some of my own code to the LLVM bitcode before compiling to a binary executable.

How to make clang compile to llvm IR

I have a question concerning llvm, clang, and gcc on OS X. 

What is the difference between the llvm-gcc 4.2, llvm 2.0 and clang? I know that they all build on llvm but how are they different? 

Besides faster compiling, what is the advantage of llvm over gcc?

LLVM vs clang on OS X

What languages can be compiled to WebAssembly (Wasm)?

I believe right now C, C++, and Rust (experimental) can be compiled to WebAssembly, with the llvm compiler backend, with languages like Java, Swift, and C# not currently being supported, but being possible candidates for future development.

I don&#39;t believe JavaScript can be compiled to Wasm.
https://github.com/WebAssembly/design/issues/219

What languages can be compiled to WebAssembly (Wasm)?

Currently I am interested in ARM in general and specifically iphone/android targets. But I just want to know more about clang, since it feels to play important role in the years to come.

I tried

    clang -cc1 --help|grep -i list
    clang -cc1 --help|grep arch|grep -v search
    clang -cc1 --help|grep target

     -triple &lt;value&gt;         Specify target triple (e.g. i686-apple-darwin9)

I know clang has -triplet parameter, but how can I list all possible values for it?
I found that clang is very different to gcc in respect to cross compiling, in GCC world you should have separate binary for everything, like PLATFORM_make or PLATFORM_ld (i*86-pc-cygwin i*86-*-linux-gnu etc. http://git.savannah.gnu.org/cgit/libtool.git/tree/doc/PLATFORMS)

in clang world, it&#39;s only one binary (as I read on some forums). But how do I get the list of supported targets? And if my target it not supported on my distro(linux/windows/macos/whatever) how can I get the one that supports more platform?

if I SVN latest clang like this:

    svn co http://llvm.org/svn/llvm-project/cfe/trunk clang

will I get most of platforms?
It looks like Clang was not built with cross compiling in mind right away, but since it&#39;s llvm based it should be very cross-friendly in theory? thank you!


clang: how to list supported target architectures?

I know that an *&quot;undefined behaviour&quot;* in C++ can pretty much allow the compiler to do anything it wants. However, I had a crash that surprised me, as I assumed that the code was safe enough.

In this case, the real problem happened only on a specific platform using a specific compiler, and only if optimization was enabled.

I tried several things in order to reproduce the problem and simplify it to the maximum. Here&#39;s an extract of a function called `Serialize`, that would take a bool parameter, and copy the string `true` or `false` to an existing destination buffer.

Would this function be in a code review, there would be no way to tell that it, in fact, could crash if the bool parameter was an uninitialized value?

    // Zero-filled global buffer of 16 characters
    char destBuffer[16];
    
    void Serialize(bool boolValue) {
        // Determine which string to print based on boolValue
        const char* whichString = boolValue ? &quot;true&quot; : &quot;false&quot;;
        
        // Compute the length of the string we selected
        const size_t len = strlen(whichString);
        
        // Copy string into destination buffer, which is zero-filled (thus already null-terminated)
        memcpy(destBuffer, whichString, len);
    }

If this code is executed with clang 5.0.0 + optimizations, it will/can crash.

The expected ternary-operator `boolValue ? &quot;true&quot; : &quot;false&quot;` looked safe enough for me, I was assuming, &quot;Whatever garbage value is in `boolValue` doesn&#39;t matter, since it will evaluate to true or false anyhow.&quot;

I have setup a [Compiler Explorer example](https://godbolt.org/z/DoFmhA) that shows the problem in the disassembly, here the complete example. *Note: in order to repro the issue, the combination I&#39;ve found that worked is by using Clang 5.0.0 with -O2 optimisation.*

    #include &lt;iostream&gt;
    #include &lt;cstring&gt;
    
    // Simple struct, with an empty constructor that doesn&#39;t initialize anything
    struct FStruct {
        bool uninitializedBool;
        
       __attribute__ ((noinline))  // Note: the constructor must be declared noinline to trigger the problem
       FStruct() {};
    };
    
    char destBuffer[16];
    
    // Small utility function that allocates and returns a string &quot;true&quot; or &quot;false&quot; depending on the value of the parameter
    void Serialize(bool boolValue) {
        // Determine which string to print depending if &#39;boolValue&#39; is evaluated as true or false
        const char* whichString = boolValue ? &quot;true&quot; : &quot;false&quot;;
        
        // Compute the length of the string we selected
        size_t len = strlen(whichString);
        
        memcpy(destBuffer, whichString, len);
    }
    
    int main()
    {
        // Locally construct an instance of our struct here on the stack. The bool member uninitializedBool is uninitialized.
        FStruct structInstance;
        
        // Output &quot;true&quot; or &quot;false&quot; to stdout
        Serialize(structInstance.uninitializedBool);
        return 0;
    }

The problem arises because of the optimizer: It was clever enough to deduce that the strings &quot;true&quot; and &quot;false&quot; only differs in length by 1. So instead of really calculating the length, it uses the value of the bool itself, which *should* technically be either 0 or 1, and goes like this:

    const size_t len = strlen(whichString); // original code
    const size_t len = 5 - boolValue;       // clang clever optimization

While this is &quot;clever&quot;, so to speak, my question is: **Does the C++ standard allow a compiler to assume a bool can only have an internal numerical representation of &#39;0&#39; or &#39;1&#39; and use it in such a way?**

Or is this a case of implementation-defined, in which case the implementation assumed that all its bools will only ever contain 0 or 1, and any other value is undefined behaviour territory?

Does the C++ standard allow for an uninitialized bool to crash a program?

I keep hearing about LLVM all the time. It&#39;s in Perl, then it&#39;s in Haskell, then someone uses it in some other language? What is it?

+ What exactly distinguishes it from GCC (perspectives = safety etc.)?

What exactly is LLVM?

I am investigating potential code-completion speedups while using clang&#39;s code-completion mechanism. The flow described below is what I found in [rtags](https://github.com/Andersbakken/rtags), by Anders Bakken.

Translation units are parsed by a daemon monitoring files for changes. This is done by called `clang_parseTranslationUnit` and related functions(`reparse*`, `dispose*`). When the user requests a completion at a given line and column in a source file, the daemon passes the cached translation unit for the last saved version of the source file and the current source file to `clang_codeCompleteAt`. ([Clang CodeComplete docs](http://clang.llvm.org/doxygen/group__CINDEX__CODE__COMPLET.html)).

The flags passed to `clang_parseTranslationUnit`(from [CompletionThread::process, line 271](https://github.com/Andersbakken/rtags/blob/master/src/CompletionThread.cpp)) are `CXTranslationUnit_PrecompiledPreamble|CXTranslationUnit_CacheCompletionResults|CXTranslationUnit_SkipFunctionBodes`. The flags passed to `clang_codeCompleteAt`(from [CompletionThread::process, line 305](https://github.com/Andersbakken/rtags/blob/master/src/CompletionThread.cpp)) are `CXCodeComplete_IncludeMacros|CXCodeComplete_IncludeCodePatterns`.

The call to `clang_codeCompleteAt` is very slow - it takes around 3-5 seconds to obtain a completion even in the cases where the completion location is a legitimate member access code, a subset of the intended use case mentioned in the documentation of [`clang_codeCompleteAt`](http://clang.llvm.org/doxygen/group__CINDEX__CODE__COMPLET.html#ga50fedfa85d8d1517363952f2e10aa3bf). This seems way too slow by IDE code-completion standards. Is there a way of speeding this up?

Faster code-completion with clang

I&#39;ve been playing with clang a while, and I stumbled upon &quot;test/SemaTemplate/dependent-template-recover.cpp&quot; (in the clang distribution) which is supposed to provide hints to recover from a template error.

The whole thing can be easily stripped down to a minimal example:

    template&lt;typename T, typename U, int N&gt; struct X {
        void f(T* t)
        {
            // expected-error{{use &#39;template&#39; keyword to treat &#39;f0&#39; as a dependent template name}}
            t-&gt;f0&lt;U&gt;();
        }
    };


The error message yielded by clang:

    tpl.cpp:6:13: error: use &#39;template&#39; keyword to treat &#39;f0&#39; as a dependent template name
             t-&gt;f0&lt;U&gt;();
                ^
                template 
    1 error generated.


... But I have a hard time understanding where exactly one is supposed to insert the `template` keyword to have the code to be syntactically correct?

Confusing Template error

LLVM has [phi](http://llvm.org/docs/LangRef.html#i_phi) instruction with quite weird explanation:

&gt; *The &#39;phi&#39; instruction is used to implement the φ node in the SSA graph representing the function.*

Typically it is used to implement branching. If I understood correctly, it is needed to make dependency analysis possible and in some cases it could help to avoid unnecessary loading. However it&#39;s still hard to understand what it does exactly.

Kaleidoscope [example][1] explains it fairly nicely for `if` case. However it&#39;s not that clear how to implement logical operations like `&amp;&amp;` and `||`. If I type the following to [online llvm](http://llvm.org/demo/index.cgi) compiler:

    void main1(bool r, bool y) {
        bool l = y || r;
    }

Last several lines completely confuse me:

    ; &lt;label&gt;:10                                      ; preds = %7, %0
    %11 = phi i1 [ true, %0 ], [ %9, %7 ]
    %12 = zext i1 %11 to i8

Looks like phi node produces a result which can be used. And I was under impression that phi node just defines from which paths values coming.

Could someone explain what is a Phi node, and how to implement `||` with it?

[1]: https://llvm.org/docs/tutorial/MyFirstLanguageFrontend/LangImpl05.html#llvm-ir-for-if-then-else

What exactly PHI instruction does and how to use it in LLVM

Is there some C/C++ IDE for Windows, which is **integrated** with the LLVM compiler (and Clang C/C++ analyzer), just like modern Xcode do.

I have Dev-Cpp (it uses outdated GCC) and [Code::Blocks][1] (with some GCC). But GCC gives me very cryptic error messages. I want to get some more user-friendly error messages from the Clang frontend.

Yes, Clang was not able to be used with complex C++ code, but trunk Clang  already can compile LLVM itself. So I wonder if is there any of LLVM IDEs in development or in beta versions.

Yes, I can use Clang as other compiler with GCC-compatible IDEs. But is there any IDE, that are *integrated* with Clang? Clang have a different output format, so the IDE must parse it. Clang can provide IDE parsing of sources. Clang has an analyze option, which must be supported in an IDE. Take a look, e.g http://iosdevelopertips.com/xcode/static-code-analysis-clang-and-xcode-3-2.html

And the most wanted feature of Clang - is smart auto-completion, so the IDE can suggest only syntaxilly-correct variants, e.g. list only fields of this struct, class.

**Results:** (merged from answers):

* Eclipse with CDT&gt;=8 and with https://code.google.com/archive/p/llvm4eclipsecdt/ plugin, from Petri Tuononen (no smart auto-completion)
* Vim with vimrc from the LLVM project (smart completion only?) https://llvm.org/viewvc/llvm-project/llvm/trunk/utils/vim/
* Emacs with (smart completion only?) https://llvm.org/svn/llvm-project/cfe/trunk/utils/clang-completion-mode.el
* Qt Creator: https://blog.qt.io/blog/2011/10/19/qt-creator-and-clang/
* CodeLite: http://www.codelite.org/LiteEditor/ClangIntegration35

  [1]: https://en.wikipedia.org/wiki/Code::Blocks



LLVM C++ IDE for Windows

I would like to view an array of elements pointed to by a pointer. In GDB this can be done by treating the pointed memory as an artificial array of a given length using the operator &#39;@&#39; as

    *pointer @ length
where `length` is the number of elements I want to view.

The above syntax does not work in LLDB supplied with Xcode 4.1.

Is there any way how to accomplish the above in LLDB?

View array in LLDB: equivalent of GDB&#39;s &#39;@&#39; operator in Xcode 4.1

I dont understand the difference between LLVM and the java (bytecode), what are they?

-edit- by &#39;what are they&#39; i mean the differences between LLVM and java (bytecode) not what are LLVM and java.


What are the differences between LLVM and java bytecode?

I know I can type ``print someFloatVariable`` when I set a breakpoint or ``po [self someIvarHoldingAnObject]``, but I can&#39;t do useful things like:

    [self setAlpha:1];

Then it spits out:

&gt; error: &#39;[self&#39; is not a valid command.

Weird thing is that I can call `po [self someIvarHoldingAnObject]` and it will print it&#39;s description.

I believe I&#39;ve seen a video a year ago where someone demonstrated how to execute code through the console at runtime, and if I am not mistaken this guy also provided arguments and assigned objects to pointers. How to do that?

How to call methods or execute code in LLDB debugger?

Looking at the LLVM documentation, they mention that [they use &quot;a custom form of RTTI&quot;][1], and this is the reason they have `isa&lt;&gt;`, `cast&lt;&gt;` and `dyn_cast&lt;&gt;` templated functions.

Usually, reading that a library reimplements some basic functionality of a language is a terrible code smell and just invites to run. However, this is LLVM we&#39;re talking of: the guys are working on a C++ compiler _and_ a C++ runtime. If they don&#39;t know what they&#39;re doing, I&#39;m pretty much screwed because I prefer `clang` to the `gcc` version that ships with Mac OS.

Still, being less experienced than them, I&#39;m left wondering what are the pitfalls of the normal RTTI. I know that it works only for types that have a v-table, but that only raises two questions:

* Since you just need a virtual method to have a vtable, why don&#39;t they just mark a method as `virtual`? Virtual destructors seem to be good at this.
* If their solution doesn&#39;t use regular RTTI, any idea how it was implemented?


  [1]: http://llvm.org/docs/ProgrammersManual.html#isa

What can make C++ RTTI undesirable to use?

I&#39;m getting the error `LLVM Profile Error: Failed to write file &quot;default.profraw&quot;: Permission denied` after running unit tests in Xcode. I don&#39;t know where Xcode is trying to write this file to. 

What folder should I grant permissions for?

LLVM Profile Error: Failed to write file &quot;default.profraw&quot;: Permission denied

The question is quite clear I think. I&#39;m trying to write a compiler detection header to be able to include in the application information on which compiler was used and which version.

This is part of the code I&#39;m using:

    /* GNU C Compiler Detection */
    #elif defined __GNUC__
        #ifdef __MINGW32__
            #define COMPILER &quot;MinGW GCC %d.%d.%d&quot;
        #else
            #define COMPILER &quot;GCC %d.%d.%d&quot;
        #endif
        #define COMP_VERSION __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__
    #endif

Which could be used like this:

    printf(&quot;  Compiled using &quot; COMPILER &quot;\n&quot;, COMP_VERSION);

Is there any way to detect LLVM and its version? And CLANG?



How to detect LLVM and its version through #define directives?

From what I&#39;ve read, there is a llvm program that converts java bytecode to llvm&#39;s intermediate form called class2llvm. My question is, how do I access this. What front end do I have to install in order to access this. 

VMkit is their implementation of a JVM, but I am looking for how to compile the java source code with llvm, not how to run it.

Is there a llvm java front end that converts java source to llvm&#39;s intermediate form?

My application needs to run many separate contexts in the same (single-threaded) process. They all share a single `LLVMContext`. 

The process will run many contexts (in the thread sense); that is, each one runs a function in a continuation object based on `boost::context` (still on vault, pre-approved lib) it means that each context can yield, but they basically run in the same single-threaded process. Each one should run basically independent of the other, and more importantly, a compilation error in each one should not affect the execution of the others.

Each of these contexts, will invoke code dynamically that spans multiple translation units (TU). some Translation units may be shared across many of these contexts. compilation errors in a new or modified translation unit should not affect other contexts.

**Clarification Edit:**
For example, T.U. A might be shared among two contexts, context X and Y. just for the sake of having a full picture, lets say that X will also be running code from other translations units, I.e B and D, while Y will have also C. At some point, X decides to make a modification to A, so it creates a new T.U A.1, which is a copy of A, and applies the modification there, so those will not affect context Y. Hope this example makes it clear the requirement. 

My initial impulse was to associate one `llvm::Module` for each context, but since its undefined in LLVM what happens with a module in an intermediate state of compilation, I decided to add one `llvm::Module` for each translation unit (see [this question for the reason][1]), plus the copy-on-write policy I explained before for when modifications of a translation unit happen locally to a context, in order to avoid a modification affecting other contexts.

The main two-fold question I&#39;ve have is:

* How do I link together the different modules in a context in order to invoke them as an unified library? I&#39;m using the C++ api. I&#39;m particularly wary of [this nasty, old bug][2] affecting this functionality. Would this bug still affect me if I transferred ownership of all the modules to the JIT with `ExecutionEngine::addModule()`?

* What are the required steps once a modification on a translation unit forces the update of one of the modules? do I need to drop/delete the old module object and create a new one? is there a recycling policy that I haven&#39;t read about?

A secondary question I have about this is:

* How many `ExecutionEngine` do I need? one for the whole application? one per context? one per module? 


Hope the scope of the question is not too overwhelming.



  [1]: https://stackoverflow.com/q/9843177/170521
  [2]: http://llvm.org/bugs/show_bug.cgi?id=2606

design suggestion: llvm multiple runtime contexts

I transform the simplest C code

    #include &lt;stdio.h&gt;
     
    int main()
    {
      return 0;
    }

to its LLVM IR, using 

    clang -emit-llvm -S hello.c 

The generated IR is:

    define i32 @main() #0 {
      %1 = alloca i32, align 4
      store i32 0, i32* %1
      ret i32 0
    }

However, I do not understand this IR. (LLVM doc helps but not that much for beginners)

1. Why do we have `%1 = alloca i32, align 4` ? What does it correspond to in the original code? 
2. Same question for `store i32 0, i32* %1`
3. Does alloca mean allocation on the stack (instead of the dynamic allocation)?
4. What do &#39;align 4&#39; mean?

Understanding the simplest LLVM IR

After learning a bit of how LLVM work I&#39;m really excited about how portable low-level code can be generated and how modular this &#39;thing&#39; is built.

But I discovered today the existence of C-- that seems to share some concepts with LLVM.

So I&#39;m looking for some information helping me understand the main differences between these two projects... and why both exist.

For me LLVM looks a bit like the ultimate Swiss Army knife for compiler infrastructure, and C-- looks far less advanced.

All Llvm Solutions on Gang of Coders

Total of 30 Llvm Solutions