[test-suite] Add prototypes to functions in Olden and MiBench

[arichardson]

Summary

When calling a function without a prototype it gets called using the
variadic calling convention. For a small number of arguments this is
usually the same as calling a non-variadic function. However, on
architectures such as CHERI the variadic and non-variadic calling
conventions use different registers (even for less than 4 arguments) and
therefore the code will crash at runtime.

This change is required in order to run the test suite on CHERI (and
possibly other architectures that have different variadic and non-variadic
calling conventions). It also allows compiling this code with
-Werror=strict-prototypes, which is currently the default on the
CI for CHERI in order to avoid these runtime crashes.

[MatzeB]

As far as I can tell, those are correct C programs.

Using this old K&R style definitions:

void func(x,y)
  int x;
  int y;
{ ... }

does indeed give you a different calling convention than

void func(int x, int y) { ... }

and the former is supposed to work with a void func() declaration.

This style of coding is luckily getting scarce. But it is still allowed by C and there is software out there written this way. From that perspective I consider it a good thing that we have some code like this in the llvm test-suite so we get some testing.

May I propose a compromise here: Leave the benchmarks as is but add a cmake variable (similar to the existing TEST_SUITE_BENCHMARKING_ONLY) allowing users to optionally skip benchmarks using K&R style functions.

[arichardson]

Calling K&R functions is not a problem. It is fine to use them as long as there is a declaration with the parameter types in the LLVM IR and not just an declare i32 @foo(...). The problem is that we are calling functions that don't have a declaration and therefore the compiler assumes that it is a variadic function call. This leads to runtime crashes on our CHERI platform.

They are not necessarily correct C programs since they include undefined behaviour

[MatzeB]

In D42576#990020, @arichardson wrote:

Calling K&R functions is not a problem. It is fine to use them as long as there is a declaration with the parameter types in the LLVM IR and not just an declare i32 @foo(...). The problem is that we are calling functions that don't have a declaration and therefore the compiler assumes that it is a variadic function call. This leads to runtime crashes on our CHERI platform.

They are not necessarily correct C programs since they include undefined behaviour

To the best of my knowledge, this is perfectly fine (even in C11):

/* a.c: */
short bar(x)
  short x;
{
    return x;
}

/* b.c: */
short bar();
int main(void) {
    bar(42);
}

If a compiler cannot handle it then it has a bug and I'm not in favor of changing the benchmarks/tests because of a bug. On the contrary: We need tests to uncover such bugs!

I agree with you that llvm representing prototype-less functions and variadic functions the same is unfortunate (and appears to only allow implementations where they are the same at a first glance?). Maybe ask clang or llvm mailing lists for comments...

[arichardson]

Your example will work for x86 and probably ARM, but as far as I can tell it is up to the ABI which calling convention should be used for functions without prototypes.
For us these calling conventions are incompatible since the variadic one will pass arguments on the stack instead of in registers so if the target function is not actually variadic this will cause it to read garbage from undefined registers. While it *should* work if there is only zero or one arguments it is not guaranteed to work with more than 1.

I also found that apparently WebAssembly does the same: https://github.com/WebAssembly/tool-conventions/issues/16 and it also causes issues with functions without prototypes (https://bugs.llvm.org/show_bug.cgi?id=35385)

[MatzeB]

In D42576#1003045, @arichardson wrote:

Your example will work for x86 and probably ARM, but as far as I can tell it is up to the ABI which calling convention should be used for functions without prototypes.
For us these calling conventions are incompatible since the variadic one will pass arguments on the stack instead of in registers so if the target function is not actually variadic this will cause it to read garbage from undefined registers. While it *should* work if there is only zero or one arguments it is not guaranteed to work with more than 1.

I also found that apparently WebAssembly does the same: https://github.com/WebAssembly/tool-conventions/issues/16 and it also causes issues with functions without prototypes (https://bugs.llvm.org/show_bug.cgi?id=35385)

I am repeating myself:

• This is perfectly legal C, so I consider it a legitimate test.
• If your compiler cannot handle it (even if it is llvms fault) then you need to fix the compiler not the test.
• I am fine to add a cmake option to skip this test for cases where it doesn’t work.

[arichardson]

Okay I won't bother submitting further improvements that actually allow us to run the test suite without crashing.

[dschuff]

I'll just add that what we do in WebAssembly right now for unprototyped functions is to codegen them using the fixed-arg calling convention; at link-time if there are any mismatches between the definition and any calls, then the program has UB, and the resulting WebAssembly module will be invalid. I think this currently has the problem that if the definition does turn out to be vararg, then we have generated an invalid module even though the program is correct (I consider that a bug or shortcoming in our toolchain though). In any case, we do aim to support correct programs with prototypeless functions. If the test suite has non-vararg cases where there are mismatches between the callsites and/or the definition (I have seen that in some other test/benchmark suites), then even though that works on most X86 and ARM ABIs that I know of it's still UB and I'd be in favor of removing it from LLVM's test suite.

[MatzeB]

In D42576#1003685, @dschuff wrote:

I'll just add that what we do in WebAssembly right now for unprototyped functions is to codegen them using the fixed-arg calling convention; at link-time if there are any mismatches between the definition and any calls, then the program has UB, and the resulting WebAssembly module will be invalid. I think this currently has the problem that if the definition does turn out to be vararg, then we have generated an invalid module even though the program is correct (I consider that a bug or shortcoming in our toolchain though). In any case, we do aim to support correct programs with prototypeless functions. If the test suite has non-vararg cases where there are mismatches between the callsites and/or the definition (I have seen that in some other test/benchmark suites), then even though that works on most X86 and ARM ABIs that I know of it's still UB and I'd be in favor of removing it from LLVM's test suite.

• My reading of the C standard is that using a prototype less declaration and defining that as a vararg functions is invalid in C. If you find bugs in this area we should fix them.
• This patch simply removes all prototype less functions which is not fine.
• The llvm IR coming out of clang appears to mark all prototype less functions as varargs which from what I suspect makes it impossible to implement varargs different from prototype-less functions. But that is a problem in clang/IR, it doesn't change the fact that the tests are valid C.

[hfinkel]

In D42576#1003695, @MatzeB wrote:

In D42576#1003685, @dschuff wrote:

