
	Where results make sense

Topic: LLVM

Related Topics

GNU Compiler Collection

Python programming language

	Debian -- llvm (Site not responding. Last check: 2007-11-07)
		LLVM uses a single, language-independent virtual instruction set both as an offline code representation (to communicate code between compiler phases and to run-time systems) and as the compiler internal representation (to analyze and transform programs).
		LLVM is currently being used to host a wide variety of academic research projects and commercial projects.
		LLVM includes C and C++ front-ends (based on GCC 4.0.1), a front-end for a Forth-like language (Stacker), a young scheme front-end, and Java support is in development.
	packages.debian.org /unstable/devel/llvm (267 words)

	Download LLVM 1.9 for Linux - LLVM is a compiler infrastructure designed for compile-time, link-time, runtime, and - ...
		LLVM supports effective optimization at compile time, link-time (particularly interprocedural), run-time and offline (i.e., after software is installed), while remaining transparent to developers and maintaining compatibility with existing build scripts.
		LLVM is a robust system, particularly well suited for developing new mid-level language-independent analyses and optimizations of all sorts, including those that require extensive interprocedural analysis.
		LLVM is also a great target for front-end development for conventional or research programming languages, including those which require compile-time, link-time, or run-time optimization for effective implementation, proper tail calls or garbage collection.
	linux.softpedia.com /get/Programming/Compilers/LLVM-7177.shtml (543 words)

	LLVM 1.7 Release Notes
		LLVM includes the new llvm-config utility, which makes it easier to build and link programs against the LLVM libraries when not using the LLVM makefiles.
		LLVM supports assigning globals and functions to a particular section in the result executable using the GCC section attribute.
		The core LLVM infrastructure uses GNU autoconf to adapt itself to the machine and operating system on which it is built.
	llvm.org /releases/1.7/docs/ReleaseNotes.html (2276 words)

	CS 421 (Fall 2005): unit project
		LLVM is based on a language-independent, typed assembly language that serves both as the compiler's internal representation and as the persistent "bytecode" representation for programs.
		LLVM is designed to support effective analysis and optimization of programs from arbitrary source-level languages (but does not aim to support language-specific techniques).
		LLVM uses a simple, imperative type system with primitive types (ints, floats, bool, and void) and exactly four derived types: pointers, structures, arrays, and functions.
	www.cs.uiuc.edu /class/fa05/cs421/current/project.html (1311 words)

	The LLVM Compiler Infrastructure Project
		LLVM supports effective optimization at compile time, link-time (particularly interprocedural), run-time and offline (i.e., after software is installed), while remaining transparent to developers and maintaining compatibility with existing build scripts.
		LLVM is a robust system, particularly well suited for developing new mid-level language-independent analyses and optimizations of all sorts, including those that require extensive interprocedural analysis.
		LLVM also provides extensive assertions to pinpoint bugs when they occur, an IR verifier, and tools to automatically identify and narrow down bugs in arbitrary compiler transformations.
	llvm.org (711 words)

	Low Level Virtual Machine - Wikipedia, the free encyclopedia
		LLVM is language and architecture independent; it lies between a language-specific module and a code generator for a machine.
		LLVM includes aggressive interprocedural optimization support, static and JIT compilers, and has many components in various stages of development (including Java bytecode and MSIL frontends, a Python frontend, a new graph coloring register allocator, and more).
		LLVM is written in C++ and was started in 2000 at the University of Illinois at Urbana-Champaign.
	en.wikipedia.org /wiki/Low_Level_Virtual_Machine (445 words)

	Udell at OSCON: IronPython news \| Lambda the Ultimate
		And the hardest part of the port is exception handling (which doesn't seem to be implemented in llvm in the x86 in version 1.2): this is critical to mono and has a lot of complexities in it (stack walks, stack unwinding, finally handlers invocation etc.).
		The biggest missing feature in LLVM is support for trapping overflows, but this would also be the most trivial to add to LLVM (for the purposes of the project, inefficient support is fine: trapping ops are not commonly used).
		LLVM is being used by several functional and other research language front-ends purely because it is really easy to target and provides a TON of different options to the language designer.
	lambda-the-ultimate.org /node/view/141 (5899 words)

	scheme -> LLVM
		This is a small (about 1K lines) self applicable scheme toy compiler which compiles to C-code, and a version that compiles to LLVM with the types fixnum, symbols, strings, functions and vectors (cons cells are seen as vectors of size 2).
		The code is quite similar to the code in SICP (Structure and Interpretation of Computer Programs), chapter five, with the difference that it implements the extra functionality that SICP assumes that the explicit control evaluator (virtual machine) already have.
		LLVM version that uses the stack for temporaries..
	www.ida.liu.se /~tobnu/scheme2llvm (282 words)

	Qt4-preview-feedback Archive - mkspecs and patches for LLVM compile of Qt4
		LLVM cvs can now compile Qt4 from the snapshots available via the unofficial svn repository save for a few linking issues.
		LLVM has no less of a goal than to replace the aging GCC compiler suite as the premier open source tool chain.
		We've patched llvm to allow it, but it would be best to make this snippet less ambiguous.
	lists.trolltech.com /qt4-preview-feedback/2005-02/msg00691.html (918 words)

	The Cliffs of Inanity (Site not responding. Last check: 2007-11-07)
		LLVM's API is quite a bit bulkier than libjit's, and it is more idiosyncratic.
		Finally, LLVM is installed strangely; it is mostly static libraries, but with a few random object files thrown in for good measure.
		LLVM is generally more functional than libjit: it has many more ports, more optimizers, and a friendlier license.
	www.peakpeak.com /~tromey/blog/2006/04/16 (296 words)

	Apple Developing CLR Alternative Into GCC? \| www.kdedevelopers.org
		Apple has hired the main developer and is now urging LLVM to be integrated as an alternative backend of the GCC compiler suite.
		For those of you who haven't had the pleasure of introductions: LLVM is an alternative compiler framework and toolchain that provides, among other things, an optimizer, a code generator, a JIT, a bytecode IR, and a ported g++ frontend.
		Or, as the LLVM website has it, LLVM is a compilation strategy, a virtual instruction set, a compiler infrastructure, and a virtual machine that does not require garbage collection or run-time code generation.
	www.kdedevelopers.org /node/1628 (929 words)

	Chris Lattner - LLVM/GCC Integration Proposal
		In this email, I want to briefly talk about the strengths that LLVM brings to the table, some of the implementation details of my integration work, some of the important ongoing work that we are working on, and answer some of the hot questions that will inevitably come up.
		The LLVM mid-level and interprocedural optimizer work on a common representation (the LLVM IR), which is a three-address SSA-based representation that is somewhat similar to GIMPLE.
		LLVM will continue to evolve this way, being extended to support new information as it is needed.
	gcc.gnu.org /ml/gcc/2005-11/msg00888.html (1864 words)

	The Lifelong Code Optimization Project
		The LLVM Instruction Set and Compilation Strategy: LLVM (Low Level Virtual Machine) is a novel object code representation and compiler infrastructure for link-time and post-link optimization.
		The key idea is to avoid maintain a detailed mapping between the final optimized LLVM code and the corresponding native machine code (generated at link-time), and use this mapping to enable high-level analysis and transformations of the native code at runtime.
		LLVM provides a powerful basis for this work because it allows such analysis to be performed in a language-independent manner (since it operates on a low-level representation), and enables interprocedural analysis without sacrificing the benefits of separate compilation (since it is a link-time framework).
	www-faculty.cs.uiuc.edu /~vadve/lcoproject.html (709 words)

	The LLVM Compiler Infrastructure Project
		The llvm-test testsuite is a large collection of programs we use for nightly testing of generated code performance, compile times, correctness, etc. Having a large testsuite gives us a lot of coverage of programs and enables us to spot and improve any problem areas in the compiler.
		Port the Bigloo Scheme compiler, from Manuel Serrano at INRIA Sophia-Antipolis, to output LLVM bytecode.
		It will be interesting to teach 'dyngen' emit LLVM code for 'ops' and use approach similar to LLVM usage in Apple's OpenGL stack: emit LLVM code for big chunks of input code, optimize it, translate to native code and execute.
	llvm.org /OpenProjects.html (1203 words)

	John T. Criswell (Site not responding. Last check: 2007-11-07)
		I am a Research Programmer for the LLVM Team at the University of Illinois at Urbana-Champaign.
		I am currently employed with the LLVM Research Group at the University of Illinois at Urbana-Champaign.
		LLVM is a compiler framework suitable for compile time, link time, and run time optimizations.
	www.bigw.org /~jcriswel (254 words)

	The LLVM Compiler System (Site not responding. Last check: 2007-11-07)
		LLVM (http://llvm.org) is a suite of carefully designed open source libraries which implement compiler components (like language front-ends, code generators, aggressive optimizers, Just-In-Time compiler support, debug support, link-time optimization, etc).
		The goal of the LLVM project is to build these components in a way that allows them to be combined together to create familiar tools (like a C compiler), interesting new tools (like an OpenGL JIT compiler) and many other things we haven't thought of yet.
		Because LLVM is under continuous development, clients of these components naturally benefit from improvements in the libraries.
	llvm.org /pubs/2007-03-12-BossaLLVMIntro.html (167 words)

	[LLVMdev] A cool use of LLVM at Apple: the OpenGL stack (Site not responding. Last check: 2007-11-07)
		This was previously announced at Apple's WWDC conference last week.] For those who are interested, Apple announced that they are using the LLVM optimizer and JIT within their Mac OS 10.5 'Leopard' OpenGL stack (which was distributed in beta form to WWDC attendees).
		LLVM is used in two different ways, at runtime: 1.
		LLVM is currently used when hardware support is disabled or when the current hardware does not support a feature requested by the user app.
	lists.cs.uiuc.edu /pipermail/llvmdev/2006-August/006492.html (381 words)

	CLiki : LLVM (Site not responding. Last check: 2007-11-07)
		The real boost should be brought by usage of LLVM as a back end for Lisp implementation.
		LLVM Release 2.0 is the latest release as of 23 May 2007.
		The LLVM Developers' Meeting Proceedings (27 May 2007) is available in the form of videos and slides (PDF).
	www.cliki.net /LLVM (217 words)

	COMP4133 Assignments
		It is difficult for you to complete either of the two projects in one week since both LLVM and the underluing compiler problem you deal with are new to you.
		Read and consult the LLVM documentation during the entire project to become familiar with the LLVM infrastructure.
		If you need the llvm front end for a different platform, you can download it from llvm's web site (click ``download 1.1'' and sign their registration form).
	www.cse.unsw.edu.au /~cs4133/Assignments/index.html (340 words)

	LLVM 1.5 has been released! \| Lambda the Ultimate
		LLVM can be used in two ways: 1) link to the libraries we provide for direct access to the APIs.
		The LLVM IR is a well defined representation, whereas the GIMPLE representation is not.
		With LLVM you can use all of GCC's targets through the use of the LLVM C-backend, but this is slower than direct codegen, and you also obviously lost tail calls.
	www.lambda-the-ultimate.org /node/view/715 (2277 words)

	LLVM Test Results for February 23, 2005
		Here are some charts showing how the LLVM optimizer and code generators are changing over time.
		This section tests LLVM on a variety of programs in the test suite.
		This section is meant to track how stable LLVM is as a whole.
	www.lenharth.org /llvm-alpha/2005-02-23.html (500 words)

	HLVM: Getting Started with HLVM
		Certain LLVM tools are being modified to accommodate HLVM as it progresses.
		LLVM is HLVM's sister project and the two are intricately connected.
		Version 4 is much better integrated with LLVM, supports more languages, builds native object files by default, and otherwise looks and acts more like a full gcc compiler than did llvm-gcc3.
	hlvm.org /docs/GettingStarted.html (2980 words)

	Getting Started with LLVM System for MinGW
		The LLVM test suite cannot be run on the MinGW port at this point of time.
		All of the llvm tools and the cfe build with some manual modifications at the source code level and will (probely) work as intended - Not tested throughly.
		Further information about the LLVM directory structure and tool chain can be found on the main Getting Started page.
	www.geocities.com /henrik_bach_llvm (873 words)

	[No title]
		In the epilogue to my three-part "Avoiding Copland 2010" series (1, 2, 3) from last year, I examined the possible role of LLVM in the future of Mac OS X. At WWDC, one use of the technology was revealed, albeit under NDA.
		The LLVM JIT optimizations combined with the new multi-threaded OpenGL stack have yielded a doubling of the frame-rate in "a very popular MMORPG" (which is code for "WoW").
		LLVM reportedly already produces better native x86 code than gcc, and rumor has it that the LLVM team is staffing up.
	arstechnica.com /staff/fatbits.ars/2006/8/17/5024 (1580 words)

	greener pastures (Site not responding. Last check: 2007-11-07)
		One of the most annoying ones is that the LLVM and GCC exception handling mechanisms are incompatible.
		We could use LLVM to JIT compile simple getter and setter methods.
		These appear often enough that it may have a measurable impact on real-world programs and there are no exception handling problems to solve.
	www.spindazzle.org /green/index.php?m=200501 (504 words)

	[bitc-dev] Bringup decisions (Site not responding. Last check: 2007-11-07)
		I don't think going to LLVM would have reduced a lot of effort in the current compiler.
		Of course, producing LLVM code would have the advantage that we could then use the LLVM interpreter for debugging, etc. ii) The other option was to use the LLVM interfaces to emit LLVM bytecode directly.
		We would have a LLVM emission phase instead of the final C emission phase.
	www.coyotos.org /pipermail/bitc-dev/2006-May/000599.html (266 words)

	ob.blog » Apple Investing in LLVM for GCC 4?
		From this posting over on the GCC list by Chris Lattner it would appear that Apple is looking to push forward with the LLVM compiler optimizer, integrated against GCC 4.
		The LLVM code generator is built on modern techniques.
		LLVM can also emit C code, which allows it to support systems for which we do not have a native code generator implemented.
	www.postal-code.com /mrhappy/blog/?p=799 (212 words)

	Reid's LLVM Notes (Site not responding. Last check: 2007-11-07)
		One of my main interests is to extend LLVM to provide as good a toolkit for front end compilers as LLVM currently provides for the back end.
		Completed the implementation of lib/System and made LLVM use it so that the bulk of LLVM is portable.
		Implemented the LLVM general purpose compiler driver, llvmc and general purpose linker, llvm-ld.
	illuvium.net /rspencer (2093 words)

	ansemond.com » Blog Archive » WWDC: LLVM & 3D on the Mac
		LLVM is being added to the OpenGL stack.
		Although the Mac’s OpenGL drivers apparently already try to fill in some of the gaps, LLVM should extend the range of supported features because it’s a full blown compiler rather than a set of optimized canned routines.
		I find this another interesting example of Apple leveraging open source software to improve its proprietary OS: They employed LLVM’s main author, Chris Lattner, who’s PhD topic was LLVM.
	ansemond.com /blog/?p=28 (240 words)

Try your search on: Qwika (all wikis)