Compiler offers custom support - Brief Article

Electronics Times, July 24, 2000

EXCLUSIVE BY CHRIS EDWARDS

Software tools company Tasking is developing an architecture for its next-generation compiler that will let designers modify how it generates code so that support for custom instructions can be built in and used automatically.

Launching the compiler next year, the company is defining a plug-in interface that will break the process of code generation down so that it can be handled by a set of communicating software modules.

Most compilers are divided into two halves. The front-end parses the source code, which may be C, C or some other language, generating an intermediate-code language. This intermediate code is independent of the target processor but is written at a level that makes it easy to generate the final assembly code.

At this point, the code generation engine steps in and performs operations such as selecting the right instructions, deciding which pieces of data can be stored in registers between instructions and the order in which instructions are processed.

The company's plug-in approach will make it possible to take out an existing instruction selector and replace it with one that contains additional code to trap pieces of intermediate code and map them to custom instructions that might have been added to a configurable processor or DSP.

Peter Murman, MD of engineering at Tasking in the Netherlands, said: "For the intermediate code format, we have gone through a lot of existing standards and research in this area. We have come up with an approach that is highly tuned to DSPs and VLIW architecture."

The company aims to publish the plug-in interface and the intermediate code representation so that developers can produce their own compiler modules.

"A relatively small number of developers will be looking at system-on- chip applications that use customisable cores," said Murman. "We will supply a standard set of plug-ins. If the instruction selector doesn't do what they want, they will be able to replace it.

"Without this approach, the only way that customers could add support for custom instructions would be to ask us to add code to the compiler.

"This plug-in approach is good for companies that don't want to take the risk of seeing their optimisations turn up in a mainstream compiler from Tasking. They can consider their plug-ins as a form of software IP."

The company has developed what it calls a target description language (TDL) that lets developers express the operations performed by each instruction. The TDL code would be used to help automate the process of building code generators.

"What we see is that a number of chip manufacturers have created syntactic and semantic databases already," said Murman. The databases use a standard way to represent instruction behaviour in a way that can be mapped to the TDL.

"We can come out with a decent compiler in less time than we see today. It wouldn't be the end of the development: some things would be hand- crafted," said Murman.

"For example, register allocation is highly dependent on the number of registers in an architecture. You can't derive the best approach to use from just a database."