hard-params.c

这是完整的gcc源代码

/* Everything you wanted to know about your machine and C compiler,
   but didn't know who to ask.
   Author: Steven Pemberton, CWI, Amsterdam; [e-mail]
   Bugfixes and upgrades gratefully received.

   Name changed to `hard-params' by Richard Stallman, April 89.
   xmalloc function defined, Richard Stallman, June 89.
   Avoid macro in #include, Richard Stallman, Jan 90.
   Undef CHAR_BIT, etc., if defined in stdio.h, Richard Stallman, Aug 90.
   In EPROP, don't compare a with old if bad is already set.  Stallman, May 91.
   Don't handle long doubles if -DNO_LONG_DOUBLE.  Stallman, May 91.

   Copyright (c) 1988, 1989 Steven Pemberton, CWI, Amsterdam.
   All rights reserved.

   COMPILING
   With luck and a following wind, just the following will work:
	cc hard-params.c -o hard-params

   If your compiler doesn't support:		add flag:
	signed char (eg pcc)			-DNO_SC
	unsigned char				-DNO_UC
	unsigned short and long			-DNO_UI
	signal(), or setjmp/longjmp()		-DNO_SIG

   Try it first with no flags, and see if you get any errors - you might be
   surprised. (Most non-ANSI compilers need -DNO_SC, though.)
   Some compilers need a -f flag for floating point.

   Don't use any optimisation flags: the program may not work if you do.
   Though "while (a+1.0-a-1.0 == 0.0)" may look like "while(1)" to an
   optimiser, to a floating-point unit there's a world of difference.

   Some compilers offer various flags for different floating point
   modes; it's worth trying all possible combinations of these.

   Add -DID=\"name\" if you want the machine/flags identified in the output.

   SYSTEM DEPENDENCIES
   You may possibly need to add some calls to signal() for other sorts of
   exception on your machine than SIGFPE, and SIGOVER.  See lines beginning
   #ifdef SIGxxx in main() (and communicate the differences to me!).

   If your C preprocessor doesn't have the predefined __FILE__ macro, and
   you want to call this file anything other than hard-params.c, change the
   #define command for __FILE__ accordingly.  If it doesn't accept macro
   names at all in #include lines, order a new C compiler. While you're
   waiting for it to arrive, change the last #include in this file (the
   last but one line) accordingly.

   OUTPUT
   Run without argument to get the information as English text.  If run
   with argument -l (e.g. hard-params -l), output is a series of #define's for
   the ANSI standard limits.h include file, excluding MB_MAX_CHAR.  If run
   with argument -f, output is a series of #define's for the ANSI standard
   float.h include file.  Flag -v gives verbose output: output includes the
   English text above as C comments.  The program exit(0)'s if everything
   went ok, otherwise it exits with a positive number, telling how many
   problems there were.

   VERIFYING THE COMPILER
   If, having produced the float.h and limits.h header files, you want to
   verify that the compiler reads them back correctly (there are a lot of
   boundary cases, of course, like minimum and maximum numbers), you can
   recompile hard-params.c with -DVERIFY set (plus the other flags that you used
   when compiling the version that produced the header files).  This then
   recompiles the program so that it #includes "limits.h" and "float.h",
   and checks that the constants it finds there are the same as the
   constants it produces. Run the resulting program with hard-params -fl.  As of
   this writing, of 21 compiler/flags combinations only 1 compiler has
   passed without error! (The honour goes to 'pcc' on an IBM RT.)

   You can also use this option if your compiler already has both files,
   and you want to confirm that this program produces the right results.

   TROUBLE SHOOTING.
   This program is now quite trustworthy, and suspicious and wrong output
   may well be caused by bugs in the compiler, not in the program (however
   of course, this is not guaranteed, and no responsibility can be
   accepted, etc.)

   The program only works if overflows are ignored by the C system or
   are catchable with signal().

   If the program fails to run to completion (often with the error message
   "Unexpected signal at point x"), this often turns out to be a bug in the
   C compiler's run-time system. Check what was about to be printed, and
   try to narrow the problem down.

   Another possible problem is that you have compiled the program to produce
   loss-of-precision arithmetic traps. The program cannot cope with these,
   and you should re-compile without them. (They should never be the default).

   Make sure you compiled with optimisation turned off.

   Output preceded by *** WARNING: identifies behaviour of the C system
   deemed incorrect by the program. Likely problems are that printf or
   scanf don't cope properly with certain boundary numbers.  For each float
   and double that is printed, the printed value is checked that it is
   correct by using sscanf to read it back.  Care is taken that numbers are
   printed with enough digits to uniquely identify them, and therefore that
   they can be read back identically. If the number read back is different,
   the program prints a warning message. If the two numbers in the warning
   look identical, then printf is more than likely rounding the last
   digit(s) incorrectly.  To put you at ease that the two really are
   different, the bit patterns of the two numbers are also printed.  The
   difference is very likely in the last bit.  Many scanf's read the
   minimum double back as 0.0, and similarly cause overflow when reading
   the maximum double.  The program quite ruthlessly declares all these
   behaviours faulty.

   The warning that "a cast didn't work" refers to cases like this:

      float f;
      #define C 1.234567890123456789
      f= C;
      if (f != (float) C) printf ("Wrong!");

   A faulty compiler will widen f to double and ignore the cast to float,
   and because there is more accuracy in a double than a float, fail to
   recognise that they are the same. In the actual case in point, f and C
   are passed as parameters to a function that discovers they are not equal,
   so it's just possible that the error was in the parameter passing,
   not in the cast (see function Validate()).
   For ANSI C, which has float constants, the error message is "constant has
   wrong precision".

   REPORTING PROBLEMS
   If the program doesn't work for you for any reason that can't be
   narrowed down to a problem in the C compiler, or it has to be changed in
   order to get it to compile, or it produces suspicious output (like a very
   low maximum float, for instance), please mail the problem and an example
   of the incorrect output to [e-mail] or mcvax!steven.uucp, so that
   improvements can be worked into future versions; mcvax/cwi.nl is the
   European backbone, and is connected to uunet and other fine hosts.

   This version of the program is the first to try to catch and diagnose
   bugs in the compiler/run-time system. I would be especially pleased to
   have reports of failures so that I can improve this service.

   I apologise unreservedly for the contorted use of the preprocessor...

   THE SMALL PRINT
   You may copy and distribute verbatim copies of this source file.

   You may modify this source file, and copy and distribute such
   modified versions, provided that you leave the copyright notice
   at the top of the file and also cause the modified file to carry
   prominent notices stating that you changed the files and the date
   of any change; and cause the whole of any work that you distribute
   or publish, that in whole or in part contains or is a derivative of
   this program or any part thereof, to be licensed at no charge to
   all third parties on terms identical to those here.

   If you do have a fix to any problem, please send it to me, so that
   other people can have the benefits.

   While every effort has been taken to make this program as reliable as
   possible, no responsibility can be taken for the correctness of the
   output, or suitability for any particular use.

   ACKNOWLEDGEMENTS
   Many people have given time and ideas to making this program what it is.
   To all of them thanks, and apologies for not mentioning them by name.
*/

