Green Hills Optimizing Compilers
Green Hills Software has led the embedded industry for the past thirty years with our optimizing compilers. On EEMBC benchmarks—the most widely accepted benchmarks in the embedded industry—Green Hills Compilers consistently outperform competing compilers to generate the fastest and smallest code for 32- and 64-bit processors.
Green Hills Compilers use the most advanced optimizations to maximize your program's performance even within strict size constraints. For example, our CodeFactor™ optimization speeds your program's execution and reduces its size by removing redundant segments of code via subroutine calls and tail merges. Static basing provides the same benefits (faster speed, smaller size) by grouping data items to significantly reduce the number of load address operations.
Every one of our optimizations—whether it's our own innovation or an industry standard—is meticulously implemented. Continuing three decades of engineering excellence, we painstakingly research and then test each one against hundreds of benchmarks. Careful implementation and cutting-edge technology mean that on most programs, the Green Hills Compilers offer a 20% improvement in speed and at least a 10% reduction in size relative to the GNU Compiler. One customer described the Green Hills Compiler as "the most aggressively optimizing embedded compiler I have ever encountered."
While the Green Hills Compilers provide excellent default settings, we understand that your application is unique. You can fine-tune compiler output by enabling different combinations of optimizations and by configuring optimizations on a per-project or per-file basis.
If you want to attain the highest level of performance, try our custom performance-tuning service. We'll use our expertise in embedded systems to make your program run faster. We'll even custom-write compiler optimizations based on our evaluation of your application. Our team of skilled experts recently worked with Freescale to help them publish benchmark results that were over 32% faster than the results of their nearest competition.
Broad processor support
Ensuring fast time to market depends critically on keeping up with the availability of the latest target hardware. Our frequent releases and tight ties to silicon vendors mean that our compilers typically support new hardware before it's even commercially available.
Green Hills Compilers are part of a complete embedded development solution that includes the MULTI Integrated Development Environment, INTEGRITY real-time operating system, and our hardware debug probe, the Green Hills Probe. Our products provide every tool you might needs, all seamlessly integrated to save you valuable time.
Prevent new bugs
To help you avoid common programming mistakes, the Green Hills Compilers provide automated enforcement of clean coding conventions. You can enforce industry standards like the MISRA 2004 guidelines, or you can enforce our own set of guidelines: GHS Standard Mode. GHS Standard Mode is based on our long history of successfully deployed software and on our collaboration with customers who have achieved the same high level of reliability. We use GHS Standard Mode internally to develop our own tools.
Find bugs automatically
DoubleCheck, Green Hills Software's integrated static analyzer, allows you to identify programming errors even before running your program. DoubleCheck is more reliable than traditional code reviews and can find bugs that may never show up during regular system testing. Because DoubleCheck is part of the Green Hills Compilers, there's no setup cost to enabling it. Simply set an option. DoubleCheck reviews source code each time the code is compiled. DoubleCheck runs much faster than traditional static analysis tools so that developers can always leave it on.
Run-time error checking complements DoubleCheck by finding bugs that cannot be identified by static analysis alone. Especially onerous bugs may remain hidden for a long time before failure. With run-time error checking, you're alerted to the cause of the problem when it happens. Eliminating a bug is often trivial when you're looking directly at it.
Reduce your processor costs
You don't always need a faster processor to meet increasing performance requirements. Our superior compiler optimizations can be tuned to get the most out of whatever chip you use. How much money would you save if you could use a lower-cost processor to meet the same real-time requirements? Or if you could release a new product without having to produce a new hardware platform to run it on? Not only will improving your application's performance save you money on the processor itself, lower-cost processors operate at lower clock rates and require less power and cooling. Longer battery life makes your product better and cheaper at the same time.
Reduce your memory costs
Green Hills Compiler optimizations reduce your memory costs by reducing the size of your executable. Most programs see at least 10% improvement relative to the GNU Compiler.
Our team of cost reduction experts can help you to reduce your memory and processor requirements without sacrificing features. We have reduced customer memory usage by over 30% and have improved performance by over 300%.