I'll just add that what we do in WebAssembly right now for unprototyped functions is to codegen them using the fixed-arg calling convention; at link-time if there are any mismatches between the definition and any calls, then the program has UB, and the resulting WebAssembly module will be invalid. I think this currently has the problem that if the definition does turn out to be vararg, then we have generated an invalid module even though the program is correct (I consider that a bug or shortcoming in our toolchain though). In any case, we do aim to support correct programs with prototypeless functions. If the test suite has non-vararg cases where there are mismatches between the callsites and/or the definition (I have seen that in some other test/benchmark suites), then even though that works on most X86 and ARM ABIs that I know of it's still UB and I'd be in favor of removing it from LLVM's test suite.

• My reading of the C standard is that using a prototype less declaration and defining that as a vararg functions is invalid in C. If you find bugs in this area we should fix them.

We should eliminate UB from the test suite. I'm also not sure that this is UB, however. Looking at http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf section 6.5.2.2 on Function calls, it seems that this is okay so long as the types actually used to define the function agree with the types used for the call (after default promotion rules are applied). The most relevant text seems to be in p6, " If the number of arguments does not equal the number of parameters, the behavior is undefined. If the function is defined with a type that includes a prototype, and either the prototype ends with an ellipsis (, ...) or the types of the arguments after promotion are not compatible with the types of the parameters, the behavior is undefined."

• This patch simply removes all prototype less functions which is not fine.
• The llvm IR coming out of clang appears to mark all prototype less functions as varargs which from what I suspect makes it impossible to implement varargs different from prototype-less functions. But that is a problem in clang/IR, it doesn't change the fact that the tests are valid C.

Agreed.

[hfinkel]

In D42576#1003710, @hfinkel wrote:

In D42576#1003695, @MatzeB wrote:

In D42576#1003685, @dschuff wrote:

I'll just add that what we do in WebAssembly right now for unprototyped functions is to codegen them using the fixed-arg calling convention; at link-time if there are any mismatches between the definition and any calls, then the program has UB, and the resulting WebAssembly module will be invalid. I think this currently has the problem that if the definition does turn out to be vararg, then we have generated an invalid module even though the program is correct (I consider that a bug or shortcoming in our toolchain though). In any case, we do aim to support correct programs with prototypeless functions. If the test suite has non-vararg cases where there are mismatches between the callsites and/or the definition (I have seen that in some other test/benchmark suites), then even though that works on most X86 and ARM ABIs that I know of it's still UB and I'd be in favor of removing it from LLVM's test suite.

• My reading of the C standard is that using a prototype less declaration and defining that as a vararg functions is invalid in C. If you find bugs in this area we should fix them.

We should eliminate UB from the test suite. I'm also not sure that this is UB, however. Looking at http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf section 6.5.2.2 on Function calls, it seems that this is okay so long as the types actually used to define the function agree with the types used for the call (after default promotion rules are applied). The most relevant text seems to be in p6, " If the number of arguments does not equal the number of parameters, the behavior is undefined. If the function is defined with a type that includes a prototype, and either the prototype ends with an ellipsis (, ...) or the types of the arguments after promotion are not compatible with the types of the parameters, the behavior is undefined."

@rsmith, is this right?

• This patch simply removes all prototype less functions which is not fine.
• The llvm IR coming out of clang appears to mark all prototype less functions as varargs which from what I suspect makes it impossible to implement varargs different from prototype-less functions. But that is a problem in clang/IR, it doesn't change the fact that the tests are valid C.

Agreed.

[sunfish]

There is also an upside to not supporting unprototyped functions. Not only did people writing C in the distant past before prototypes not know what we know today about what it takes to have reasonably robust C code, but leaving C code unmaintained for decades is the opposite of what it takes to have reasonably robust C code, so such code is in double trouble. Obliging people who have unmaintained C codebases to either maintain them or forego using them on new platforms is a positive outcome. It's within reason to assign a variety of relative weights to that outcome, relative to the other outcomes.

[dschuff]

• My reading of the C standard is that using a prototype less declaration and defining that as a vararg functions is invalid in C. If you find bugs in this area we should fix them.

Interesting, I'll look closer at that. We haven't gotten any complaints about it so far.

• This patch simply removes all prototype less functions which is not fine.

Sorry, in case I wasn't clear, I agree that these tests are valid C and we should not change them.

• The llvm IR coming out of clang appears to mark all prototype less functions as varargs which from what I suspect makes it impossible to implement varargs different from prototype-less functions. But that is a problem in clang/IR, it doesn't change the fact that the tests are valid C.

Yeah, you can sort of cheat because in C, vararg functions must have at least one non-vararg parameter (at least AFAIK no C standard implemented by Clang allows that). So you can tell a real vararg function declare i32 @foo(i32, ...) from a non-prototype function declare i32 @foo(...). I suspect that only works for C though.

MultiSource/Benchmarks/MiBench/automotive-bitcount/conio.h

 #define UNXCONIO__H
 
 #include <stdio.h>
 #include <unistd.h>
 
 #define echo_on()  term_option(0)
 #define echo_off() term_option(1)
 
-int term_option();
-int getch();
+int term_option(int);
+int getch(void);
 
 #endif /* UNXCONIO__H */

MultiSource/Benchmarks/MiBench/automotive-susan/susan.c

usage()
   exit(0);
 }
 
 /* }}} */
 /* {{{ get_image(filename,in,x_size,y_size) */
 
 /* {{{ int getint(fp) derived from XV */
 