#ifndef __FILE__
#define __FILE__ "hard-params.c"
#endif

#ifndef PASS
#define PASS 1
#define PASS1 1
#define VERSION "4.1"

/* Procedure just marks the functions that don't return a result */
#ifdef Procedure
#undef Procedure
#endif
#define Procedure

#define Vprintf if (V) printf

/* stdc is used in tests like if (stdc) */
#ifdef __STDC__
#define stdc 1
#else
#define stdc 0
#endif

/* volatile is used to reduce the chance of optimisation,
   and to prevent variables being put in registers (when setjmp/longjmp
   wouldn't work as we want)  */
#ifndef __STDC__
#define volatile static
#endif

#include <stdio.h>

/* Kludge around the possiblity that <stdio.h> includes <limits.h> */
#ifdef CHAR_BIT
#undef CHAR_BIT
#undef CHAR_MAX
#undef CHAR_MIN
#undef SCHAR_MAX
#undef SCHAR_MIN
#undef UCHAR_MAX
#undef UCHAR_MIN
#endif

#ifdef VERIFY
#include "limits.h"
#include "float.h"
#endif

#ifdef NO_SIG  /* There's no signal(), or setjmp/longjmp() */

	/* Dummy routines instead */
	int lab=1;
	int setjmp(lab) int lab; { return(0); }
	signal(i, p) int i, (*p)(); {}

