[fa.info-vax] Digital's VAX C and variable argument lists

info-vax@ucbvax.ARPA (02/22/85)

From: nolan%eludom.DEC@decwrl.ARPA  (CHRIS 381-2080)













         There have been a number of messages recently about  a  "bug"



    in  the current VAX C compiler from Digital.  Some of the data has



    been true, most has been false.  Let me  try  to  put  the  record



    straight here.







         The issue is of the shape and the position  of  the  argument



    block  passed  to  C  functions.   Under  all  currently  released



    versions of VAX C, namely V1.0 through V1.5, the argument block is



    a  contiguous  block  of  memory  on  the  stack pointed to by the



    hardware Argument Pointer, the AP.  This is exactly  the  same  as



    other Digital VAX Languages.  However, VAX C, under these released



    versions,  is  in  technical  violation  of  the  VAX/VMS  Calling



    Standard,  since doubles and structures are passed by value in the



    argument block and that any  arguments  may  be  modified  by  the



    compiler  generated  code.   (Note,  however, that an exception is



    made to the calling standard for  C,  so  that  values  of  length



    greater  than  one  longword can be passed in the argument block.)



    This becomes a problem if the  caller  of  the  C  function  is  a



    FORTRAN  program, since the C code can modify a permanent argument



    block which is supposed to be unmodifyable.  Living  in  a  common



    language  environment  as  VAX C does, presents some problems that



    other stand alone C compilers in other environments do not have to



    deal with.







         We are currently in field test with  VAX  C  V2.0.   In  this



    development  cycle  we  attempted to correct the above problem and



    adhere to the VAX/VMS Calling Standard, at least  as  far  as  not



    modifying  the  argument block is concerned.  An additional reason



    for the change was an attempt to improve the use of registers with



    arguments  in  the called function.  Thus we elected to move those



    arguments whose address was taken via the & (address-of)  operator



    onto  the  stack  as  an  auto  variable.   This  modification was



    released to the field in the first field  test  distribution.   We



    did  not  realize  at  that time how many programs relied on being



    able to walk a contiguous block of memory by taking the address of



    the  first  argument and flying from there.  It became "painfully"



    obvious to us very quickly that this modification was causing  our



    customers significant problems and was removed in the second field



    test distribution two months later.  VAX C V2.0 when  released  to



    the  field  as  a  product  will  use  the same method of argument



    passing as did VAX C V1.n, namely a  contiguous  block  of  memory



    accessed via the Argument Pointer.







         As a future implementation  note  we  reserve  the  right  to



    change this method of argument passing in a future release.  As of



    VAX C V2.0,  we  will  support  the  VARARGS  macro  package  from



    UNIX(*),  which  provides  macros  and  some run time functions to



    permit  the  walking  of   a   variable   argument   list.    This



    functionality is curently part of the ANSI C draft standard and we



    will support it future releases of VAX C, starting with V2.0.   We



    recommend  that  this  be the method of handling variable argument



    lists, as this allows us to optimize argument passing to functions



    without  removing  the  ability of the programmer to ascertain how



    many  arguments  were  passed  and  to  walk  the  argument   list



    accordingly.







    Chris Nolan,



    VAX C Development,



    Digital Equipment Corporation.







    * UNIX is a trade mark of AT&T Bell Laboratories.