Date: Wed, 15 Aug 2012 19:34:23 +0000 Subject: Vendor import of llvm trunk r161861: http://llvm.org/svn/llvm-project/llvm/trunk@161861 --- docs/FAQ.html | 948 ---------------------------------------------------------- 1 file changed, 948 deletions(-) delete mode 100644 docs/FAQ.html (limited to 'docs/FAQ.html') diff --git a/docs/FAQ.html b/docs/FAQ.html deleted file mode 100644 index 78c0268..0000000 --- a/docs/FAQ.html +++ /dev/null @@ -1,948 +0,0 @@ - - - - - LLVM: Frequently Asked Questions - - - - -

- LLVM: Frequently Asked Questions -

- -

License -
1. Why are the LLVM source code and the front-end distributed under - different licenses?
2. Does the University of Illinois Open Source License really qualify as an - "open source" license?
3. Can I modify LLVM source code and redistribute the modified source?
4. Can I modify LLVM source code and redistribute binaries or other tools - based on it, without redistributing the source?
Source code -
1. In what language is LLVM written?
2. How portable is the LLVM source code?
Build Problems -
1. When I run configure, it finds the wrong C compiler.
2. The configure script finds the right C compiler, but it uses - the LLVM linker from a previous build. What do I do?
3. When creating a dynamic library, I get a strange GLIBC error.
4. I've updated my source tree from Subversion, and now my build is trying - to use a file/directory that doesn't exist.
5. I've modified a Makefile in my source tree, but my build tree keeps - using the old version. What do I do?
6. I've upgraded to a new version of LLVM, and I get strange build - errors.
7. I've built LLVM and am testing it, but the tests freeze.
8. Why do test results differ when I perform different types of - builds?
9. Compiling LLVM with GCC 3.3.2 fails, what should I do?
10. Compiling LLVM with GCC succeeds, but the resulting tools do not work, - what can be wrong?
11. When I use the test suite, all of the C Backend tests fail. What is - wrong?
12. After Subversion update, rebuilding gives the error "No rule to make - target".
13. When I compile LLVM-GCC with srcdir == objdir, - it fails. Why?
Source Languages -
- -
Using the GCC Front End -
1. When I compile software that uses a configure script, the configure - script thinks my system has all of the header files and libraries it is - testing for. How do I get configure to work correctly?
2. When I compile code using the LLVM GCC front end, it complains that it - cannot find libcrtend.a?
3. How can I disable all optimizations when compiling code using the LLVM - GCC front end?
4. Can I use LLVM to convert C++ code to C - code?
5. Can I compile C or C++ code to - platform-independent LLVM bitcode?
-
Questions about code generated by the GCC front-end -
-

- -

Written by The LLVM Team

- - - -

- License -

- - -

- -

Why are the LLVM source code and the front-end distributed under different - licenses?

- -

The C/C++ front-ends are based on GCC and must be distributed under the GPL. - Our aim is to distribute LLVM source code under a much less - restrictive license, in particular one that does not compel users who - distribute tools based on modifying the source to redistribute the modified - source code as well.

- -

Does the University of Illinois Open Source License really qualify as an - "open source" license?

- -

Yes, the license - is certified by - the Open Source Initiative (OSI).

- -

Can I modify LLVM source code and redistribute the modified source?

- -

Yes. The modified source distribution must retain the copyright notice and - follow the three bulletted conditions listed in - the LLVM - license.

- -

Can I modify LLVM source code and redistribute binaries or other tools based - on it, without redistributing the source?

- -

Yes. This is why we distribute LLVM under a less restrictive license than - GPL, as explained in the first question above.

- -

- - -

- Source Code -

- - -

- -

In what language is LLVM written?

- -

All of the LLVM tools and libraries are written in C++ with extensive use of - the STL.

- -

How portable is the LLVM source code?

- -

The LLVM source code should be portable to most modern UNIX-like operating -systems. Most of the code is written in standard C++ with operating system -services abstracted to a support library. The tools required to build and test -LLVM have been ported to a plethora of platforms.

- -

Some porting problems may exist in the following areas:

- -

The GCC front end code is not as portable as the LLVM suite, so it may not - compile as well on unsupported platforms.
The LLVM build system relies heavily on UNIX shell tools, like the Bourne - Shell and sed. Porting to systems without these tools (MacOS 9, Plan 9) - will require more effort.