#else

#include <signal.h>
#include <setjmp.h>

	jmp_buf lab;
	overflow(sig) int sig; { /* what to do on overflow/underflow */
		signal(sig, overflow);
		longjmp(lab, 1);
	}

#endif /*NO_SIG*/

#define Unexpected(place) if (setjmp(lab)!=0) croak(place)

int V= 0,	/* verbose */
    L= 0,	/* produce limits.h */
    F= 0,	/* produce float.h  */
    bugs=0;	/* The number of (possible) bugs in the output */

char co[4], oc[4]; /* Comment starter and ender symbols */

int bits_per_byte; /* the number of bits per unit returned by sizeof() */

#ifdef TEST
/* Set the fp modes on a SUN with 68881 chip, to check that different
   rounding modes etc. get properly detected.
   Compile with additional flag -DTEST, and run with additional parameter
   +hex-number, to set the 68881 mode register to hex-number
*/

/* Bits 0x30 = rounding mode: */
#define ROUND_BITS	0x30
#define TO_NEAREST	0x00
#define TO_ZERO		0x10
#define TO_MINUS_INF	0x20
#define TO_PLUS_INF	0x30 /* The SUN FP user's guide seems to be wrong here */

/* Bits 0xc0 = extended rounding: */
#define EXT_BITS	0xc0
#define ROUND_EXTENDED	0x00
#define ROUND_SINGLE 	0x40
#define ROUND_DOUBLE	0x80

/* Enabled traps: */
#define EXE_INEX1  0x100
#define EXE_INEX2  0x200
#define EXE_DZ	   0x400
#define EXE_UNFL   0x800
#define EXE_OVFL  0x1000
#define EXE_OPERR 0x2000
#define EXE_SNAN  0x4000
#define EXE_BSUN  0x8000

printmode(new) unsigned new; {
	fpmode_(&new);
	printf("New fp mode:\n");
	printf("  Round toward ");
	switch (new & ROUND_BITS) {
	      case TO_NEAREST:   printf("nearest"); break;
	      case TO_ZERO:      printf("zero"); break;
	      case TO_MINUS_INF: printf("minus infinity"); break;
	      case TO_PLUS_INF:  printf("plus infinity"); break;
	      default: printf("???"); break;
	}

	printf("\n  Extended rounding precision: ");

	switch (new & EXT_BITS) {
	      case ROUND_EXTENDED: printf("extended"); break;
	      case ROUND_SINGLE:   printf("single"); break;
	      case ROUND_DOUBLE:   printf("double"); break;
	      default: printf("???"); break;
	}

	printf("\n  Enabled exceptions:");
	if (new & (unsigned) EXE_INEX1) printf(" inex1");
	if (new & (unsigned) EXE_INEX2) printf(" inex2");
	if (new & (unsigned) EXE_DZ)    printf(" dz"); 
	if (new & (unsigned) EXE_UNFL)  printf(" unfl"); 
	if (new & (unsigned) EXE_OVFL)  printf(" ovfl"); 
	if (new & (unsigned) EXE_OPERR) printf(" operr"); 
	if (new & (unsigned) EXE_SNAN)  printf(" snan"); 
	if (new & (unsigned) EXE_BSUN)  printf(" bsun"); 
	printf("\n");
}

