Conference turris::languages

This sounds rather confused...

The situation is:

    - For VMS, there is a standard object file format, which is described
      in the VMS documentation.  This applies only to the actual layout
      of data in an object file, not what the sequences of instructions
      might do.  There is also a calling standard described in the VMS
      documentation which is common across all languages and specifies
      how routines should be called, parameters passed, etc.  This sounds
      sort of like what you're interested in, but it doesn't have anything
      to do with "U-Codes".  VMS has a dumper for object files (ANAL/OBJECT.)

    - For MIPS, there written "standards" for both of these things, though
      they are less complete than the VMS doc. in some areas.  The
      object file format is extended coff, so it is relatively standard.
      There is also a dumper for objects.

    - The MIPS-based compilers (cc, c89, f77 through 2.10, pas), can generate
      intermediate files known as "ucode" files.  These files are specific
      to the MIPS compiler system, and as far as I know, these aren't
      documented anywhere for public consumption.  On MIPS, the "ucode
      loader" can merge several ucode files to allow optimization together.

    - For VAX, there is a code generator known as the "VAX Code Generator",
      or VCG.  This compiler back end takes it's own intermediate language
      and symbol table and generates code and object files in association
      with a front end.  This code generator is used by VAX PL/I, VAX C,
      VAX Ada and VAX SCAN.  (This is described in the book "Engineering
      a Compiler" by Cutler, Heinen and MacLaren.)  VAX FORTRAN, VAX Pascal,
      etc., each have their own optimizer/code generator for VAX.  The VCG
      has a somewhat documented interface, but it is in maintenance mode
      at this point, and there are certainly no resources available for
      doing new products based on it.

    - DEC has been in the process of building a new rehostable/retargettable
      compiler system known as GEM.  This compiler system currently
      generates code for MIPS, Alpha (I'll presume it's OK to talk about
      Alpha since K.O. demoed one at the shareholder's meeting and the
      fact that it seems to be all over the papers...), and is starting
      work on another target (which is not VAX.)

Basically, each compiler (or compiler system) has it's own intermediate
representation that may be more or less documented, and each compiler
system has it's own support/communication issues, though it isn't clear
exactly what you're trying to accomplish.  It sounds like you're interested
in VAX, which means that your options are:

    - generating a "higher level" language (e.g. C) as output

    - trying to interface to something public like gcc

    - doing your own code generation

    - picking up a (totally unsuppored) copy of the VCG (if it is
      even available to that degree)

    Thanks,
    	I'll look around the doc. you've mentioned and check.
    YH

>	We're now working on a project which will generate object codes,
>	ans thus it can be linked with other object codes generated by
>	C, Basic, or whatever. 

	You may be interested in note 301 in this conference.  It appears
	you are writing a compiler, or a compiler-like package, and you
	may thus be able to take advantage of the GEM compiler support
	package.  (I would try contacting the author of 301.1 offline.)