-int getint(fd)
-  FILE *fd;
+int getint(FILE *fd)
 {
   int c, i;
   char dummy[10000];
 
   c = getc(fd);
   while (1) /* find next integer */
   {
     if (c=='#')    /* if we're at a comment, read to end of line */
while (1) {
     if (c<'0' || c>'9') break;
   }
 
   return (i);
 }
 
 /* }}} */
 
-void get_image(filename,in,x_size,y_size)
-  char           filename[200];
-  unsigned char  **in;
-  int            *x_size, *y_size;
+void get_image(char filename[200], unsigned char  **in, int *x_size, int *y_size)
 {
 FILE  *fd;
 char header [100];
 int  tmp;
 
 #ifdef FOPENB
   if ((fd=fopen(filename,"rb")) == NULL)
 #else
if (fread(*in,1,*x_size * *y_size,fd) == 0)
     exit_error("Image %s is wrong size.\n",filename);
 
   fclose(fd);
 }
 
 /* }}} */
 /* {{{ put_image(filename,in,x_size,y_size) */
 
-put_image(filename,in,x_size,y_size)
-  char filename [100],
-       *in;
-  int  x_size,
-       y_size;
+put_image(char filename[100], char *in, int x_size, int y_size)
 {
 FILE  *fd;
 
 #ifdef FOPENB
   if ((fd=fopen(filename,"wb")) == NULL) 
 #else
   if ((fd=fopen(filename,"w")) == NULL) 
 #endif
     exit_error("Can't output image%s.\n",filename);
 
   fprintf(fd,"P5\n");
   fprintf(fd,"%d %d\n",x_size,y_size);
   fprintf(fd,"255\n");
   
   if (fwrite(in,x_size*y_size,1,fd) != 1)
     exit_error("Can't write image %s.\n",filename);
 
   fclose(fd);
 }
 
 /* }}} */
 /* {{{ int_to_uchar(r,in,size) */
 
-int_to_uchar(r,in,size)
-  uchar *in;
-  int   *r, size;
+int_to_uchar(int *r, uchar *in, int size)
 {
 int i,
     max_r=r[0],
     min_r=r[0];
 
   for (i=0; i<size; i++)
     {
       if ( r[i] > max_r )
         max_r=r[i];
       if ( r[i] < min_r )
         min_r=r[i];
     }
 
   /*printf("min=%d max=%d\n",min_r,max_r);*/
 
   max_r-=min_r;
 
   for (i=0; i<size; i++)
     in[i] = (uchar)((int)((int)(r[i]-min_r)*255)/max_r);
 }
 
 /* }}} */
 /* {{{ setup_brightness_lut(bp,thresh,form) */
 
-void setup_brightness_lut(bp,thresh,form)
-  uchar **bp;
-  int   thresh, form;
+void setup_brightness_lut(uchar **bp, int thresh, int form)
 {
 int   k;
 float temp;
 
   *bp=(unsigned char *)malloc(516);
   *bp=*bp+258;
 
   for(k=-256;k<257;k++)
   {
     temp=((float)k)/((float)thresh);
     temp=temp*temp;
     if (form==6)
       temp=temp*temp*temp;
     temp=100.0*exp(-temp);
     *(*bp+k)= (uchar)temp;
   }
 }
 
 /* }}} */
 /* {{{ susan principle */
 
 /* {{{ susan_principle(in,r,bp,max_no,x_size,y_size) */
 
-susan_principle(in,r,bp,max_no,x_size,y_size)
-  uchar *in, *bp;
-  int   *r, max_no, x_size, y_size;
+susan_principle(uchar *in, int *r, uchar *bp, int max_no, int x_size, int y_size)
 {
 int   i, j, n;
 uchar *p,*cp;
 
   memset (r,0,x_size * y_size * sizeof(int));
 
   for (i=3;i<y_size-3;i++)
     for (j=3;j<x_size-3;j++)
for (j=3;j<x_size-3;j++)
       if (n<=max_no)
         r[i*x_size+j] = max_no - n;
     }
 }
 
 /* }}} */
 /* {{{ susan_principle_small(in,r,bp,max_no,x_size,y_size) */
 
-susan_principle_small(in,r,bp,max_no,x_size,y_size)
-  uchar *in, *bp;
-  int   *r, max_no, x_size, y_size;
+susan_principle_small(uchar *in, int *r, uchar *bp, int max_no, int x_size, int y_size)
 {
 int   i, j, n;
 uchar *p,*cp;
 
   memset (r,0,x_size * y_size * sizeof(int));
 
   max_no = 730; /* ho hum ;) */
 

 
 /* }}} */
 
 /* }}} */
 /* {{{ smoothing */
 
 /* {{{ median(in,i,j,x_size) */
 
-uchar median(in,i,j,x_size)
-  uchar *in;
-  int   i, j, x_size;
+uchar median(uchar *in, int i, int j, int x_size)
 {
 int p[8],k,l,tmp;
 
   p[0]=in[(i-1)*x_size+j-1];
   p[1]=in[(i-1)*x_size+j  ];
   p[2]=in[(i-1)*x_size+j+1];
   p[3]=in[(i  )*x_size+j-1];
   p[4]=in[(i  )*x_size+j+1];
int p[8],k,l,tmp;
   return( (p[3]+p[4]) / 2 );
 }
 
 /* }}} */
 /* {{{ enlarge(in,tmp_image,x_size,y_size,border) */
 
 /* this enlarges "in" so that borders can be dealt with easily */
 
-enlarge(in,tmp_image,x_size,y_size,border)
-  uchar **in;
-  uchar *tmp_image;
-  int   *x_size, *y_size, border;
+enlarge(uchar **in, uchar *tmp_image, int *x_size, int *y_size, int border)
 {
 int   i, j;
 
   for(i=0; i<*y_size; i++)   /* copy *in into tmp_image */
     memcpy(tmp_image+(i+border)*(*x_size+2*border)+border, *in+i* *x_size, *x_size);
 
   for(i=0; i<border; i++) /* copy top and bottom rows; invert as many as necessary */
   {
int   i, j;
   *x_size+=2*border;  /* alter image size */
   *y_size+=2*border;
   *in=tmp_image;      /* repoint in */
 }
 
 /* }}} */
 /* {{{ void susan_smoothing(three_by_three,in,dt,x_size,y_size,bp) */
 
-void susan_smoothing(three_by_three,in,dt,x_size,y_size,bp)
-  int   three_by_three, x_size, y_size;
-  uchar *in, *bp;
-  float dt;
+void susan_smoothing(int three_by_three, uchar *in, float dt, int x_size,
+                     int y_size, uchar *bp)
 {
 /* {{{ vars */
 
 float temp;
 int   n_max, increment, mask_size,
       i,j,x,y,area,brightness,tmp,centre;
 uchar *ip, *dp, *dpt, *cp, *out=in,
       *tmp_image;

 
 /* }}} */
 
 /* }}} */
 /* {{{ edges */
 
 /* {{{ edge_draw(in,corner_list,drawing_mode) */
 
-edge_draw(in,mid,x_size,y_size,drawing_mode)
-  uchar *in, *mid;
-  int x_size, y_size, drawing_mode;
+edge_draw(uchar *in, uchar *mid, int x_size, int y_size, int drawing_mode)
 {
 int   i;
 uchar *inp, *midp;
 
   if (drawing_mode==0)
   {
     /* mark 3x3 white block around each edge point */
     midp=mid;

 }
 
 /* }}} */
 /* {{{ susan_thin(r,mid,x_size,y_size) */
 
 /* only one pass is needed as i,j are decremented if necessary to go
    back and do bits again */
 
-susan_thin(r,mid,x_size,y_size)
-  uchar *mid;
-  int   *r, x_size, y_size;
+susan_thin(int *r, uchar *mid, int x_size, int y_size)
 {
 int   l[9], centre, nlinks, npieces,
       b01, b12, b21, b10,
       p1, p2, p3, p4,
       b00, b02, b20, b22,
       m, n, a, b, x, y, i, j;
 uchar *mp;
 

 
 /* }}} */
       }
 }
 
 /* }}} */
 /* {{{ susan_edges(in,r,sf,max_no,out) */
 
-susan_edges(in,r,mid,bp,max_no,x_size,y_size)
-  uchar *in, *bp, *mid;
-  int   *r, max_no, x_size, y_size;
+susan_edges(uchar *in, int *r, uchar *mid, uchar* bp, int max_no, int x_size,
+            int y_size)
 {
 float z;
 int   do_symmetry, i, j, m, n, a, b, x, y, w;
 uchar c,*p,*cp;
 
   memset (r,0,x_size * y_size * sizeof(int));
 
   for (i=3;i<y_size-3;i++)
for (j=4;j<x_size-4;j++)
         }
       }
     }
 }
 
 /* }}} */
 /* {{{ susan_edges_small(in,r,sf,max_no,out) */
 