int setmode(s) char *s; {
	unsigned mode=0, dig;
	char c;

	while (*s) {
		c= *s++;
		if  (c>='0' && c<='9') dig= c-'0';
		else if (c>='a' && c<='f') dig= c-'a'+10;
		else if (c>='A' && c<='F') dig= c-'A'+10;
		else return 1;
		mode= mode<<4 | dig;
	}
	printmode(mode);
	return 0;
}
#else
int setmode(s) char *s; {
	fprintf(stderr, "Can't set mode: not compiled with TEST\n");
	return(1);
}
#endif

croak(place) int place; {
	printf("*** Unexpected signal at point %d\n", place);
	exit(bugs+1); /* An exit isn't essential here, but avoids loops */
}

/* This is here in case alloca.c is used.  That wants to call this.  */

char *
xmalloc(size) unsigned size; {
	char *malloc();
	char *value = malloc(size);
	if (value == 0) {
		fprintf(stderr, "Virtual memory exceeded\n");
		exit(bugs+1);
	}
	return value;
}

main(argc, argv) int argc; char *argv[]; {
	int dprec, fprec, lprec, basic(), fprop(), dprop(), efprop(), edprop();
	char *malloc();
	unsigned int size;
	long total;
	int i; char *s; int bad;

#ifdef SIGFPE
	signal(SIGFPE, overflow);
#endif
#ifdef SIGOVER
	signal(SIGOVER, overflow);
#endif
/* Add more calls as necessary */

	Unexpected(1);

	bad=0;
	for (i=1; i < argc; i++) {
		s= argv[i];
		if (*s == '-') {
			s++;
			while (*s) {
				switch (*(s++)) {
				      case 'v': V=1; break;
				      case 'l': L=1; break;
				      case 'f': F=1; break;
				      default: bad=1; break;
				}
			}
		} else if (*s == '+') {
			s++;
			bad= setmode(s);
		} else bad= 1;
	}
	if (bad) {
		fprintf(stderr,
			"Usage: %s [-vlf]\n  v=Verbose l=Limits.h f=Float.h\n",
			argv[0]);
		exit(1);
	}
	if (L || F) {
		co[0]= '/'; oc[0]= ' ';
		co[1]= '*'; oc[1]= '*';
		co[2]= ' '; oc[2]= '/';
		co[3]= '\0'; oc[3]= '\0';
	} else {
		co[0]= '\0'; oc[0]= '\0';
		V=1;
	}

	if (L) printf("%slimits.h%s\n", co, oc);
	if (F) printf("%sfloat.h%s\n", co, oc);
#ifdef ID
	printf("%sProduced on %s by hard-params version %s, CWI, Amsterdam%s\n",
	       co, ID, VERSION, oc);
#else
	printf("%sProduced by hard-params version %s, CWI, Amsterdam%s\n",
	       co, VERSION, oc);
#endif

#ifdef VERIFY
	printf("%sVerification phase%s\n", co, oc);
#endif

#ifdef NO_SIG
	Vprintf("%sCompiled without signal(): %s%s\n",
		co,
		"there's nothing that can be done if overflow occurs",
		oc);
#endif
#ifdef NO_SC
	Vprintf("%sCompiled without signed char%s\n", co, oc);
#endif
#ifdef NO_UC
	Vprintf("%Compiled without unsigned char%s\n", co, oc);
#endif
#ifdef NO_UI
	Vprintf("%Compiled without unsigned short or long%s\n", co, oc);
#endif
#ifdef __STDC__
	Vprintf("%sCompiler claims to be ANSI C level %d%s\n",
		co, __STDC__, oc);
#else
	Vprintf("%sCompiler does not claim to be ANSI C%s\n", co, oc);