#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "sreal.h"

Include dependency graph for sreal.c:

Functions
static void	copy (sreal , sreal )
static void	shift_right (sreal *, int)
static void	normalize (sreal *)
void	dump_sreal ()
DEBUG_FUNCTION void	debug ()
static void	copy ()
static void	shift_right ()
static void	normalize ()
sreal *	sreal_init ()
HOST_WIDE_INT	sreal_to_int ()
int	sreal_compare ()
sreal *	sreal_add ()
sreal *	sreal_sub ()
sreal *	sreal_mul ()
sreal *	sreal_div ()

Function Documentation

static void copy	(	sreal *	,
		sreal *
	)

inlinestatic

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see http://www.gnu.org/licenses/. This library supports positive real numbers and 0; inf and nan are NOT supported. It is written to be simple and fast.

Value of sreal is x = sig * 2 ^ exp where sig = significant (for < 64-bit machines sig = sig_lo + sig_hi * 2 ^ SREAL_PART_BITS) exp = exponent

One HOST_WIDE_INT is used for the significant on 64-bit (and more than 64-bit) machines, otherwise two HOST_WIDE_INTs are used for the significant. Only a half of significant bits is used (in normalized sreals) so that we do not have problems with overflow, for example when c->sig = a->sig * b->sig. So the precision for 64-bit and 32-bit machines is 32-bit.

Invariant: The numbers are normalized before and after each call of sreal_*.

Normalized sreals: All numbers (except zero) meet following conditions: SREAL_MIN_SIG <= sig && sig <= SREAL_MAX_SIG -SREAL_MAX_EXP <= exp && exp <= SREAL_MAX_EXP

If the number would be too large, it is set to upper bounds of these conditions.

If the number is zero or would be too small it meets following conditions: sig == 0 && exp == -SREAL_MAX_EXP

Referenced by canonicalize_component_ref(), diddle_return_value(), emit_clobber(), gen_internal_sym(), gimple_redirect_edge_and_branch(), initialize_argument_information(), insn_decl_eq_p(), move_all_children(), vnull::operator vec< T, A, L >(), shared_const_p(), sreal_sub(), and subscript_dependence_tester_1().

static void copy ( )

inlinestatic

Copy the sreal number.

DEBUG_FUNCTION void debug ( )

void dump_sreal ( )

Print the content of struct sreal.

static void normalize ( sreal * )

static

static void normalize ( )

static

Normalize *X.

Move lower part of significant to higher part.

     Check underflow.   


     Find out how many bits will be shifted.

     Round the number.

             x->sig_hi was SREAL_MAX_SIG before increment
             so now last bit is zero.

     Check overflow.

References sreal::exp, and SREAL_MAX_EXP.

static void shift_right	(	sreal *	,
		int
	)

inlinestatic

Referenced by sreal_sub().

static void shift_right ( )

inlinestatic

Shift X right by S bits. Needed: 0 < S <= SREAL_BITS. When the most significant bit shifted out is 1, add 1 to X (rounding).

Exponent should never be so large because shift_right is used only by sreal_add and sreal_sub ant thus the number cannot be shifted out from exponent range.

sreal* sreal_add ( )

*R = *A + *B. Return R.

int sreal_compare ( )

Compare *A and *B. Return -1 if *A < *B, 1 if *A > *B and 0 if *A == *B.

sreal* sreal_div ( )

*R = *A / *B. Return R.

Since division by the whole number is pretty ugly to write we are dividing by first 3/4 of bits of number.

Referenced by edge_badness().

sreal* sreal_init ( )

Set *R to SIG * 2 ^ EXP. Return R.

References sreal::exp, MAX_HOST_WIDE_INT, sreal::sig_hi, sreal::sig_lo, SREAL_BITS, and SREAL_PART_BITS.

Referenced by edge_badness().

sreal* sreal_mul ( )

*R = *A * *B. Return R.

Referenced by edge_badness().

sreal* sreal_sub ( )

*R = *A - *B. Return R.

References copy(), and shift_right().

HOST_WIDE_INT sreal_to_int ( )

Return integer value of *R.

Referenced by edge_badness().

Functions

Function Documentation