-susan_edges_small(in,r,mid,bp,max_no,x_size,y_size)
-  uchar *in, *bp, *mid;
-  int   *r, max_no, x_size, y_size;
+susan_edges_small(uchar *in, int *r, uchar *mid, uchar* bp, int max_no,
+                  int x_size, int y_size)
 {
 float z;
 int   do_symmetry, i, j, m, n, a, b, x, y, w;
 uchar c,*p,*cp;
 
   memset (r,0,x_size * y_size * sizeof(int));
 
   max_no = 730; /* ho hum ;) */

 
 /* }}} */
 
 /* }}} */
 /* {{{ corners */
 
 /* {{{ corner_draw(in,corner_list,drawing_mode) */
 
-corner_draw(in,corner_list,x_size,drawing_mode)
-  uchar *in;
-  CORNER_LIST corner_list;
-  int x_size, drawing_mode;
+corner_draw(uchar *in, CORNER_LIST corner_list, int x_size, int drawing_mode)
 {
 uchar *p;
 int   n=0;
 
   while(corner_list[n].info != 7)
   {
     if (drawing_mode==0)
     {
else
       n++;
     }
   }
 }
 
 /* }}} */
 /* {{{ susan(in,r,sf,max_no,corner_list) */
 
-susan_corners(in,r,bp,max_no,corner_list,x_size,y_size)
-  uchar       *in, *bp;
-  int         *r, max_no, x_size, y_size;
-  CORNER_LIST corner_list;
+susan_corners(uchar *in, int *r, uchar *bp, int max_no, CORNER_LIST corner_list,
+              int x_size, int y_size)
 {
 int   n,x,y,sq,xx,yy,
       i,j,*cgx,*cgy;
 float divide;
 uchar c,*p,*cp;
 
   memset (r,0,x_size * y_size * sizeof(int));
 

 free(cgx);
 free(cgy);
 
 }
 
 /* }}} */
 /* {{{ susan_quick(in,r,sf,max_no,corner_list) */
 
-susan_corners_quick(in,r,bp,max_no,corner_list,x_size,y_size)
-  uchar       *in, *bp;
-  int         *r, max_no, x_size, y_size;
-  CORNER_LIST corner_list;
+susan_corners_quick(uchar *in, int *r, uchar *bp, int max_no,
+                    CORNER_LIST corner_list, int x_size, int y_size)
 {
 int   n,x,y,i,j;
 uchar *p,*cp;
 
   memset (r,0,x_size * y_size * sizeof(int));
 
   for (i=7;i<y_size-7;i++)
     for (j=7;j<x_size-7;j++) {

MultiSource/Benchmarks/MiBench/consumer-lame/lame.c

imp3= lame_encode_buffer(gfp,in_buffer[0],in_buffer[1],576*gfp->mode_gr,
         mp3buf,size);
   mf_samples_to_encode = save;
   return imp3;
 }
 
 
 #ifdef __FreeBSD__
 # include <floatingpoint.h>
+fp_except_t fpgetmask(void);
+fp_except_t fpsetmask(fp_except_t);
 #endif
 
 
 /* initialize mp3 encoder */
 void lame_init(lame_global_flags *gfp)
 {
 
   /*

MultiSource/Benchmarks/MiBench/consumer-typeset/externs.h

typedef struct back_end_rec {
   void (*PrintGraphicObject)(OBJECT x);
   void (*DefineGraphicNames)(OBJECT x);
   void (*SaveTranslateDefineSave)(OBJECT x,FULL_LENGTH xdist,FULL_LENGTH ydist);
   void (*PrintGraphicInclude)(OBJECT x,FULL_LENGTH colmark,FULL_LENGTH rowmark);
   void (*LinkSource)(OBJECT name, FULL_LENGTH llx, FULL_LENGTH lly,
     FULL_LENGTH urx, FULL_LENGTH ury);
   void (*LinkDest)(OBJECT name, FULL_LENGTH llx, FULL_LENGTH lly,
     FULL_LENGTH urx, FULL_LENGTH ury);
-  void (*LinkCheck)();
+  void (*LinkCheck)(void);
 } *BACK_END;
 
 
 /*@::object types@************************************************************/
 /*                                                                           */
 /*  OBJECT, TOKEN AND OTHER TYPES inhabiting type(x) and predefined(x)       */
 /*                                                                           */
 /*  Key letters in the adjacent comment indicate where the tag is legal:     */

 extern  void    FontPageUsed(OBJECT face);
 extern  BOOLEAN   FontNeeded(FILE *fp);
 
 /*****  z38.c   Character Mappings    **************************************/
 extern  MAP_VEC   MapTable[];
 extern  MAPPING    MapLoad(OBJECT filename, BOOLEAN recoded);
 extern  FULL_CHAR MapCharEncoding(FULL_CHAR *str, MAPPING m);
 extern  FULL_CHAR *MapEncodingName(MAPPING m);
-extern  void    MapPrintEncodings();
+extern  void    MapPrintEncodings(void);
 extern  void    MapEnsurePrinted(MAPPING m, int curr_page);
 extern  void    MapPrintPSResources(FILE *fp);
 extern  OBJECT    MapSmallCaps(OBJECT x, STYLE *style);
 extern  BOOLEAN    MapIsLowerCase(FULL_CHAR ch, MAPPING m);
 
 
 /*****  z39.c   String Handler        **************************************/
 #define     AsciiToFull(x)  ( (FULL_CHAR *) (x) )

MultiSource/Benchmarks/MiBench/office-ispell/CMakeLists.txt

 set(PROG office-ispell)
 list(APPEND CPPFLAGS -Dconst=)
+list(APPEND CPPFLAGS -DGENERATE_LIBRARY_PROTOS=1)
 list(APPEND LDFLAGS -lm)
 set(RUN_OPTIONS -a -d ${CMAKE_CURRENT_SOURCE_DIR}/americanmed+)
 set(STDIN_FILENAME ${CMAKE_CURRENT_SOURCE_DIR}/large.txt)
 llvm_multisource()

MultiSource/Benchmarks/MiBench/office-ispell/term.c

  *
  */
 
 #include "config.h"
 #include "ispell.h"
 #include "proto.h"
 #include "msgs.h"
 #include <signal.h>
+#include <sys/types.h>
+#include <sys/wait.h>
 
 #if defined(__GLIBC__) || defined(__FreeBSD__) || defined(__APPLE__)
 /* Use termios under at least glibc */
 #include <termios.h>
 #define USE_TERMIOS
 #ifndef USG
 #define USG
 #endif

 static struct sgttyb  osbuf;
 #ifdef TIOCSLTC
 static struct ltchars ltc;
 static struct ltchars oltc;
 #endif
 #endif
 #endif
 static int    termchanged = 0;
-static SIGNAL_TYPE  (*oldint) ();
-static SIGNAL_TYPE  (*oldterm) ();
+static SIGNAL_TYPE  (*oldint) (int);
+static SIGNAL_TYPE  (*oldterm) (int);
 #ifdef SIGTSTP
-static SIGNAL_TYPE  (*oldttin) ();
-static SIGNAL_TYPE  (*oldttou) ();
-static SIGNAL_TYPE  (*oldtstp) ();
+static SIGNAL_TYPE  (*oldttin) (int);
+static SIGNAL_TYPE  (*oldttou) (int);
+static SIGNAL_TYPE  (*oldtstp) (int);
 #endif
 
 void terminit ()
     {
 #ifdef TIOCPGRP
     int     tpgrp;
 #else
 #ifdef TIOCGPGRP

MultiSource/Benchmarks/MiBench/security-blowfish/bftest.c

 /* This has been a quickly hacked 'ideatest.c'.  When I add tests for other
  * RC2 modes, more of the code will be uncommented. */
 
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include "blowfish.h"
 
-int test();
+int test(void);
 
 char *bf_key[2]={
   "abcdefghijklmnopqrstuvwxyz",
   "Who is John Galt?"
   };
 
 /* big endian */
 BF_LONG bf_plain[2][2]={

MultiSource/Benchmarks/MiBench/telecomm-gsm/toast.h

 #include <sys/types.h>
 #include <sys/stat.h>
 
 #include <stdio.h>
 #include <ctype.h>
 #include <signal.h>
 
 #include <errno.h>
-#ifndef HAS_ERRNO_DECL
+#if !defined(errno) && !defined(HAS_ERRNO_DECL)
    extern int errno;
 #endif
 
 #ifdef  HAS_LIMITS_H
 #include <limits.h>
 #endif
 
 #ifdef  HAS_FCNTL_H

MultiSource/Benchmarks/MiBench/telecomm-gsm/toast.c

static char * suffix P2((name, suf), char *name, char * suf)
   size_t slen = strlen(suf);
 
   if (!slen || nlen <= slen) return (char *)0;
   name += nlen - slen;
   return memcmp(name, suf, slen) ? (char *)0 : name;
 }
 
 
-static void catch_signals P1((fun), SIGHANDLER_T (*fun) ()) 
+static void catch_signals P1((fun), SIGHANDLER_T (*fun) (int))
 {
 #ifdef  SIGHUP
   signal( SIGHUP,   fun );
 #endif
 #ifdef  SIGINT
   signal( SIGINT,   fun );
 #endif
 #ifdef  SIGPIPE

MultiSource/Benchmarks/Olden/bh/defs.h

 
 
 #include "stdinc.h"
 
 #define THREEDIM
 #include "vectmath.h"
 
 #define MAX_NUM_NODES 64
-extern double fabs();
-
 
 /*
  * BODY and CELL data structures are used to represent the tree:
  *
  *         +-----------------------------------------------+
  * root--> | CELL: mass, pos, quad, /, o, /, /, /, /, o, / |
  *         +---------------------------|--------------|----+
  *                                     |              |

MultiSource/Benchmarks/Olden/bh/newbh.c

 #define global  /* nada */
 
 #include "defs.h"
 #include "code.h"
 
 
 int nbody;
 
-double sqrt(), xrand(), my_rand();
-real pow();
+double xrand(double xl, double xh, double r);
+double my_rand(double seed);
 extern icstruct intcoord(bodyptr p, treeptr t);
 extern int BhDebug;
 
 void computegrav(treeptr t, int nstep);
 nodeptr maketree(bodyptr btab, int nbody, treeptr t, int nsteps, int proc);
 void vp(bodyptr q, int nstep);
 
 void gravstep(real rsize, nodeptr rt, bodyptr p, int nstep, real dthf);
 void ptree(nodeptr n, int level);
 
 typedef struct {
   vector cmr;
   vector cmv;
   bodyptr list;
    bodyptr tail;
 } datapoints;
 
 
-bodyptr testdata();
+bodyptr testdata(void);
 datapoints uniform_testdata(int proc, int nbody, int seedfactor);
 void stepsystem(treeptr t, int nstep);
-treeptr old_main();
+treeptr old_main(void);
 void my_free(nodeptr n);
 bodyptr ubody_alloc(int p);
 bodyptr movebodies(bodyptr list, int proc);
 void freetree(nodeptr n);
 void freetree1(nodeptr n);
 int old_subindex(icstruct ic, int l);
 
-int dealwithargs();
-int error();
+int dealwithargs(int, char**);
+int error(const char*);
 
 int arg1;
 
 /* Used to setup runtime system, get arguments-- see old_main */
 int main(int argc, char **argv) {
   treeptr t;
 
   /* Initialize the runtime system */
   dealwithargs(argc, argv);
   chatting("nbody = %d, numnodes = %d\n", nbody, NumNodes);
 
   t = old_main();
   return 0;
 }
 
 /* global! */
 
 /* Main routine from original program */
-treeptr old_main() {
+treeptr old_main(void) {
   real tnow;
   real tout;
   int i, nsteps, nprocs;
   treeptr t;
   bodyptr bt0,p;
   long t1, t2;
   vector cmr, cmv;
   bodyptr prev=NULL;

  * TESTDATA: generate Plummer model initial conditions for test runs,
  * scaled to units such that M = -4E = G = 1 (Henon, Hegge, etc).
  * See Aarseth, SJ, Henon, M, & Wielen, R (1974) Astr & Ap, 37, 183.
  */
 
 #define MFRAC  0.999    /* mass cut off at MFRAC of total */
 
 /* don't use this unless it is fixed on random numbers, &c */
-bodyptr testdata()
+bodyptr testdata(void)
 {
     real rsc, vsc, r, v, x, y;
     vector cmr, cmv;
     bodyptr head, p, prev;
     register int i;
     double temp, t1;
     double seed = 123.0;
     register int k;

 }
 
 /*
  * LOAD.C: routines to create body-tree.  Public routines: maketree().
  * Copyright (c) 1991, Joshua E. Barnes, Honolulu, HI.
  *      It's free because it's yours.
  */
 
-double ceil();
-
 bodyptr body_alloc(int p, real p0, real p1, real p2, real v0, real v1, real v2, real a0, real a1, real a2, real mass, bodyptr ob);
 bodyptr ubody_alloc(int p);
 cellptr cell_alloc(int p);
 
 typedef struct {
   nodeptr tp;
   int num;
 } dtstruct;

 
 /*
  * INTCOORD: compute integerized coordinates.
  * Returns: TRUE unless rp was out of bounds.
  */
 /* called from expandbox */
 icstruct intcoord1(double rp0, double rp1, double rp2, treeptr t)
 {
-    double xsc, floor();
+    double xsc;
     /*double rmin,rsize;*/
     icstruct ic;
 
 /***
    rmin = t->rmin[0];
    rsize = t->rsize;
     chatting("rp0 %f,rmin %f,rsize %f\n",rp0,rmin,rsize);
 ***/

 /*
  * INTCOORD: compute integerized coordinates.
  * Returns: TRUE unless rp was out of bounds.
  */
 
 icstruct intcoord(bodyptr p, treeptr t)
 {
     register double xsc;
-    double floor();
     icstruct ic;
     register real rsize;
     vector pos;
 
 
     ic.inb = TRUE;          /* use to check bounds      */
     rsize = t->rsize;
 
icstruct intcoord(bodyptr p, treeptr t)
 
     /*chatting("Returning %d:%d:%d, ic.inb=%d\n",ic.xp[0],ic.xp[1],ic.xp[2],ic.inb);*/
     return (ic);
 }
 
 
 int ic_test(bodyptr p, treeptr t)
 {
-    double xsc, rsize, floor();
+    double xsc, rsize;
     int result;
     vector pos;
 
     result = TRUE;          /* use to check bounds      */
 
     pos[0] = Pos(p)[0];
     pos[1] = Pos(p)[1];
     pos[2] = Pos(p)[2];

 /*
  * SUBINDEX: determine which subcell to select.  Rolled intcoord & subindex together.
  */
 
 int subindex(bodyptr p, treeptr t , int l)
 {
     register int i, k;
     register real rsize;
-    double xsc, floor();
+    double xsc;
     int xp[NDIM];
     vector pos;
 
     pos[0] = Pos(p)[0];
     pos[1] = Pos(p)[1];
     pos[2] = Pos(p)[2];
 
     rsize = t->rsize;

MultiSource/Benchmarks/Olden/bh/stdinc.h

  * only.  Note: this slightly kinky substitution is used to so that one
  * need not declare something to be void before using it.
  */
 
 #ifndef TORONTO
 #define void int
 #endif
 
-/*
- * PROC, IPROC, RPROC: pointers to procedures, integer functions, and
- * real-valued functions, respectively.
- */
-
-typedef void (*proc)();
-typedef int (*iproc)();
-typedef real (*rproc)();
 
 /*
  * PRIVATE: declare something to be local to a file.
  * PERMANENT: declare something to be permanent data within a function.
  */
 
 #define private     static
 #define permanent static

MultiSource/Benchmarks/Olden/bh/util.c

 
 void exit(int);
 
 /* random:
  * return a random number, which is also the next seed.
  */
 double my_rand(double seed)
 {
-    double  t = A*seed  + 1; 
-    double floor();
+    double  t = A*seed  + 1;
 
 
     seed = t - (M * floor(t / M));
     return seed;
 
 } /* end of random */
 
 /*

MultiSource/Benchmarks/Olden/bisort/proc.h

 /* For copyright information, see olden_v1.0/COPYRIGHT */
 
 /* ========== PROCEDURE TYPES/NUMS ================== */
 
 
-HANDLE *RandTree();
+HANDLE *RandTree(int n, int seed, int node, int level);
 
-void SwapValue();
-void SwapValLeft();
-void SwapValRight();
-int Bimerge();
-int Bisort();
+void SwapValue(HANDLE *l, HANDLE *r);
+void SwapValLeft(HANDLE *l, HANDLE *r, HANDLE *ll, HANDLE *rl, int lval, int rval);
+void SwapValRight(HANDLE *l, HANDLE *r, HANDLE *ll, HANDLE *rl, int lval, int rval);
+int Bimerge(HANDLE *root, int spr_val, int dir);
+int Bisort(HANDLE *root, int spr_val, int dir);
 int dealwithargs(int argc, char *argv[]);

MultiSource/Benchmarks/Olden/em3d/make_graph.h

 /* For copyright information, see olden_v1.0/COPYRIGHT */
 
 /* make_graph.h
  *
  * By:  Martin C. Carlisle
  * Date: Feb 23, 1994
  *
  */
 
 /* initialize graph returns a structure with pointers to lists of e and h
  * nodes.
  */ 
-graph_t *initialize_graph();
+graph_t *initialize_graph(void);

MultiSource/Benchmarks/Olden/em3d/make_graph.c

void do_all(table_t *table, int groupname, int nproc,
   if (nproc > 1) {
     do_all(table,groupname+nproc/2,nproc/2,func,groupsize);
     do_all(table,groupname,nproc/2,func,groupsize);
   } else {
     func(table,groupname);
   }
 }
 
-graph_t *initialize_graph() {
+graph_t *initialize_graph(void) {
   table_t *table;
   graph_t *retval;
   int i,j,blocksize;
   int groupsize;
 
   table = (table_t *)malloc(sizeof(table_t));
   retval = (graph_t *)malloc(sizeof(graph_t));
 

MultiSource/Benchmarks/Olden/em3d/util.h

 
 /* return a random number from 0 to range-1 */
 int gen_number(int range);
 
 /* return a random number in [-range+1,range-1] */
 int gen_signed_number(int range);
 
 /* Generate a double from 0.0 to 1.0 */
-double gen_uniform_double();
+double gen_uniform_double(void);
 
 /* Return 1, percent percent of the time and 0 otherwise */
 int check_percent(int percent);

MultiSource/Benchmarks/Olden/em3d/util.c

 /* For copyright information, see olden_v1.0/COPYRIGHT */
 
 #include <stdlib.h>
 #include "em3d.h"
 
 #ifdef TORONTO
 #define chatting printf
 #endif
 
 #ifdef __MINGW32__
 #define srand48(x) srand(x)
 #define lrand48() (rand() << 16 | rand())
 #define drand48() (1.0*rand() / RAND_MAX)
 #else
-extern double drand48();
+extern double drand48(void);
 #endif
 
 static int percentcheck=0,numlocal=0;
 
 /* initialize the random number generator for a particular processor */
 void init_random(int seed)
 {
   srand48(seed);

MultiSource/Benchmarks/Olden/power/compute.c

 static double P=1.0;
 static double Q=1.0;
 
 
 /*----------------------------------------------------------------------*/
 /* Leaf optimization procedures                 */
 
 void optimize_node (double pi_R, double pi_I);
-double find_g ();
-double find_h ();
+double find_g (void);
+double find_h (void);
 double find_gradient_f (double pi_R, double pi_I, double* gradient);
 double find_gradient_g (double* gradient);
 double find_gradient_h (double* gradient);
 void find_dd_grad_f (double pi_R, double pi_I, double* dd_grad);
 double make_orthogonal (double* v_mod, double* v_static);
 
 
 void Compute_Tree(Root r) {

MultiSource/Benchmarks/Olden/power/power.h

typedef struct leaf {
   double pi_R;
   double pi_I;
 } *Leaf;  /* sizeof(struct leaf) = 32 bytes */
 
 /* Prototypes */
 Root build_tree(void);
 Lateral build_lateral(int i, int num);
 Branch build_branch(int i, int j, int num);
-Leaf build_leaf();
+Leaf build_leaf(void);
 
 void Compute_Tree(Root r);
 Demand Compute_Lateral(Lateral l, double theta_R, double theta_I,
                        double pi_R, double pi_I);
 Demand Compute_Branch(Branch b, double theta_R, double theta_I,
                        double pi_R, double pi_I);
 Demand Compute_Leaf(Leaf l, double pi_R, double pi_I);
 

MultiSource/Benchmarks/Olden/voronoi/defines.h

 #define SIZE ((uptrint) sizeof(struct edge_rec))
 #define ANDF ((uptrint) 4*sizeof(struct edge_rec) - 1)
 
 #define sym(a) ((QUAD_EDGE) (((uptrint) (a)) ^ 2*SIZE))
 #define rot(a) ((QUAD_EDGE) ( (((uptrint) (a) + 1*SIZE) & ANDF) | ((uptrint) (a) & ~ANDF) ))
 #define rotinv(a) ((QUAD_EDGE) ( (((uptrint) (a) + 3*SIZE) & ANDF) | ((uptrint) (a) & ~ANDF) ))
 #define base(a) ((QUAD_EDGE) ((uptrint a) & ~ANDF))
 
-QUAD_EDGE alloc_edge();
+QUAD_EDGE alloc_edge(void);
 void free_edge(QUAD_EDGE e);
-QUAD_EDGE makeedge();
-void splice();
-void swapedge();
-void deleteedge();
-QUAD_EDGE build_delaunay_triangulation();
+QUAD_EDGE makeedge(VERTEX_PTR origin, VERTEX_PTR destination);
+void splice(QUAD_EDGE, QUAD_EDGE);
+void swapedge(QUAD_EDGE);
+void deleteedge(QUAD_EDGE);
+QUAD_EDGE build_delaunay_triangulation(VERTEX_PTR tree, VERTEX_PTR extra);
 EDGE_PAIR build_delaunay(VERTEX_PTR tree, VERTEX_PTR extra);
 EDGE_PAIR do_merge(QUAD_EDGE ldo, QUAD_EDGE ldi, QUAD_EDGE rdi, QUAD_EDGE rdo);
-QUAD_EDGE connect_left();
-QUAD_EDGE connect_right();
+QUAD_EDGE connect_left(QUAD_EDGE a, QUAD_EDGE b);
+QUAD_EDGE connect_right(QUAD_EDGE a, QUAD_EDGE b);
 
 int myrandom(int seed);
-void zero_seen();
-QUAD_EDGE pop_edge();
+void zero_seen(struct EDGE_STACK *my_stack, QUAD_EDGE edge);
+QUAD_EDGE pop_edge(struct EDGE_STACK *x);
 
 #define drand(seed) (((double) (seed=myrandom(seed))) / (double) 2147483647)
 
 extern VERTEX_PTR *vp ;
 extern struct VERTEX *va ;
 extern EDGE_PTR *next ;
 extern VERTEX_PTR *org ;
 extern int num_vertices, num_edgeparts, stack_size ;

MultiSource/Benchmarks/Olden/voronoi/newvor.c

QUAD_EDGE build_delaunay_triangulation(tree,extra)
      VERTEX_PTR tree,extra;
 {
     EDGE_PAIR retval;
 
     retval=build_delaunay(tree,extra);
     return retval.left;
 }
 
-VERTEX_PTR get_low(tree)
-     register VERTEX_PTR tree;
+VERTEX_PTR get_low(VERTEX_PTR tree)
 {
   register VERTEX_PTR temp;
   while((temp=tree->left)) tree=temp;             /* 3% load penalty */
   return tree;
 }
 
 /****************************************************************/
 /*  Recursive Delaunay Triangulation Procedure              */

 }
 
 
 
 /****************************************************************/
 /*  Geometric primitives                                    */
 /****************************************************************/
 
-BOOLEAN incircle(a,b,c,d)
+BOOLEAN incircle(VERTEX_PTR a, VERTEX_PTR b, VERTEX_PTR c, VERTEX_PTR d)
      /* incircle, as in the Guibas-Stolfi paper. */
-     VERTEX_PTR a,b,c,d;
 {
   double adx, ady, bdx, bdy, cdx, cdy, dx, dy, anorm, bnorm, cnorm, dnorm;
   double dret ;
   VERTEX_PTR loc_a,loc_b,loc_c,loc_d;
 
   /*if (flag) printf("incircle: 0x%x,0x%x,0x%x,0x%x\n",a,b,c,d);*/
   loc_d = d; 
   dx = X(loc_d); dy = Y(loc_d); dnorm = NORM(loc_d); 
BOOLEAN ccw(VERTEX_PTR a, VERTEX_PTR b, VERTEX_PTR c) {
   dret = (xa-xc)*(yb-yc) - (xb-xc)*(ya-yc);
   /*if (flag) printf("ccw: %f\n", dret);*/
   return dret > 0.0;
 }
 
 /****************************************************************/
 /*  Quad-edge manipulation primitives                       */
 /****************************************************************/
-QUAD_EDGE makeedge(origin, destination)
-VERTEX_PTR origin, destination;
+QUAD_EDGE makeedge(VERTEX_PTR origin, VERTEX_PTR destination)
 {
     register QUAD_EDGE temp, ans;
     temp =  alloc_edge();
     ans = temp;
 
     onext(temp) = ans;
     orig(temp) = origin;
     temp = (QUAD_EDGE) ((uptrint) temp+SIZE);
QUAD_EDGE e;
     /*printf("end swapedge\n");*/
 }
 
 /****************************************************************/
 /*  The Merge Procedure. */
 /****************************************************************/
 /*#define valid(l) ccw(orig(basel), dest(l), dest(basel))*/
 
-int valid(l,basel)
-     QUAD_EDGE l,basel;
+int valid(QUAD_EDGE l, QUAD_EDGE basel)
 {
   register VERTEX_PTR t1,t2,t3;
 
   /*printf("valid:0x%x,0x%x\n",l,basel);*/
 
   t1=orig(basel);
   t3=dest(basel);
 
   t2=dest(l);   /* <------------------------------------------------- 11 % load penalty */
   return ccw(t1,t2,t3);
 }
 
-void dump_quad(ptr)
-     QUAD_EDGE ptr;
+void dump_quad(QUAD_EDGE ptr)
 {
   int i;
   QUAD_EDGE j;
   VERTEX_PTR v;
 
   ptr = (QUAD_EDGE) ((uptrint) ptr & ~ANDF);
   printf("Entered DUMP_QUAD: ptr=0x%p\n",ptr);
   for (i=0; i<4; i++)

 
 
 #define CONST_m1 10000
 #define CONST_b 31415821
 #define RANGE 100
 
 int loop = 0, randum = 1, filein = 0 , fileout = 1, statistics = 0; 
 
-void in_order(tree)
-     VERTEX_PTR tree;
+void in_order(VERTEX_PTR tree)
 {
   VERTEX_PTR tleft, tright;
   double x, y;
 
   if (!tree) {
     printf("NULL\n");
     return;
   }
struct EDGE_STACK *allocate_stack(int num_vertice)
 
   num_edgeparts = 12*num_vertice;
   my_stack = (struct EDGE_STACK *)malloc(sizeof(struct EDGE_STACK));
   my_stack->elts = (QUAD_EDGE *)malloc(num_edgeparts * sizeof(QUAD_EDGE));
   my_stack->stack_size = num_edgeparts/2;
   return my_stack;
 }
 
-void free_all(cont,my_stack)
-     int cont;
-     struct EDGE_STACK *my_stack;
+void free_all(int cont, struct EDGE_STACK *my_stack)
 {
   free(my_stack->elts);
   free(my_stack);
 }
 
 struct get_point get_points(int n, double curmax,int i, int seed,
                             int processor, int numnodes)
 {
void push_ring(struct EDGE_STACK *stack, QUAD_EDGE edge) {
   if (seen(nex) == 0) {
      seen(nex) = 1;
      push_edge(stack, nex);
   }
   nex = onext(nex);
     }
 }
 
-void push_nonzero_ring(stack, edge)
-     struct EDGE_STACK *stack;
-     QUAD_EDGE edge;
+void push_nonzero_ring(struct EDGE_STACK *stack, QUAD_EDGE edge)
 {
   QUAD_EDGE nex;
   nex = onext(edge);
   while (nex != edge) {
     if (seen(nex) != 0) {
       seen(nex) = 0;
       push_edge(stack, nex);
     }

MultiSource/Benchmarks/Olden/voronoi/output.c

 /* For copyright information, see olden_v1.0/COPYRIGHT */
 
 #include "defines.h"
 #include <stdio.h>
 
-extern struct VEC2 V2_sum();
-extern struct VEC2 V2_sub();
-extern struct VEC2 V2_times();
-extern double V2_cprod();
-extern struct VEC2 V2_cross();
-extern double V2_dot();
-extern double V2_magn();
+extern struct VEC2 V2_sum(struct VEC2 u, struct VEC2 v);
+extern struct VEC2 V2_sub(struct VEC2 u, struct VEC2 v);
+extern struct VEC2 V2_times(double c, struct VEC2 v);
+extern double V2_cprod(struct VEC2 u, struct VEC2 v);
+extern struct VEC2 V2_cross(struct VEC2 v);
+extern double V2_dot(struct VEC2 u, struct VEC2 v);
+extern double V2_magn(struct VEC2 u);
 
 /****************************************************************/
 /*  Voronoi Output Routines */
 /****************************************************************/
 
-void plot_dedge(p1, p2)
-VERTEX_PTR p1, p2;
+void plot_dedge(VERTEX_PTR p1, VERTEX_PTR p2)
 {
   double x1,x2,y1,y2;
 
   x1=X(p1);
   y1=Y(p1);
   x2=X(p2);
   y2=Y(p2);
   /* plots a Delaunay-triangulation edge on your favorite device. */
   printf("Dedge %g %g %g %g \n",(float) x1, (float) y1,
    (float) x2, (float) y2);
 }
 
-void plot_vedge(p1, p2)
-     struct VEC2 p1, p2;
+void plot_vedge(struct VEC2 p1, struct VEC2 p2)
 {
   /* plots a Voronoi-diagram edge on your favorite device. */
 
   /* Some of the values that are printed can become negative nans
    * and may, depending on the operating system and libc version,
    * either be printed as '-nan' or 'nan'.
    *
    * The following code ensures we always get positive nans, which