- -

- - -

- Build Problems -

- - -

- -

When I run configure, it finds the wrong C compiler.

- -

The configure script attempts to locate first gcc and then - cc, unless it finds compiler paths set in CC - and CXX for the C and C++ compiler, respectively.

- -

If configure finds the wrong compiler, either adjust your - PATH environment variable or set CC and CXX - explicitly.

- -

The configure script finds the right C compiler, but it uses the - LLVM linker from a previous build. What do I do?

- -

The configure script uses the PATH to find executables, so - if it's grabbing the wrong linker/assembler/etc, there are two ways to fix - it:

- -

Adjust your PATH environment variable so that the correct - program appears first in the PATH. This may work, but may not be - convenient when you want them first in your path for other - work.
Run configure with an alternative PATH that is - correct. In a Borne compatible shell, the syntax would be:
- -
```
-% PATH=[the path without the bad program] ./configure ...
-
```
- -
This is still somewhat inconvenient, but it allows configure - to do its work without having to adjust your PATH - permanently.

- -

When creating a dynamic library, I get a strange GLIBC error.

- -

Under some operating systems (i.e. Linux), libtool does not work correctly if - GCC was compiled with the --disable-shared option. To work around this, - install your own version of GCC that has shared libraries enabled by - default.

- -

I've updated my source tree from Subversion, and now my build is trying to - use a file/directory that doesn't exist.

- -

You need to re-run configure in your object directory. When new Makefiles - are added to the source tree, they have to be copied over to the object tree - in order to be used by the build.

- -

I've modified a Makefile in my source tree, but my build tree keeps using the - old version. What do I do?

- -

If the Makefile already exists in your object tree, you can just run the - following command in the top level directory of your object tree:

- -

-% ./config.status <relative path to Makefile>
-

- -

If the Makefile is new, you will have to modify the configure script to copy - it over.

- -

I've upgraded to a new version of LLVM, and I get strange build errors.

- -

Sometimes, changes to the LLVM source code alters how the build system works. - Changes in libtool, autoconf, or header file dependencies are especially - prone to this sort of problem.

- -

The best thing to try is to remove the old files and re-build. In most - cases, this takes care of the problem. To do this, just type make - clean and then make in the directory that fails to build.

- -

I've built LLVM and am testing it, but the tests freeze.

- -

This is most likely occurring because you built a profile or release - (optimized) build of LLVM and have not specified the same information on the - gmake command line.

- -

For example, if you built LLVM with the command:

- -

-% gmake ENABLE_PROFILING=1
-

- -

...then you must run the tests with the following commands:

- -

-% cd llvm/test
-% gmake ENABLE_PROFILING=1
-

- -

Why do test results differ when I perform different types of builds?

- -

The LLVM test suite is dependent upon several features of the LLVM tools and - libraries.

- -

First, the debugging assertions in code are not enabled in optimized or - profiling builds. Hence, tests that used to fail may pass.

- -

Second, some tests may rely upon debugging options or behavior that is only - available in the debug build. These tests will fail in an optimized or - profile build.

- -

Compiling LLVM with GCC 3.3.2 fails, what should I do?

- -

This is a bug in - GCC, and affects projects other than LLVM. Try upgrading or downgrading - your GCC.

- -

Compiling LLVM with GCC succeeds, but the resulting tools do not work, what - can be wrong?

- -

Several versions of GCC have shown a weakness in miscompiling the LLVM - codebase. Please consult your compiler version (gcc --version) to - find out whether it is broken. - If so, your only option is to upgrade GCC to a known good version.

- -

After Subversion update, rebuilding gives the error "No rule to make - target".

- -

If the error is of the form:

- -

-gmake[2]: *** No rule to make target `/path/to/somefile', needed by
-`/path/to/another/file.d'.

-Stop.
-

- -

This may occur anytime files are moved within the Subversion repository or - removed entirely. In this case, the best solution is to erase all - .d files, which list dependencies for source files, and rebuild:

- -

-% cd $LLVM_OBJ_DIR
-% rm -f `find . -name \*\.d` 
-% gmake 
-

- -

In other cases, it may be necessary to run make clean before - rebuilding.

