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 CVS repository or removed -entirely. In this case, the best solution is to erase all .d files, -which list dependencies for source files, and rebuild:
+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:
@@ -406,6 +389,107 @@ which list dependencies for source files, and rebuild: rebuilding.
llvmc is experimental and isn't really supported. We suggest +using llvm-gcc instead.
+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.
+In the stacker module is a compiler and runtime + library for the Stacker language, a "toy" language loosely based on Forth.
+The PyPy developers are working on integrating LLVM into the PyPy backend + so that PyPy language can translate to LLVM.
+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.
+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. There is, however, a mostly + implemented configuration-driven + compiler driver which simplifies the task + of running optimizations, linking, and executable generation.
+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 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. - +
- Make sure that the regular C compiler is first in your PATH. -
- - Add the string "-Wl,-native" to your CFLAGS environment variable. - +
- Add the string "-Wl,-native" to your CFLAGS environment variable.
-This will allow the gccld linker to create a native code executable instead of -a 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. -
+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.-In order to find libcrtend.a, you must have the directory in which it lives in -your LLVM_LIB_SEARCH_PATH environment variable. For the binary distribution of -the LLVM GCC front end, this will be the full path of the bytecode-libs -directory inside of the LLVM GCC distribution. +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. +
+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. However, this is a good way to add +C++ support for a processor that does not otherwise have a C++ compiler. +
+ +Use commands like this:
+ +-
+
Compile your program as normal with llvm-g++:
+ +++ ++% llvm-g++ x.cpp -o program +
+or:
+ +++ ++% llvm-g++ a.cpp -c +% llvm-g++ b.cpp -c +% llvm-g++ a.o b.o -o program +
+With llvm-gcc3, 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 +
+
+
+
Note that, by default, the C backend 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 correct but relatively +slow.
+ +Also note: this specific sequence of commands won't work if you use a +function defined in the C++ runtime library (or any other C++ library). To +access an external C++ library, you must 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 can compile the +libraries and your application into two different chunks of C code and link +them.
+ +-What is this __main() call that gets inserted into main()? -
What is this llvm.global_ctors and +_GLOBAL__I__tmp_webcompile... stuff that happens when I #include +<iostream>?
+-The __main call is inserted by the C/C++ compiler in order to guarantee -that static constructors and destructors are called when the program starts up -and shuts down. In C, you can create static constructors and destructors by -using GCC extensions, and in C++ you can do so by creating a global variable -whose class has a ctor or dtor. -
--The actual implementation of __main lives in the -llvm/runtime/GCCLibraries/crtend/ directory in the source-base, and is -linked in automatically when you link the program. +
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.
+-What is this llvm.global_ctors and _GLOBAL__I__tmp_webcompile... stuff that happens when I #include <iostream>? + +
What is this "undef" thing that shows up in my code?
-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. -
+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: --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. -
+
+int X() { int i; return i; }
+
+-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. -
+Is compiled to "ret i32 undef" because "i" never has +a value specified for it.
+ LLVM Compiler Infrastructure
Last modified: $Date$