Re: DSP-C Compilers; fixedpoint data types

Holger Keding <>
27 May 1999 23:25:47 -0400

          From comp.compilers

Related articles
DSP-C Compilers; fixedpoint data types (Christopher Glaeser) (1999-05-21)
Re: DSP-C Compilers; fixedpoint data types (Holger Keding) (1999-05-27)
| List of all articles for this month |

From: Holger Keding <>
Newsgroups: comp.compilers
Date: 27 May 1999 23:25:47 -0400
Organization: Aachen University of Technology, ISS
References: 99-05-099
Keywords: C, DSP, arithmetic

Christopher Glaeser wrote:

> DSP-C extensions are designed to support DSP hardware features, most
> notably fixedpoint types, and other DSP features (see
> )
> What is the current state of implementation in the industry? In
> particular, I'd be interested to know which C compilers currently
> support fixedpoint data types.

From the document you mention I assume you refer to real fixed-point
types (not just fractional or integer), i.e. you want a portable type,
an arbitrary wordlength, integer wordlength, different number
representations etc. - well as far as I know there are a few
experimental compiler systems that support fixed-point data types,
e.g. the Fixed-C language and Fixed-C DSP compiler FCC presented by
Jersak at last ICSPAT'98. The Fixed-C language is disigned to be
portable. The compiler has to map the fixed-point data types to the
registers of the target, i.e. embedding them into the appropriate
register types, adjusting the location of the binary point, inserting
shift operations where necessary, etc. (you'll find an abstract of
this paper at:

Also, there are a couple of approaches (in academia and industry) to
tackle the problem at C level (using a target independent, bit-true
C-like language) and from there to a specific target. The idea is
first to determine the fixed-point requirements for each
operand/operation and afterwards (automatically) transform this
functionality to an integer based C code that can be fed into today's
compilers. I'm currently working on a fixed-point design environment
that first takes you from the floating-point C level to the
fixed-point C level (using a C++ based, bit-true modeling language
similar to the one described in Jersak's paper). As a second step we
transform this fixed-point model to a target implementation, e.g. a
DSP C compiler. The C compilers we use for programmable devices only
support integer types, so in this second step of our approach we map
the fixed-point data types to integer types. So if you start at the
fixed-point level, you pretty much have the same effect as programming
for a compiler that takes fixed-point types, too - with the difference
that the mapping to integer types takes place *before* the
compiler. (some more detailed stuff:

Greetinx, Holger

  Holger Keding, DSP Tools Group

  Aachen University of Technology
  Integrated Signal Processing Systems
  Templergraben 55
  D-52056 Aachen, Germany
  Phone : ++49 241 80-7884 E-Mail:
  Fax : ++49 241 8888-195 URL:

Post a followup to this message

Return to the comp.compilers page.
Search the comp.compilers archives again.