- -

When I compile LLVM-GCC with srcdir == objdir, it - fails. Why?

- -

The GNUmakefile in the top-level directory of LLVM-GCC is a special - Makefile used by Apple to invoke the build_gcc script after - setting up a special environment. This has the unfortunate side-effect that - trying to build LLVM-GCC with srcdir == objdir in a "non-Apple way" invokes - the GNUmakefile instead of Makefile. Because the - environment isn't set up correctly to do this, the build fails.

- -

People not building LLVM-GCC the "Apple way" need to build LLVM-GCC with - srcdir != objdir, or simply remove the GNUmakefile entirely.

- -

We regret the inconvenience.

- -

- - -

- Source Languages -

- -

What source languages are supported?

- -

LLVM currently has full support for C and C++ source languages. These are - available through a special version of GCC that LLVM calls the - C Front End

- -

There is an incomplete version of a Java front end available in the - java module. There is no documentation on this yet so you'll need to - download the code, compile it, and try it.

- -

The PyPy developers are working on integrating LLVM into the PyPy backend so - that PyPy language can translate to LLVM.

- -

I'd like to write a self-hosting LLVM compiler. How - should I interface with the LLVM middle-end optimizers and back-end code - generators?

- -

Your compiler front-end will communicate with LLVM by creating a module in - the LLVM intermediate representation (IR) format. Assuming you want to write - your language's compiler in the language itself (rather than C++), there are - 3 major ways to tackle generating LLVM IR from a front-end:

- -

Call into the LLVM libraries code using your language's FFI - (foreign function interface). - -
- for: best tracks changes to the LLVM IR, .ll syntax, and .bc - format
- for: enables running LLVM optimization passes without a - emit/parse overhead
- for: adapts well to a JIT context
- against: lots of ugly glue code to write
Emit LLVM assembly from your compiler's native language. -
- for: very straightforward to get started
- against: the .ll parser is slower than the bitcode reader - when interfacing to the middle end
- against: you'll have to re-engineer the LLVM IR object model - and asm writer in your language
- against: it may be harder to track changes to the IR
Emit LLVM bitcode from your compiler's native language. - -
- for: can use the more-efficient bitcode reader when - interfacing to the middle end
- against: you'll have to re-engineer the LLVM IR object - model and bitcode writer in your language
- against: it may be harder to track changes to the IR

- -

If you go with the first option, the C bindings in include/llvm-c should help - a lot, since most languages have strong support for interfacing with C. The - most common hurdle with calling C from managed code is interfacing with the - garbage collector. The C interface was designed to require very little memory - management, and so is straightforward in this regard.

- -

What support is there for a higher level source language - constructs for building a compiler?

- -

Currently, there isn't much. LLVM supports an intermediate representation - which is useful for code representation but will not support the high level - (abstract syntax tree) representation needed by most compilers. There are no - facilities for lexical nor semantic analysis.

- -

I don't understand the GetElementPtr - instruction. Help!

- -

See The Often Misunderstood GEP - Instruction.

- -

- - -

- Using the GCC Front End -

- -

When I compile software that uses a configure script, the configure script - thinks my system has all of the header files and libraries it is testing for. - How do I get configure to work correctly?

- -

The configure script is getting things wrong because the LLVM linker allows - symbols to be undefined at link time (so that they can be resolved during JIT - or translation to the C back end). That is why configure thinks your system - "has everything."

- -

To work around this, perform the following steps:

- -

Make sure the CC and CXX environment variables contains the full path to - the LLVM GCC front end.
Make sure that the regular C compiler is first in your PATH.
Add the string "-Wl,-native" to your CFLAGS environment variable.

- -

This will allow the llvm-ld linker to create a native code - executable instead of shell script that runs the JIT. Creating native code - requires standard linkage, which in turn will allow the configure script to - find out if code is not linking on your system because the feature isn't - available on your system.

- -

When I compile code using the LLVM GCC front end, it complains that it cannot - find libcrtend.a. -

- -

The only way this can happen is if you haven't installed the runtime - library. To correct this, do:

- -

-% cd llvm/runtime
-% make clean ; make install-bytecode
-

- -

How can I disable all optimizations when compiling code using the LLVM GCC - front end?

- -

