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. -
-+% cd llvm/runtime +% make clean ; make install-bytecode ++
-What is this __main() call that gets inserted into main()? -
-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. +How can I disable all optimizations when compiling code using the LLVM GCC front end?
+-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. +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.
-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. +Can I use LLVM to convert C++ code to C code?
+-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. +
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 llvm.global_ctors and _GLOBAL__I__tmp_webcompile... stuff that happens when I #include <iostream>?
@@ -548,6 +674,52 @@ instead of iostreams to print values.+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. +
++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.
+@@ -557,7 +729,7 @@ instead of iostreams to print values.
+ LLVM Compiler Infrastructure
Last modified: $Date$