Readme For

Open Research Compiler Release 1.0.0


Jan 15, 2002




How to download pre-built compilers and install

Cross compilation

How to download and build compiler source

Known problems and limitations

How to report bugs and get support

Appendix A Brief descriptions on Pro64 compiler

Appendix B Doing the build

Appendix C Bug list





The ORC compilers, based on the SGI Pro64™* compiler suite, include optimizing compilers and runtime support for C, C++, and Fortran90. These compilers produce code that follows the Linux/IA-64 ABI.  This means that objects produced by the ORC compilers can link with objects produced by other Linux/IA-64 compliant compilers such as RedHat/Cygnus gcc and g++.


The latest information and update for the ORC compilers can be found in  The packages included in this distribution represent a work in progress.


Please send problem reports to web site.


The compilers include all optimizations performed by the Pro64 compiler. For a more detailed description of existing Pro64 highlights and optimizations, please refer to the readme file of the Pro64 compilers release. A portion of that is included as Appendix A.


A number of research infrastructure features and Itanium processor family optimizations have been added. The infrastructure features include:

- Region-based optimization framework, the notion of region is introduced into CG and many phases are made aware of and performed under it.

- Parameterized machine model, it encapsulate micro-architectural details and can be easily reconfigured to study the impact of different configurations.

- Support of profiling feedback at code generator, some common profiling support are provided to allow researchers to construct various profiling, e.g. path profiling, value profiling, memory profiling, etc.


The newly designed Itanium processor family specific optimizations include:

- If-conversion (predication)

- Control and data speculation with recovery code generation

- Predicate analysis to support predicate-aware data flow analysis

- Global Instruction scheduling integrated with template selection


The ORC specific features replace those provided by the Pro64. When the ORC compilers are invoked, the optimizations mentioned above will be performed by default at O2 or above, and can be turned off separately or entirely. Other optimizations in the Pro64 compilers will still be performed. (Note: profile feedback at the code generator provided by ORC does not replace the profiling scheme provided in Pro64. It is designed to complement and extend the original scheme.)


There is a FAQ for the ORC compiler. More information can be found there.


How to download pre-built compilers and install


Download following file from this URL:


The ORC compilers, like the Pro64 compilers assume to be operating under an NUE environment.  Information about NUE can be found at:


To install the ORC compilers:


For installation under NUE on an IA32 machine:

  % nue 

  # tar zxvf orc-1.0.0.tgz

  # ./



Note that the nue command will put you under your home directory in NUE, which may not be your regular home directory. You should make sure that the ORC binaries are under a directory that is accessible under NUE.


For installation on an Itaniummachine:




You can verify your installation by doing a simple hello world test under NUE or the Itanium machine:


  %cat hello.c

  #include <stdio.h>




    printf("hello world\n");




  %orcc hello.c


  hello world!



Cross compilation


Some users might find it more convenient to do cross compilation on an IA32 machine under NUE and run the binaries on an Itanium machine. To do that, we recommend that you generate the object files (.os) under NUE, transfer the objects files to the Itanium machines, link the .os, produce the binary there and run it, as follows:

1. At IA32 side:

  [IA32]% orcc -c hello.c -o hello.o

  [IA32]% ftp IA64               (transfer hello.o to machine IA64)

2. At IA64 side:

  [IA64]% orcc hello.o -o hello

  [IA64]% ../hello

  hello world!



How To Download And Build Compiler Source


Download the ORC source:


Install the ORC source:


  % cd download-directory

  % tar zxvf orc-1.0.0-sources.tgz

  % ./ (You will be prompted for license information and installation directory)


The ORC source will be added to the original Pro64 source. Some of the original source file and makefiles will be overwritten.


Build the compiler under IA32 machine




We used the following version of gcc to compile the binaries included in our rpm:


   gcc version 2.95.2 19991024 (release)


Build optimized compiler


If compile time is important to you, you can build the compiler (or parts of the components) with optimized option and with all verification turned off. This is the default setting in the source package. If the default configuration has been changed, you can do as following:

1. modify file osprey1.o/Makefile.gsetup and set the value of the variable OPTIMIZER to what you want under DEBUG and NODEBUG branch (say, -O2 under NODEBUG branch).

2. You need to make sure the value of the variable BUILD_OPTIMIZE in each sub-makefiles is DEBUG or NODEBUG, e.g. if you want to control be build, you need to check osprey1.0/targia32_ia64_nodebug/be/Makefile for setting BUILD_OPTIMIZE to DEBUG or NODEBUG

3. #undef Is_True_On in osprey1.0/common/ipfe_targ_info/access/ekapi_ia64.h