Passing "-Wa,-disable-opt -Wl,-disable-opt" will disable *all* cleanup and - optimizations done at the llvm level, leaving you with the truly horrible - code that you desire.

- - -

Can I use LLVM to convert C++ code to C code?

- -

Yes, you can use LLVM to convert code from any language LLVM supports to C. - Note that the generated C code will be very low level (all loops are lowered - to gotos, etc) and not very pretty (comments are stripped, original source - formatting is totally lost, variables are renamed, expressions are - regrouped), so this may not be what you're looking for. Also, there are - several limitations noted below.

- -

Use commands like this:

- -

Compile your program with llvm-g++:
- -
```
-% llvm-g++ -emit-llvm x.cpp -o program.bc -c
-
```
- -
or:
- -
```
-% llvm-g++ a.cpp -c -emit-llvm
-% llvm-g++ b.cpp -c -emit-llvm
-% llvm-ld a.o b.o -o program
-
```
- -
This will generate program and program.bc. The .bc - file is the LLVM version of the program all linked together.
Convert the LLVM code to C code, using the LLC tool with the C - backend:
- -
```
-% llc -march=c program.bc -o program.c
-
```
Finally, compile the C file:
- -
```
-% cc x.c -lstdc++
-
```

- -

Using LLVM does not eliminate the need for C++ library support. If you use - the llvm-g++ front-end, the generated code will depend on g++'s C++ support - libraries in the same way that code generated from g++ would. If you use - another C++ front-end, the generated code will depend on whatever library - that front-end would normally require.

- -

If you are working on a platform that does not provide any C++ libraries, you - may be able to manually compile libstdc++ to LLVM bitcode, statically link it - into your program, then use the commands above to convert the whole result - into C code. Alternatively, you might compile the libraries and your - application into two different chunks of C code and link them.

- -

Note that, by default, the C back end does not support exception handling. - If you want/need it for a certain program, you can enable it by passing - "-enable-correct-eh-support" to the llc program. The resultant code will use - setjmp/longjmp to implement exception support that is relatively slow, and - not C++-ABI-conforming on most platforms, but otherwise correct.

- -

Also, there are a number of other limitations of the C backend that cause it - to produce code that does not fully conform to the C++ ABI on most - platforms. Some of the C++ programs in LLVM's test suite are known to fail - when compiled with the C back end because of ABI incompatibilities with - standard C++ libraries.

- -

Can I compile C or C++ code to - platform-independent LLVM bitcode?

- -

No. C and C++ are inherently platform-dependent languages. The most obvious - example of this is the preprocessor. A very common way that C code is made - portable is by using the preprocessor to include platform-specific code. In - practice, information about other platforms is lost after preprocessing, so - the result is inherently dependent on the platform that the preprocessing was - targeting.

- -

Another example is sizeof. It's common for sizeof(long) to - vary between platforms. In most C front-ends, sizeof is expanded to - a constant immediately, thus hard-wiring a platform-specific detail.

- -

Also, since many platforms define their ABIs in terms of C, and since LLVM is - lower-level than C, front-ends currently must emit platform-specific IR in - order to have the result conform to the platform ABI.

- -

- - -

- Questions about code generated by the GCC front-end -

- -

What is this llvm.global_ctors and - _GLOBAL__I__tmp_webcompile... stuff that happens when I #include - <iostream>?

- -

If you #include the <iostream> header into a C++ - translation unit, the file will probably use - the std::cin/std::cout/... global objects. However, C++ - does not guarantee an order of initialization between static objects in - different translation units, so if a static ctor/dtor in your .cpp file - used std::cout, for example, the object would not necessarily be - automatically initialized before your use.

- -

To make std::cout and friends work correctly in these scenarios, the - STL that we use declares a static object that gets created in every - translation unit that includes <iostream>. This object has a - static constructor and destructor that initializes and destroys the global - iostream objects before they could possibly be used in the file. The code - that you see in the .ll file corresponds to the constructor and destructor - registration code. -

- -

If you would like to make it easier to understand the LLVM code - generated by the compiler in the demo page, consider using printf() - instead of iostreams to print values.

- - - -

Where did all of my code go??

- -