Build non-optimized compiler


If you need to debug one or more of the compiler components, you can turn on the verification capability of the compiler and build it with debug option by changing the corresponding files. For example, if you want to debug the backend and the code generator, you can set the variable BUILD_OPTIMIZE in both osprey1.0/targia32_ia64_nodebug/be/Makefile and

osprey1.0/targia32_ia64_nodebug/cg/Makefile to DEBUG. This will allow you to have and with symbol debugging capability while the other components in optimized format.


Building other components with debug option will be similar. 

Detailed description of the actual build of each individual components is the same as described in the readme file in 0.13 release of Pro64. Please see Appendix B for reference.



Known Problems and limitations



We have tested the compilers to the best of our knowledge. The following are known problems or areas that we have not done extensive testing:


1. With IPA turned on, some of the CPU2000 integer benchmarks failed.

2. We have not tested IPA with CPU2000 fp benchmarks. 

A full description of each known problem is listed in Appendix C.



How to report bugs and get support



Bugs can be reported via Sourceforge in the ORC Support Request tracker. In order to respond quickly to your problem, we request the following information be entered in the bug report by using the "Submit New" form in the tracker:


From the pull-down list, select one item that best describes the bug on your judgment. 
Currently the list is as follow:

Assertion failure
Compilation crashed
Correctness defect
Feature request
Performance defect


Please select V1.0.0eval at this moment.


Please give a brief description of the problem in this field.

Detailed description

Compilation options.
Commands to execute application if it's an runtime error.
Symptom descriptions.

Files if any that will help repeat the problem:

Source code. It would be better that the file is preprocessed. This would reduce the problem caused by included files in the code.
Other input files such as data files needed by the application.

For issues with installation and usage of the compiler, we request that users first go through the mail alias This will help us respond to the issues in a more timely fashion without dropping anyone. We also strongly suggest you to sign onto the ipf-orc-support@lists.sourceforge. For issues related to the Pro64 compiler, please go to mailing list


Appendix A


The following is extracted from the readme file of the Pro64 compilers:

Language highlights:


C compatible with gcc

C++ compatible g++

Fortran90 with Fortran95 extensions

Optimization highlights:


Software pipelining: 

At the -O2 and -O3 optimization levels the compilers will use the IA-64 software pipelining instructions. 

At the -O3 level a more powerful data dependence analysis will be performed. 

Scalar optimization: 


A partial list of optimizations performed include

Code motion

Constant propagation

Dead code elimination

Expression simplification

Common subexpression elimination

Strength reduction

Appendix B


Doing the Build


Before doing the build make sure you have permissions

in the tree where you will be doing the builds. You

can do this by:


       %chown -R your_username osprey1.0


The compilers suite contains CROSS compiler components and IA-64




CROSS compiler components


The following components are CROSS components in that

they will be built by IA-32 tools and run on IA-32 platforms

but they produce IA-64 code. They are built by doing a make

in the corresponding

osprey1.0/targia32_ia64_nodebug directories.



A sample makefile has been provided for your convenience

to build all of the CROSS components listed below.

To do a full build of the CROSS components:


          %make build -f Make.cross





You must NOT be in the NUE environment when running this

makefile (Make.cross).




Each component may also be built separately as described




Compiler Drivers


/usr/bin/orcc  -- C   compiler driver

/usr/bin/orCC  -- C++ compiler driver

/usr/bin/orc++  -- C++ compiler driver (alternate name)

/usr/bin/orf90 -- Fortran90 compiler driver


These are links to



To build the driver:

% cd osprey1.0/targia32_ia64_nodebug/driver.nue; gmake



C Front-End




is the C compiler front-end. We have upgraded it

from gcc version 2.95 19990929 to gcc version

2.96 20000530.


To build:


% cd osprey1.0/targia32_ia64_nodebug/gccfe; gmake



C++ Front-End




is the C++ compiler front-end. We have upgraded

it from g++ version 2.96 20000111 (experimental)

to g++ version 2.96 20000605 (experimental).


To build:


% cd osprey1.0/targia32_ia64_nodebug/g++fe; gmake



Fortran 90 Front-End




is the Fortran90 compiler front-end.





Is the message catalog file for it:


To build:


% cd osprey1.0/targia32_ia64_nodebug/crayf90; gmake


NOTE: mfef90 does not build at this time because it

      needs an IA-32 version of f90 to compile parts

      of itself. While SGI has a prototype of such

      a compiler, it is good enough only to compile

      what is needed and thus we are not making it

      available. Mfef90 contains only code

      developed by SGI.









are the backend components


To build:


%cd osprey1.0/targia32_ia64_nodebug/be ; gmake





Code Generator




is the code generator


To build:

%cd osprey1.0/targia32_ia64_nodebug/cg ; gmake




Global Optimizer




is the global optimizer. It is invoked when orcc

is run with -O2.


To build:

%cd osprey1.0/targia32_ia64_nodebug/wopt ; gmake




Loop Nest Optimizer




is the loop nest optimizer. It is invoked when

orcc is run with -O3.


To build:

%cd osprey1.0/targia32_ia64_nodebug/lno ; gmake




Stand-Alone Inliner




is the stand-alone inliner


To build:

%cd osprey1.0/targia32_ia64_nodebug/lw_inline; gmake


(lw_inline is built which is renamed to inline)




Interprocedural analysis optimizer




is the interprocedural analysis optimizer


To build:

%cd osprey1.0/targia32_ia64_nodebug/ipa; gmake




Interprocedural analysis optimizer (local summary phase)





is the interprocedural analysis optimizer

(local summary phase).


To build:

%cd osprey1.0/targia32_ia64_nodebug/ipl; gmake




Interprocedural analysis linker driver (ipa_link)




is the interprocedural analysis linker driver


To build:

%cd osprey1.0/targcygnus_ia32_ia64; ./CONFIGURE ; gmake


ld-new is created under the targcygnus_ia32_ia64/ld

directory. It is renamed to ipa_link in the INSTALL





Itanium processor target description module




is the Itanium processor target description



To build:

%cd osprey1.0/targia32_ia64_nodebug/targ_info; gmake




WHIRL (the orcc intermediate language) to C converter





is the WHIRL (the orcc intermediate language)

to C converter.


To build:

%cd osprey1.0/targia32_ia64_nodebug/whirl2c; gmake




WHIRL to Fortran converter





is the WHIRL (the orcc intermediate language)

to Fortran converter.



To build:

%cd osprey1.0/targia32_ia64_nodebug/whirl2f; gmake




WHIRL to ASCII converter




is the WHIRL (the orcc intermediate language)

to ASCII converter utility.


To build:

%cd osprey1.0/targia32_ia64_nodebug/ir_tools; gmake








The following components are IA-64 native libraries.

in that they will be built by the IA-64 tools. As

a result, you must do the builds under the NUE



To run under NUE, you will need to install the NUE

environment. Information about NUE can be found at:



To get into the NUE environment, simply type:




A sample makefile has been provided for your convenience

to build all of the CROSS components listed below.

To do a full build of the CROSS components:


     %make build -f Make.NUE.lib


Each library may also be built separately

by doing a make in the corresponding

osprey1.0/targia64 directories as described below.





is the Fortran90 runtime library:


To build:

%cd osprey1.0/targia64/include; gmake

%cd osprey1.0/targia64/libfortran; gmake





is the Fast Fortran I/O runtime library:


To build:

%cd osprey1.0/targia64/include; gmake

%cd osprey1.0/targia64/libu; gmake






is the SGI math library:


To build:

%cd osprey1.0/targia64/libmsgi; gmake





is the SGI math library (vector version):


To build:

%cd osprey1.0/targia64/libmv; gmake





To build:

%cd osprey1.0/targia64/libgcc; gmake





To build:

%cd osprey1.0/targia64/libstdc++; gmake





is the SGI feedback instrumentation library


To build:

%cd osprey1.0/targia64/libinstr; gmake





is the ORC feedback instrumentation library


To build:

%cd osprey1.0/targia64/libcginstr; gmake





is the SGI implementation for turning on



To build:

%cd osprey1.0/targia64/init; gmake






Are already provided under:







Appendix C


The following is a full list of known problems found during testing of the evaluation release binaries:

  1. Core dumped running 300.twolf, 255.vortex with -O2 -IPA or -O3 -IPA, Segmentation fault.

  2. Core dumped running 197.parser and 175.vpr with -O3 -IPA, Segmentation fault.

  3. Link error in compiling 252.eon at both -O2 -IPA and -O3 -IPA, ipa_link couldn't read symbols.

  4. Wrong result (ref) for 186.crafty with -O3 -IPA binary.

  5. Compiler error in compiling 253.perlbmk at both -O2 -IPA and -O3 -IPA.

  6. Aborted running gcc with both -O2 -IPA or -O3 -IPA, Too long to complete.

Copyright and Legal Information

Intel and Itanium are trademarks or registered trademarks of Intel Corporation or its subsidiaries in the United States and other countries.

SGI and Pro64 are trademarks or registered trademarks of Silicon Graphics, Inc.
* Other names and brands may be claimed as the property of others