If you are using the LLVM demo page, you may often wonder what happened to - all of the code that you typed in. Remember that the demo script is running - the code through the LLVM optimizers, so if your code doesn't actually do - anything useful, it might all be deleted.

- -

To prevent this, make sure that the code is actually needed. For example, if - you are computing some expression, return the value from the function instead - of leaving it in a local variable. If you really want to constrain the - optimizer, you can read from and assign to volatile global - variables.

- - - -

What is this "undef" thing that shows up in my - code?

- -

undef is the LLVM way of - representing a value that is not defined. You can get these if you do not - initialize a variable before you use it. For example, the C function:

- -

-int X() { int i; return i; }
-

- -

Is compiled to "ret i32 undef" because "i" never has a - value specified for it.

- - - -

Why does instcombine + simplifycfg turn - a call to a function with a mismatched calling convention into "unreachable"? - Why not make the verifier reject it?

- -

This is a common problem run into by authors of front-ends that are using -custom calling conventions: you need to make sure to set the right calling -convention on both the function and on each call to the function. For example, -this code:

- -

-define fastcc void @foo() {
-        ret void
-}
-define void @bar() {
-        call void @foo()
-        ret void
-}
-

- -

Is optimized to:

- -

-define fastcc void @foo() {
-	ret void
-}
-define void @bar() {
-	unreachable
-}
-

- -

... with "opt -instcombine -simplifycfg". This often bites people because -"all their code disappears". Setting the calling convention on the caller and -callee is required for indirect calls to work, so people often ask why not make -the verifier reject this sort of thing.

- -

The answer is that this code has undefined behavior, but it is not illegal. -If we made it illegal, then every transformation that could potentially create -this would have to ensure that it doesn't, and there is valid code that can -create this sort of construct (in dead code). The sorts of things that can -cause this to happen are fairly contrived, but we still need to accept them. -Here's an example:

- -

-define fastcc void @foo() {
-        ret void
-}
-define internal void @bar(void()* %FP, i1 %cond) {
-        br i1 %cond, label %T, label %F
-T:  
-        call void %FP()
-        ret void
-F:
-        call fastcc void %FP()
-        ret void
-}
-define void @test() {
-        %X = or i1 false, false
-        call void @bar(void()* @foo, i1 %X)
-        ret void
-} 
-

- -

In this example, "test" always passes @foo/false into bar, which ensures that - it is dynamically called with the right calling conv (thus, the code is - perfectly well defined). If you run this through the inliner, you get this - (the explicit "or" is there so that the inliner doesn't dead code eliminate - a bunch of stuff): -

- -

-define fastcc void @foo() {
-	ret void
-}
-define void @test() {
-	%X = or i1 false, false
-	br i1 %X, label %T.i, label %F.i
-T.i:
-	call void @foo()
-	br label %bar.exit
-F.i:
-	call fastcc void @foo()
-	br label %bar.exit
-bar.exit:
-	ret void
-}
-

- -

Here you can see that the inlining pass made an undefined call to @foo with - the wrong calling convention. We really don't want to make the inliner have - to know about this sort of thing, so it needs to be valid code. In this case, - dead code elimination can trivially remove the undefined code. However, if %X - was an input argument to @test, the inliner would produce this: -

- -

-define fastcc void @foo() {
-	ret void
-}
-
-define void @test(i1 %X) {
-	br i1 %X, label %T.i, label %F.i
-T.i:
-	call void @foo()
-	br label %bar.exit
-F.i:
-	call fastcc void @foo()
-	br label %bar.exit
-bar.exit:
-	ret void
-}
-

- -

The interesting thing about this is that %X must be false for the -code to be well-defined, but no amount of dead code elimination will be able to -delete the broken call as unreachable. However, since instcombine/simplifycfg -turns the undefined call into unreachable, we end up with a branch on a -condition that goes to unreachable: a branch to unreachable can never happen, so -"-inline -instcombine -simplifycfg" is able to produce:

- -

-define fastcc void @foo() {
-	ret void
-}
-define void @test(i1 %X) {
-F.i:
-	call fastcc void @foo()
-	ret void
-}
-

- -

- - - -

- - LLVM Compiler Infrastructure
- Last modified: $Date: 2012-03-27 13:25:16 +0200 (Tue, 27 Mar 2012) $ -

- - - -- cgit v1.1