* [PATCH] c++ify sreal
@ 2014-10-24 6:30 tsaunders
2014-10-24 8:56 ` Richard Biener
0 siblings, 1 reply; 11+ messages in thread
From: tsaunders @ 2014-10-24 6:30 UTC (permalink / raw)
To: gcc-patches; +Cc: Trevor Saunders
From: Trevor Saunders <tsaunders@mozilla.com>
Hi,
do $subject, and cleanup for always 64 bit hwi.
bootstrapped + regtested x86_64-unknown-linux-gnu, ok?
Trev
gcc/ChangeLog:
2014-10-24 Trevor Saunders <tsaunders@mozilla.com>
* ipa-inline.c (edge_badness): Adjust.
(inline_small_functions): Likewise.
* predict.c (propagate_freq): Likewise.
(estimate_bb_frequencies): Likewise.
* sreal.c (sreal::dump): Rename from dump_sreal.
(debug): Adjust.
(copy): Remove function.
(sreal::shift_right): Rename from sreal_sift_right.
(sreal::normalize): Rename from normalize.
(sreal_init): Remove function.
(sreal::to_int): Rename from sreal_to_int.
(sreal_compare): Remove function.
(sreal::operator+): Rename from sreal_add.
(sreal::operator-): Rename from sreal_sub.
(sreal::operator*): Rename from sreal_mul.
(sreal::operator/): Rename from sreal_div.
* sreal.h (class sreal): Adjust.
(inline sreal &operator+=): New operator.
(inline sreal &operator-=): Likewise.
(inline sreal &operator/=): Likewise.
(inline sreal &operator*=): Likewise.
(inline bool operator!=): Likewise.
(inline bool operator>): Likewise.
(inline bool operator<=): Likewise.
(inline bool operator>=): Likewise.
---
gcc/ipa-inline.c | 25 ++-
gcc/predict.c | 82 ++++------
gcc/sreal.c | 479 +++++++++++--------------------------------------------
gcc/sreal.h | 97 ++++++++---
4 files changed, 213 insertions(+), 470 deletions(-)
diff --git a/gcc/ipa-inline.c b/gcc/ipa-inline.c
index e79a4dd..cca1fb3 100644
--- a/gcc/ipa-inline.c
+++ b/gcc/ipa-inline.c
@@ -939,29 +939,28 @@ edge_badness (struct cgraph_edge *edge, bool dump)
else if (max_count)
{
- sreal tmp, relbenefit_real, growth_real;
int relbenefit = relative_time_benefit (callee_info, edge, edge_time);
/* Capping edge->count to max_count. edge->count can be larger than
max_count if an inline adds new edges which increase max_count
after max_count is computed. */
gcov_type edge_count = edge->count > max_count ? max_count : edge->count;
- sreal_init (&relbenefit_real, relbenefit, 0);
- sreal_init (&growth_real, growth, 0);
+ sreal relbenefit_real (relbenefit, 0);
+ sreal growth_real (growth, 0);
/* relative_edge_count. */
- sreal_init (&tmp, edge_count, 0);
- sreal_div (&tmp, &tmp, &max_count_real);
+ sreal tmp (edge_count, 0);
+ tmp /= max_count_real;
/* relative_time_benefit. */
- sreal_mul (&tmp, &tmp, &relbenefit_real);
- sreal_div (&tmp, &tmp, &max_relbenefit_real);
+ tmp *= relbenefit_real;
+ tmp /= max_relbenefit_real;
/* growth_f_caller. */
- sreal_mul (&tmp, &tmp, &half_int_min_real);
- sreal_div (&tmp, &tmp, &growth_real);
+ tmp *= half_int_min_real;
+ tmp /= growth_real;
- badness = -1 * sreal_to_int (&tmp);
+ badness = -1 * tmp.to_int ();
if (dump)
{
@@ -1604,9 +1603,9 @@ inline_small_functions (void)
if (max_count < edge->count)
max_count = edge->count;
}
- sreal_init (&max_count_real, max_count, 0);
- sreal_init (&max_relbenefit_real, RELATIVE_TIME_BENEFIT_RANGE, 0);
- sreal_init (&half_int_min_real, INT_MAX / 2, 0);
+ max_count_real = sreal (max_count, 0);
+ max_relbenefit_real = sreal (RELATIVE_TIME_BENEFIT_RANGE, 0);
+ half_int_min_real = sreal (INT_MAX / 2, 0);
ipa_free_postorder_info ();
initialize_growth_caches ();
diff --git a/gcc/predict.c b/gcc/predict.c
index 5f5d4a5..10675c3 100644
--- a/gcc/predict.c
+++ b/gcc/predict.c
@@ -2571,15 +2571,13 @@ propagate_freq (basic_block head, bitmap tovisit)
bb->count = bb->frequency = 0;
}
- memcpy (&BLOCK_INFO (head)->frequency, &real_one, sizeof (real_one));
+ BLOCK_INFO (head)->frequency = real_one;
last = head;
for (bb = head; bb; bb = nextbb)
{
edge_iterator ei;
- sreal cyclic_probability, frequency;
-
- memcpy (&cyclic_probability, &real_zero, sizeof (real_zero));
- memcpy (&frequency, &real_zero, sizeof (real_zero));
+ sreal cyclic_probability = real_zero;
+ sreal frequency = real_zero;
nextbb = BLOCK_INFO (bb)->next;
BLOCK_INFO (bb)->next = NULL;
@@ -2596,42 +2594,34 @@ propagate_freq (basic_block head, bitmap tovisit)
FOR_EACH_EDGE (e, ei, bb->preds)
if (EDGE_INFO (e)->back_edge)
{
- sreal_add (&cyclic_probability, &cyclic_probability,
- &EDGE_INFO (e)->back_edge_prob);
+ cyclic_probability += EDGE_INFO (e)->back_edge_prob;
}
else if (!(e->flags & EDGE_DFS_BACK))
{
- sreal tmp;
-
/* frequency += (e->probability
* BLOCK_INFO (e->src)->frequency /
REG_BR_PROB_BASE); */
- sreal_init (&tmp, e->probability, 0);
- sreal_mul (&tmp, &tmp, &BLOCK_INFO (e->src)->frequency);
- sreal_mul (&tmp, &tmp, &real_inv_br_prob_base);
- sreal_add (&frequency, &frequency, &tmp);
+ sreal tmp (e->probability, 0);
+ tmp *= BLOCK_INFO (e->src)->frequency;
+ tmp *= real_inv_br_prob_base;
+ frequency += tmp;
}
- if (sreal_compare (&cyclic_probability, &real_zero) == 0)
+ if (cyclic_probability == real_zero)
{
- memcpy (&BLOCK_INFO (bb)->frequency, &frequency,
- sizeof (frequency));
+ BLOCK_INFO (bb)->frequency = frequency;
}
else
{
- if (sreal_compare (&cyclic_probability, &real_almost_one) > 0)
- {
- memcpy (&cyclic_probability, &real_almost_one,
- sizeof (real_almost_one));
- }
+ if (cyclic_probability > real_almost_one)
+ cyclic_probability = real_almost_one;
/* BLOCK_INFO (bb)->frequency = frequency
/ (1 - cyclic_probability) */
- sreal_sub (&cyclic_probability, &real_one, &cyclic_probability);
- sreal_div (&BLOCK_INFO (bb)->frequency,
- &frequency, &cyclic_probability);
+ cyclic_probability = real_one - cyclic_probability;
+ BLOCK_INFO (bb)->frequency = frequency / cyclic_probability;
}
}
@@ -2640,16 +2630,13 @@ propagate_freq (basic_block head, bitmap tovisit)
e = find_edge (bb, head);
if (e)
{
- sreal tmp;
-
/* EDGE_INFO (e)->back_edge_prob
= ((e->probability * BLOCK_INFO (bb)->frequency)
/ REG_BR_PROB_BASE); */
- sreal_init (&tmp, e->probability, 0);
- sreal_mul (&tmp, &tmp, &BLOCK_INFO (bb)->frequency);
- sreal_mul (&EDGE_INFO (e)->back_edge_prob,
- &tmp, &real_inv_br_prob_base);
+ sreal tmp (e->probability, 0);
+ tmp *= BLOCK_INFO (bb)->frequency;
+ EDGE_INFO (e)->back_edge_prob = tmp * real_inv_br_prob_base;
}
/* Propagate to successor blocks. */
@@ -2929,13 +2916,13 @@ estimate_bb_frequencies (bool force)
if (!real_values_initialized)
{
real_values_initialized = 1;
- sreal_init (&real_zero, 0, 0);
- sreal_init (&real_one, 1, 0);
- sreal_init (&real_br_prob_base, REG_BR_PROB_BASE, 0);
- sreal_init (&real_bb_freq_max, BB_FREQ_MAX, 0);
- sreal_init (&real_one_half, 1, -1);
- sreal_div (&real_inv_br_prob_base, &real_one, &real_br_prob_base);
- sreal_sub (&real_almost_one, &real_one, &real_inv_br_prob_base);
+ real_zero = sreal (0, 0);
+ real_one = sreal (1, 0);
+ real_br_prob_base = sreal (REG_BR_PROB_BASE, 0);
+ real_bb_freq_max = sreal (BB_FREQ_MAX, 0);
+ real_one_half = sreal (1, -1);
+ real_inv_br_prob_base = real_one / real_br_prob_base;
+ real_almost_one = real_one - real_inv_br_prob_base;
}
mark_dfs_back_edges ();
@@ -2953,10 +2940,8 @@ estimate_bb_frequencies (bool force)
FOR_EACH_EDGE (e, ei, bb->succs)
{
- sreal_init (&EDGE_INFO (e)->back_edge_prob, e->probability, 0);
- sreal_mul (&EDGE_INFO (e)->back_edge_prob,
- &EDGE_INFO (e)->back_edge_prob,
- &real_inv_br_prob_base);
+ EDGE_INFO (e)->back_edge_prob = sreal (e->probability, 0);
+ EDGE_INFO (e)->back_edge_prob *= real_inv_br_prob_base;
}
}
@@ -2964,19 +2949,16 @@ estimate_bb_frequencies (bool force)
to outermost to examine frequencies for back edges. */
estimate_loops ();
- memcpy (&freq_max, &real_zero, sizeof (real_zero));
+ freq_max = real_zero;
FOR_EACH_BB_FN (bb, cfun)
- if (sreal_compare (&freq_max, &BLOCK_INFO (bb)->frequency) < 0)
- memcpy (&freq_max, &BLOCK_INFO (bb)->frequency, sizeof (freq_max));
+ if (freq_max < BLOCK_INFO (bb)->frequency)
+ freq_max = BLOCK_INFO (bb)->frequency;
- sreal_div (&freq_max, &real_bb_freq_max, &freq_max);
+ freq_max = real_bb_freq_max / freq_max;
FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun), NULL, next_bb)
{
- sreal tmp;
-
- sreal_mul (&tmp, &BLOCK_INFO (bb)->frequency, &freq_max);
- sreal_add (&tmp, &tmp, &real_one_half);
- bb->frequency = sreal_to_int (&tmp);
+ sreal tmp = BLOCK_INFO (bb)->frequency * freq_max + real_one_half;
+ bb->frequency = tmp.to_int ();
}
free_aux_for_blocks ();
diff --git a/gcc/sreal.c b/gcc/sreal.c
index 5c429c5..c99aa1e 100644
--- a/gcc/sreal.c
+++ b/gcc/sreal.c
@@ -54,28 +54,18 @@ along with GCC; see the file COPYING3. If not see
#include "coretypes.h"
#include "sreal.h"
-static inline void copy (sreal *, sreal *);
-static inline void shift_right (sreal *, int);
-static void normalize (sreal *);
-
/* Print the content of struct sreal. */
void
-dump_sreal (FILE *file, sreal *x)
+sreal::dump (FILE *file) const
{
-#if SREAL_PART_BITS < 32
- fprintf (file, "((" HOST_WIDE_INT_PRINT_UNSIGNED " * 2^16 + "
- HOST_WIDE_INT_PRINT_UNSIGNED ") * 2^%d)",
- x->sig_hi, x->sig_lo, x->exp);
-#else
- fprintf (file, "(" HOST_WIDE_INT_PRINT_UNSIGNED " * 2^%d)", x->sig, x->exp);
-#endif
+ fprintf (file, "(" HOST_WIDE_INT_PRINT_UNSIGNED " * 2^%d)", m_sig, m_exp);
}
DEBUG_FUNCTION void
debug (sreal &ref)
{
- dump_sreal (stderr, &ref);
+ ref.dump (stderr);
}
DEBUG_FUNCTION void
@@ -87,472 +77,195 @@ debug (sreal *ptr)
fprintf (stderr, "<nil>\n");
}
+/* Shift this right by S bits. Needed: 0 < S <= SREAL_BITS.
+ When the most significant bit shifted out is 1, add 1 to this (rounding).
+ */
-/* Copy the sreal number. */
-
-static inline void
-copy (sreal *r, sreal *a)
-{
-#if SREAL_PART_BITS < 32
- r->sig_lo = a->sig_lo;
- r->sig_hi = a->sig_hi;
-#else
- r->sig = a->sig;
-#endif
- r->exp = a->exp;
-}
-
-/* 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). */
-
-static inline void
-shift_right (sreal *x, int s)
+void
+sreal::shift_right (int s)
{
gcc_assert (s > 0);
gcc_assert (s <= SREAL_BITS);
/* 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. */
- gcc_assert (x->exp + s <= SREAL_MAX_EXP);
+ gcc_assert (m_exp + s <= SREAL_MAX_EXP);
- x->exp += s;
+ m_exp += s;
-#if SREAL_PART_BITS < 32
- if (s > SREAL_PART_BITS)
- {
- s -= SREAL_PART_BITS;
- x->sig_hi += (uhwi) 1 << (s - 1);
- x->sig_lo = x->sig_hi >> s;
- x->sig_hi = 0;
- }
- else
- {
- x->sig_lo += (uhwi) 1 << (s - 1);
- if (x->sig_lo & ((uhwi) 1 << SREAL_PART_BITS))
- {
- x->sig_hi++;
- x->sig_lo -= (uhwi) 1 << SREAL_PART_BITS;
- }
- x->sig_lo >>= s;
- x->sig_lo |= (x->sig_hi & (((uhwi) 1 << s) - 1)) << (SREAL_PART_BITS - s);
- x->sig_hi >>= s;
- }
-#else
- x->sig += (uhwi) 1 << (s - 1);
- x->sig >>= s;
-#endif
+ m_sig += (uhwi) 1 << (s - 1);
+ m_sig >>= s;
}
-/* Normalize *X. */
+/* Normalize *this. */
-static void
-normalize (sreal *x)
+void
+sreal::normalize ()
{
-#if SREAL_PART_BITS < 32
- int shift;
- HOST_WIDE_INT mask;
-
- if (x->sig_lo == 0 && x->sig_hi == 0)
- {
- x->exp = -SREAL_MAX_EXP;
- }
- else if (x->sig_hi < SREAL_MIN_SIG)
- {
- if (x->sig_hi == 0)
- {
- /* Move lower part of significant to higher part. */
- x->sig_hi = x->sig_lo;
- x->sig_lo = 0;
- x->exp -= SREAL_PART_BITS;
- }
- shift = 0;
- while (x->sig_hi < SREAL_MIN_SIG)
- {
- x->sig_hi <<= 1;
- x->exp--;
- shift++;
- }
- /* Check underflow. */
- if (x->exp < -SREAL_MAX_EXP)
- {
- x->exp = -SREAL_MAX_EXP;
- x->sig_hi = 0;
- x->sig_lo = 0;
- }
- else if (shift)
- {
- mask = (1 << SREAL_PART_BITS) - (1 << (SREAL_PART_BITS - shift));
- x->sig_hi |= (x->sig_lo & mask) >> (SREAL_PART_BITS - shift);
- x->sig_lo = (x->sig_lo << shift) & (((uhwi) 1 << SREAL_PART_BITS) - 1);
- }
- }
- else if (x->sig_hi > SREAL_MAX_SIG)
- {
- unsigned HOST_WIDE_INT tmp = x->sig_hi;
-
- /* Find out how many bits will be shifted. */
- shift = 0;
- do
- {
- tmp >>= 1;
- shift++;
- }
- while (tmp > SREAL_MAX_SIG);
-
- /* Round the number. */
- x->sig_lo += (uhwi) 1 << (shift - 1);
-
- x->sig_lo >>= shift;
- x->sig_lo += ((x->sig_hi & (((uhwi) 1 << shift) - 1))
- << (SREAL_PART_BITS - shift));
- x->sig_hi >>= shift;
- x->exp += shift;
- if (x->sig_lo & ((uhwi) 1 << SREAL_PART_BITS))
- {
- x->sig_lo -= (uhwi) 1 << SREAL_PART_BITS;
- x->sig_hi++;
- if (x->sig_hi > SREAL_MAX_SIG)
- {
- /* x->sig_hi was SREAL_MAX_SIG before increment
- so now last bit is zero. */
- x->sig_hi >>= 1;
- x->sig_lo >>= 1;
- x->exp++;
- }
- }
-
- /* Check overflow. */
- if (x->exp > SREAL_MAX_EXP)
- {
- x->exp = SREAL_MAX_EXP;
- x->sig_hi = SREAL_MAX_SIG;
- x->sig_lo = SREAL_MAX_SIG;
- }
- }
-#else
- if (x->sig == 0)
+ if (m_sig == 0)
{
- x->exp = -SREAL_MAX_EXP;
+ m_exp = -SREAL_MAX_EXP;
}
- else if (x->sig < SREAL_MIN_SIG)
+ else if (m_sig < SREAL_MIN_SIG)
{
do
{
- x->sig <<= 1;
- x->exp--;
+ m_sig <<= 1;
+ m_exp--;
}
- while (x->sig < SREAL_MIN_SIG);
+ while (m_sig < SREAL_MIN_SIG);
/* Check underflow. */
- if (x->exp < -SREAL_MAX_EXP)
+ if (m_exp < -SREAL_MAX_EXP)
{
- x->exp = -SREAL_MAX_EXP;
- x->sig = 0;
+ m_exp = -SREAL_MAX_EXP;
+ m_sig = 0;
}
}
- else if (x->sig > SREAL_MAX_SIG)
+ else if (m_sig > SREAL_MAX_SIG)
{
int last_bit;
do
{
- last_bit = x->sig & 1;
- x->sig >>= 1;
- x->exp++;
+ last_bit = m_sig & 1;
+ m_sig >>= 1;
+ m_exp++;
}
- while (x->sig > SREAL_MAX_SIG);
+ while (m_sig > SREAL_MAX_SIG);
/* Round the number. */
- x->sig += last_bit;
- if (x->sig > SREAL_MAX_SIG)
+ m_sig += last_bit;
+ if (m_sig > SREAL_MAX_SIG)
{
- x->sig >>= 1;
- x->exp++;
+ m_sig >>= 1;
+ m_exp++;
}
/* Check overflow. */
- if (x->exp > SREAL_MAX_EXP)
+ if (m_exp > SREAL_MAX_EXP)
{
- x->exp = SREAL_MAX_EXP;
- x->sig = SREAL_MAX_SIG;
+ m_exp = SREAL_MAX_EXP;
+ m_sig = SREAL_MAX_SIG;
}
}
-#endif
-}
-
-/* Set *R to SIG * 2 ^ EXP. Return R. */
-
-sreal *
-sreal_init (sreal *r, unsigned HOST_WIDE_INT sig, signed int exp)
-{
-#if SREAL_PART_BITS < 32
- r->sig_lo = 0;
- r->sig_hi = sig;
- r->exp = exp - 16;
-#else
- r->sig = sig;
- r->exp = exp;
-#endif
- normalize (r);
- return r;
}
-/* Return integer value of *R. */
+/* Return integer value of *this. */
-HOST_WIDE_INT
-sreal_to_int (sreal *r)
+int64_t
+sreal::to_int () const
{
-#if SREAL_PART_BITS < 32
- if (r->exp <= -SREAL_BITS)
+ if (m_exp <= -SREAL_BITS)
return 0;
- if (r->exp >= 0)
+ if (m_exp >= SREAL_PART_BITS)
return MAX_HOST_WIDE_INT;
- return ((r->sig_hi << SREAL_PART_BITS) + r->sig_lo) >> -r->exp;
-#else
- if (r->exp <= -SREAL_BITS)
- return 0;
- if (r->exp >= SREAL_PART_BITS)
- return MAX_HOST_WIDE_INT;
- if (r->exp > 0)
- return r->sig << r->exp;
- if (r->exp < 0)
- return r->sig >> -r->exp;
- return r->sig;
-#endif
+ if (m_exp > 0)
+ return m_sig << m_exp;
+ if (m_exp < 0)
+ return m_sig >> -m_exp;
+ return m_sig;
}
-/* Compare *A and *B. Return -1 if *A < *B, 1 if *A > *B and 0 if *A == *B. */
+/* Return *this + other. */
-int
-sreal_compare (sreal *a, sreal *b)
-{
- if (a->exp > b->exp)
- return 1;
- if (a->exp < b->exp)
- return -1;
-#if SREAL_PART_BITS < 32
- if (a->sig_hi > b->sig_hi)
- return 1;
- if (a->sig_hi < b->sig_hi)
- return -1;
- if (a->sig_lo > b->sig_lo)
- return 1;
- if (a->sig_lo < b->sig_lo)
- return -1;
-#else
- if (a->sig > b->sig)
- return 1;
- if (a->sig < b->sig)
- return -1;
-#endif
- return 0;
-}
-
-/* *R = *A + *B. Return R. */
-
-sreal *
-sreal_add (sreal *r, sreal *a, sreal *b)
+sreal
+sreal::operator+ (const sreal &other) const
{
int dexp;
- sreal tmp;
- sreal *bb;
+ sreal tmp, r;
+const sreal *a_p = this, *b_p = &other, *bb;
- if (sreal_compare (a, b) < 0)
+ if (*a_p < *b_p)
{
- sreal *swap;
- swap = a;
- a = b;
- b = swap;
+ const sreal *swap;
+ swap = a_p;
+ a_p = b_p;
+ b_p = swap;
}
- dexp = a->exp - b->exp;
- r->exp = a->exp;
+ dexp = a_p->m_exp - b_p->m_exp;
+ r.m_exp = a_p->m_exp;
if (dexp > SREAL_BITS)
{
-#if SREAL_PART_BITS < 32
- r->sig_hi = a->sig_hi;
- r->sig_lo = a->sig_lo;
-#else
- r->sig = a->sig;
-#endif
+ r.m_sig = a_p->m_sig;
return r;
}
if (dexp == 0)
- bb = b;
+ bb = b_p;
else
{
- copy (&tmp, b);
- shift_right (&tmp, dexp);
+ tmp = *b_p;
+ tmp.shift_right (dexp);
bb = &tmp;
}
-#if SREAL_PART_BITS < 32
- r->sig_hi = a->sig_hi + bb->sig_hi;
- r->sig_lo = a->sig_lo + bb->sig_lo;
- if (r->sig_lo & ((uhwi) 1 << SREAL_PART_BITS))
- {
- r->sig_hi++;
- r->sig_lo -= (uhwi) 1 << SREAL_PART_BITS;
- }
-#else
- r->sig = a->sig + bb->sig;
-#endif
- normalize (r);
+ r.m_sig = a_p->m_sig + bb->m_sig;
+ r.normalize ();
return r;
}
-/* *R = *A - *B. Return R. */
+/* Return *this - other. */
-sreal *
-sreal_sub (sreal *r, sreal *a, sreal *b)
+sreal
+sreal::operator- (const sreal &other) const
{
int dexp;
- sreal tmp;
- sreal *bb;
+ sreal tmp, r;
+ const sreal *bb;
- gcc_assert (sreal_compare (a, b) >= 0);
+ gcc_assert (*this >= other);
- dexp = a->exp - b->exp;
- r->exp = a->exp;
+ dexp = m_exp - other.m_exp;
+ r.m_exp = m_exp;
if (dexp > SREAL_BITS)
{
-#if SREAL_PART_BITS < 32
- r->sig_hi = a->sig_hi;
- r->sig_lo = a->sig_lo;
-#else
- r->sig = a->sig;
-#endif
+ r.m_sig = m_sig;
return r;
}
if (dexp == 0)
- bb = b;
+ bb = &other;
else
{
- copy (&tmp, b);
- shift_right (&tmp, dexp);
+ tmp = other;
+ tmp.shift_right (dexp);
bb = &tmp;
}
-#if SREAL_PART_BITS < 32
- if (a->sig_lo < bb->sig_lo)
- {
- r->sig_hi = a->sig_hi - bb->sig_hi - 1;
- r->sig_lo = a->sig_lo + ((uhwi) 1 << SREAL_PART_BITS) - bb->sig_lo;
- }
- else
- {
- r->sig_hi = a->sig_hi - bb->sig_hi;
- r->sig_lo = a->sig_lo - bb->sig_lo;
- }
-#else
- r->sig = a->sig - bb->sig;
-#endif
- normalize (r);
+ r.m_sig = m_sig - bb->m_sig;
+ r.normalize ();
return r;
}
-/* *R = *A * *B. Return R. */
+/* Return *this * other. */
-sreal *
-sreal_mul (sreal *r, sreal *a, sreal *b)
+sreal
+sreal::operator* (const sreal &other) const
{
-#if SREAL_PART_BITS < 32
- if (a->sig_hi < SREAL_MIN_SIG || b->sig_hi < SREAL_MIN_SIG)
- {
- r->sig_lo = 0;
- r->sig_hi = 0;
- r->exp = -SREAL_MAX_EXP;
- }
- else
+sreal r;
+ if (m_sig < SREAL_MIN_SIG || other.m_sig < SREAL_MIN_SIG)
{
- unsigned HOST_WIDE_INT tmp1, tmp2, tmp3;
- if (sreal_compare (a, b) < 0)
- {
- sreal *swap;
- swap = a;
- a = b;
- b = swap;
- }
-
- r->exp = a->exp + b->exp + SREAL_PART_BITS;
-
- tmp1 = a->sig_lo * b->sig_lo;
- tmp2 = a->sig_lo * b->sig_hi;
- tmp3 = a->sig_hi * b->sig_lo + (tmp1 >> SREAL_PART_BITS);
-
- r->sig_hi = a->sig_hi * b->sig_hi;
- r->sig_hi += (tmp2 >> SREAL_PART_BITS) + (tmp3 >> SREAL_PART_BITS);
- tmp2 &= ((uhwi) 1 << SREAL_PART_BITS) - 1;
- tmp3 &= ((uhwi) 1 << SREAL_PART_BITS) - 1;
- tmp1 = tmp2 + tmp3;
-
- r->sig_lo = tmp1 & (((uhwi) 1 << SREAL_PART_BITS) - 1);
- r->sig_hi += tmp1 >> SREAL_PART_BITS;
-
- normalize (r);
- }
-#else
- if (a->sig < SREAL_MIN_SIG || b->sig < SREAL_MIN_SIG)
- {
- r->sig = 0;
- r->exp = -SREAL_MAX_EXP;
+ r.m_sig = 0;
+ r.m_exp = -SREAL_MAX_EXP;
}
else
{
- r->sig = a->sig * b->sig;
- r->exp = a->exp + b->exp;
- normalize (r);
+ r.m_sig = m_sig * other.m_sig;
+ r.m_exp = m_exp + other.m_exp;
+ r.normalize ();
}
-#endif
return r;
}
-/* *R = *A / *B. Return R. */
+/* Return *this / other. */
-sreal *
-sreal_div (sreal *r, sreal *a, sreal *b)
+sreal
+sreal::operator/ (const sreal &other) const
{
-#if SREAL_PART_BITS < 32
- unsigned HOST_WIDE_INT tmp, tmp1, tmp2;
-
- gcc_assert (b->sig_hi >= SREAL_MIN_SIG);
- if (a->sig_hi < SREAL_MIN_SIG)
- {
- r->sig_hi = 0;
- r->sig_lo = 0;
- r->exp = -SREAL_MAX_EXP;
- }
- else
- {
- /* Since division by the whole number is pretty ugly to write
- we are dividing by first 3/4 of bits of number. */
-
- tmp1 = (a->sig_hi << SREAL_PART_BITS) + a->sig_lo;
- tmp2 = ((b->sig_hi << (SREAL_PART_BITS / 2))
- + (b->sig_lo >> (SREAL_PART_BITS / 2)));
- if (b->sig_lo & ((uhwi) 1 << ((SREAL_PART_BITS / 2) - 1)))
- tmp2++;
-
- r->sig_lo = 0;
- tmp = tmp1 / tmp2;
- tmp1 = (tmp1 % tmp2) << (SREAL_PART_BITS / 2);
- r->sig_hi = tmp << SREAL_PART_BITS;
-
- tmp = tmp1 / tmp2;
- tmp1 = (tmp1 % tmp2) << (SREAL_PART_BITS / 2);
- r->sig_hi += tmp << (SREAL_PART_BITS / 2);
-
- tmp = tmp1 / tmp2;
- r->sig_hi += tmp;
-
- r->exp = a->exp - b->exp - SREAL_BITS - SREAL_PART_BITS / 2;
- normalize (r);
- }
-#else
- gcc_assert (b->sig != 0);
- r->sig = (a->sig << SREAL_PART_BITS) / b->sig;
- r->exp = a->exp - b->exp - SREAL_PART_BITS;
- normalize (r);
-#endif
+ gcc_assert (other.m_sig != 0);
+sreal r;
+ r.m_sig = (m_sig << SREAL_PART_BITS) / other.m_sig;
+ r.m_exp = m_exp - other.m_exp - SREAL_PART_BITS;
+ r.normalize ();
return r;
}
diff --git a/gcc/sreal.h b/gcc/sreal.h
index 08d577a..a3db3d5 100644
--- a/gcc/sreal.h
+++ b/gcc/sreal.h
@@ -21,11 +21,7 @@ along with GCC; see the file COPYING3. If not see
#define GCC_SREAL_H
/* SREAL_PART_BITS has to be an even number. */
-#if (HOST_BITS_PER_WIDE_INT / 2) % 2 == 1
-#define SREAL_PART_BITS (HOST_BITS_PER_WIDE_INT / 2 - 1)
-#else
#define SREAL_PART_BITS (HOST_BITS_PER_WIDE_INT / 2)
-#endif
#define uhwi unsigned HOST_WIDE_INT
#define MAX_HOST_WIDE_INT (((uhwi) 1 << (HOST_BITS_PER_WIDE_INT - 1)) - 1)
@@ -34,33 +30,86 @@ along with GCC; see the file COPYING3. If not see
#define SREAL_MAX_SIG (((uhwi) 1 << SREAL_PART_BITS) - 1)
#define SREAL_MAX_EXP (INT_MAX / 4)
-#if SREAL_PART_BITS < 32
-#define SREAL_BITS (SREAL_PART_BITS * 2)
-#else
#define SREAL_BITS SREAL_PART_BITS
-#endif
/* Structure for holding a simple real number. */
-struct sreal
+class sreal
{
-#if SREAL_PART_BITS < 32
- unsigned HOST_WIDE_INT sig_lo; /* Significant (lower part). */
- unsigned HOST_WIDE_INT sig_hi; /* Significant (higher part). */
-#else
- unsigned HOST_WIDE_INT sig; /* Significant. */
-#endif
- signed int exp; /* Exponent. */
+public:
+ /* Construct an uninitialized sreal. */
+ sreal () : m_sig (-1), m_exp (-1) {}
+
+ /* Construct a sreal. */
+ sreal (uint64_t sig, int exp) : m_sig (sig), m_exp (exp) { normalize (); }
+
+ void dump (FILE *) const;
+ int64_t to_int () const;
+
+ sreal operator+ (const sreal &other) const;
+ sreal operator- (const sreal &other) const;
+ sreal operator* (const sreal &other) const;
+ sreal operator/ (const sreal &other) const;
+
+ bool operator< (const sreal &other) const
+ {
+ return m_exp < other.m_exp
+ || (m_exp == other.m_exp && m_sig < other.m_sig);
+ }
+
+ bool operator== (const sreal &other) const
+ {
+ return m_exp == other.m_exp && m_sig == other.m_sig;
+ }
+
+private:
+ void normalize ();
+ void shift_right (int amount);
+
+ uint64_t m_sig; /* Significant. */
+ signed int m_exp; /* Exponent. */
};
-extern void dump_sreal (FILE *, sreal *);
extern void debug (sreal &ref);
extern void debug (sreal *ptr);
-extern sreal *sreal_init (sreal *, unsigned HOST_WIDE_INT, signed int);
-extern HOST_WIDE_INT sreal_to_int (sreal *);
-extern int sreal_compare (sreal *, sreal *);
-extern sreal *sreal_add (sreal *, sreal *, sreal *);
-extern sreal *sreal_sub (sreal *, sreal *, sreal *);
-extern sreal *sreal_mul (sreal *, sreal *, sreal *);
-extern sreal *sreal_div (sreal *, sreal *, sreal *);
+
+inline sreal &operator+= (sreal &a, const sreal &b)
+{
+ return a = a + b;
+}
+
+inline sreal &operator-= (sreal &a, const sreal &b)
+{
+return a = a - b;
+}
+
+inline sreal &operator/= (sreal &a, const sreal &b)
+{
+return a = a / b;
+}
+
+inline sreal &operator*= (sreal &a, const sreal &b)
+{
+ return a = a * b;
+}
+
+inline bool operator!= (const sreal &a, const sreal &b)
+{
+ return !(a == b);
+}
+
+inline bool operator> (const sreal &a, const sreal &b)
+{
+ return !(a == b || a < b);
+}
+
+inline bool operator<= (const sreal &a, const sreal &b)
+{
+ return a < b || a == b;
+}
+
+inline bool operator>= (const sreal &a, const sreal &b)
+{
+ return a == b || a > b;
+}
#endif
--
2.1.1
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH] c++ify sreal
2014-10-24 6:30 [PATCH] c++ify sreal tsaunders
@ 2014-10-24 8:56 ` Richard Biener
2014-11-11 6:51 ` Andrew Pinski
0 siblings, 1 reply; 11+ messages in thread
From: Richard Biener @ 2014-10-24 8:56 UTC (permalink / raw)
To: tsaunders; +Cc: GCC Patches
On Fri, Oct 24, 2014 at 8:28 AM, <tsaunders@mozilla.com> wrote:
> From: Trevor Saunders <tsaunders@mozilla.com>
>
> Hi,
>
> do $subject, and cleanup for always 64 bit hwi.
>
>
> bootstrapped + regtested x86_64-unknown-linux-gnu, ok?
Ok. Can you please replace remaining HOST_WIDE_INT
vestiges in there with [u]int64_t please?
Thanks,
Richard.
> Trev
>
> gcc/ChangeLog:
>
> 2014-10-24 Trevor Saunders <tsaunders@mozilla.com>
>
> * ipa-inline.c (edge_badness): Adjust.
> (inline_small_functions): Likewise.
> * predict.c (propagate_freq): Likewise.
> (estimate_bb_frequencies): Likewise.
> * sreal.c (sreal::dump): Rename from dump_sreal.
> (debug): Adjust.
> (copy): Remove function.
> (sreal::shift_right): Rename from sreal_sift_right.
> (sreal::normalize): Rename from normalize.
> (sreal_init): Remove function.
> (sreal::to_int): Rename from sreal_to_int.
> (sreal_compare): Remove function.
> (sreal::operator+): Rename from sreal_add.
> (sreal::operator-): Rename from sreal_sub.
> (sreal::operator*): Rename from sreal_mul.
> (sreal::operator/): Rename from sreal_div.
> * sreal.h (class sreal): Adjust.
> (inline sreal &operator+=): New operator.
> (inline sreal &operator-=): Likewise.
> (inline sreal &operator/=): Likewise.
> (inline sreal &operator*=): Likewise.
> (inline bool operator!=): Likewise.
> (inline bool operator>): Likewise.
> (inline bool operator<=): Likewise.
> (inline bool operator>=): Likewise.
> ---
> gcc/ipa-inline.c | 25 ++-
> gcc/predict.c | 82 ++++------
> gcc/sreal.c | 479 +++++++++++--------------------------------------------
> gcc/sreal.h | 97 ++++++++---
> 4 files changed, 213 insertions(+), 470 deletions(-)
>
> diff --git a/gcc/ipa-inline.c b/gcc/ipa-inline.c
> index e79a4dd..cca1fb3 100644
> --- a/gcc/ipa-inline.c
> +++ b/gcc/ipa-inline.c
> @@ -939,29 +939,28 @@ edge_badness (struct cgraph_edge *edge, bool dump)
>
> else if (max_count)
> {
> - sreal tmp, relbenefit_real, growth_real;
> int relbenefit = relative_time_benefit (callee_info, edge, edge_time);
> /* Capping edge->count to max_count. edge->count can be larger than
> max_count if an inline adds new edges which increase max_count
> after max_count is computed. */
> gcov_type edge_count = edge->count > max_count ? max_count : edge->count;
>
> - sreal_init (&relbenefit_real, relbenefit, 0);
> - sreal_init (&growth_real, growth, 0);
> + sreal relbenefit_real (relbenefit, 0);
> + sreal growth_real (growth, 0);
>
> /* relative_edge_count. */
> - sreal_init (&tmp, edge_count, 0);
> - sreal_div (&tmp, &tmp, &max_count_real);
> + sreal tmp (edge_count, 0);
> + tmp /= max_count_real;
>
> /* relative_time_benefit. */
> - sreal_mul (&tmp, &tmp, &relbenefit_real);
> - sreal_div (&tmp, &tmp, &max_relbenefit_real);
> + tmp *= relbenefit_real;
> + tmp /= max_relbenefit_real;
>
> /* growth_f_caller. */
> - sreal_mul (&tmp, &tmp, &half_int_min_real);
> - sreal_div (&tmp, &tmp, &growth_real);
> + tmp *= half_int_min_real;
> + tmp /= growth_real;
>
> - badness = -1 * sreal_to_int (&tmp);
> + badness = -1 * tmp.to_int ();
>
> if (dump)
> {
> @@ -1604,9 +1603,9 @@ inline_small_functions (void)
> if (max_count < edge->count)
> max_count = edge->count;
> }
> - sreal_init (&max_count_real, max_count, 0);
> - sreal_init (&max_relbenefit_real, RELATIVE_TIME_BENEFIT_RANGE, 0);
> - sreal_init (&half_int_min_real, INT_MAX / 2, 0);
> + max_count_real = sreal (max_count, 0);
> + max_relbenefit_real = sreal (RELATIVE_TIME_BENEFIT_RANGE, 0);
> + half_int_min_real = sreal (INT_MAX / 2, 0);
> ipa_free_postorder_info ();
> initialize_growth_caches ();
>
> diff --git a/gcc/predict.c b/gcc/predict.c
> index 5f5d4a5..10675c3 100644
> --- a/gcc/predict.c
> +++ b/gcc/predict.c
> @@ -2571,15 +2571,13 @@ propagate_freq (basic_block head, bitmap tovisit)
> bb->count = bb->frequency = 0;
> }
>
> - memcpy (&BLOCK_INFO (head)->frequency, &real_one, sizeof (real_one));
> + BLOCK_INFO (head)->frequency = real_one;
> last = head;
> for (bb = head; bb; bb = nextbb)
> {
> edge_iterator ei;
> - sreal cyclic_probability, frequency;
> -
> - memcpy (&cyclic_probability, &real_zero, sizeof (real_zero));
> - memcpy (&frequency, &real_zero, sizeof (real_zero));
> + sreal cyclic_probability = real_zero;
> + sreal frequency = real_zero;
>
> nextbb = BLOCK_INFO (bb)->next;
> BLOCK_INFO (bb)->next = NULL;
> @@ -2596,42 +2594,34 @@ propagate_freq (basic_block head, bitmap tovisit)
> FOR_EACH_EDGE (e, ei, bb->preds)
> if (EDGE_INFO (e)->back_edge)
> {
> - sreal_add (&cyclic_probability, &cyclic_probability,
> - &EDGE_INFO (e)->back_edge_prob);
> + cyclic_probability += EDGE_INFO (e)->back_edge_prob;
> }
> else if (!(e->flags & EDGE_DFS_BACK))
> {
> - sreal tmp;
> -
> /* frequency += (e->probability
> * BLOCK_INFO (e->src)->frequency /
> REG_BR_PROB_BASE); */
>
> - sreal_init (&tmp, e->probability, 0);
> - sreal_mul (&tmp, &tmp, &BLOCK_INFO (e->src)->frequency);
> - sreal_mul (&tmp, &tmp, &real_inv_br_prob_base);
> - sreal_add (&frequency, &frequency, &tmp);
> + sreal tmp (e->probability, 0);
> + tmp *= BLOCK_INFO (e->src)->frequency;
> + tmp *= real_inv_br_prob_base;
> + frequency += tmp;
> }
>
> - if (sreal_compare (&cyclic_probability, &real_zero) == 0)
> + if (cyclic_probability == real_zero)
> {
> - memcpy (&BLOCK_INFO (bb)->frequency, &frequency,
> - sizeof (frequency));
> + BLOCK_INFO (bb)->frequency = frequency;
> }
> else
> {
> - if (sreal_compare (&cyclic_probability, &real_almost_one) > 0)
> - {
> - memcpy (&cyclic_probability, &real_almost_one,
> - sizeof (real_almost_one));
> - }
> + if (cyclic_probability > real_almost_one)
> + cyclic_probability = real_almost_one;
>
> /* BLOCK_INFO (bb)->frequency = frequency
> / (1 - cyclic_probability) */
>
> - sreal_sub (&cyclic_probability, &real_one, &cyclic_probability);
> - sreal_div (&BLOCK_INFO (bb)->frequency,
> - &frequency, &cyclic_probability);
> + cyclic_probability = real_one - cyclic_probability;
> + BLOCK_INFO (bb)->frequency = frequency / cyclic_probability;
> }
> }
>
> @@ -2640,16 +2630,13 @@ propagate_freq (basic_block head, bitmap tovisit)
> e = find_edge (bb, head);
> if (e)
> {
> - sreal tmp;
> -
> /* EDGE_INFO (e)->back_edge_prob
> = ((e->probability * BLOCK_INFO (bb)->frequency)
> / REG_BR_PROB_BASE); */
>
> - sreal_init (&tmp, e->probability, 0);
> - sreal_mul (&tmp, &tmp, &BLOCK_INFO (bb)->frequency);
> - sreal_mul (&EDGE_INFO (e)->back_edge_prob,
> - &tmp, &real_inv_br_prob_base);
> + sreal tmp (e->probability, 0);
> + tmp *= BLOCK_INFO (bb)->frequency;
> + EDGE_INFO (e)->back_edge_prob = tmp * real_inv_br_prob_base;
> }
>
> /* Propagate to successor blocks. */
> @@ -2929,13 +2916,13 @@ estimate_bb_frequencies (bool force)
> if (!real_values_initialized)
> {
> real_values_initialized = 1;
> - sreal_init (&real_zero, 0, 0);
> - sreal_init (&real_one, 1, 0);
> - sreal_init (&real_br_prob_base, REG_BR_PROB_BASE, 0);
> - sreal_init (&real_bb_freq_max, BB_FREQ_MAX, 0);
> - sreal_init (&real_one_half, 1, -1);
> - sreal_div (&real_inv_br_prob_base, &real_one, &real_br_prob_base);
> - sreal_sub (&real_almost_one, &real_one, &real_inv_br_prob_base);
> + real_zero = sreal (0, 0);
> + real_one = sreal (1, 0);
> + real_br_prob_base = sreal (REG_BR_PROB_BASE, 0);
> + real_bb_freq_max = sreal (BB_FREQ_MAX, 0);
> + real_one_half = sreal (1, -1);
> + real_inv_br_prob_base = real_one / real_br_prob_base;
> + real_almost_one = real_one - real_inv_br_prob_base;
> }
>
> mark_dfs_back_edges ();
> @@ -2953,10 +2940,8 @@ estimate_bb_frequencies (bool force)
>
> FOR_EACH_EDGE (e, ei, bb->succs)
> {
> - sreal_init (&EDGE_INFO (e)->back_edge_prob, e->probability, 0);
> - sreal_mul (&EDGE_INFO (e)->back_edge_prob,
> - &EDGE_INFO (e)->back_edge_prob,
> - &real_inv_br_prob_base);
> + EDGE_INFO (e)->back_edge_prob = sreal (e->probability, 0);
> + EDGE_INFO (e)->back_edge_prob *= real_inv_br_prob_base;
> }
> }
>
> @@ -2964,19 +2949,16 @@ estimate_bb_frequencies (bool force)
> to outermost to examine frequencies for back edges. */
> estimate_loops ();
>
> - memcpy (&freq_max, &real_zero, sizeof (real_zero));
> + freq_max = real_zero;
> FOR_EACH_BB_FN (bb, cfun)
> - if (sreal_compare (&freq_max, &BLOCK_INFO (bb)->frequency) < 0)
> - memcpy (&freq_max, &BLOCK_INFO (bb)->frequency, sizeof (freq_max));
> + if (freq_max < BLOCK_INFO (bb)->frequency)
> + freq_max = BLOCK_INFO (bb)->frequency;
>
> - sreal_div (&freq_max, &real_bb_freq_max, &freq_max);
> + freq_max = real_bb_freq_max / freq_max;
> FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun), NULL, next_bb)
> {
> - sreal tmp;
> -
> - sreal_mul (&tmp, &BLOCK_INFO (bb)->frequency, &freq_max);
> - sreal_add (&tmp, &tmp, &real_one_half);
> - bb->frequency = sreal_to_int (&tmp);
> + sreal tmp = BLOCK_INFO (bb)->frequency * freq_max + real_one_half;
> + bb->frequency = tmp.to_int ();
> }
>
> free_aux_for_blocks ();
> diff --git a/gcc/sreal.c b/gcc/sreal.c
> index 5c429c5..c99aa1e 100644
> --- a/gcc/sreal.c
> +++ b/gcc/sreal.c
> @@ -54,28 +54,18 @@ along with GCC; see the file COPYING3. If not see
> #include "coretypes.h"
> #include "sreal.h"
>
> -static inline void copy (sreal *, sreal *);
> -static inline void shift_right (sreal *, int);
> -static void normalize (sreal *);
> -
> /* Print the content of struct sreal. */
>
> void
> -dump_sreal (FILE *file, sreal *x)
> +sreal::dump (FILE *file) const
> {
> -#if SREAL_PART_BITS < 32
> - fprintf (file, "((" HOST_WIDE_INT_PRINT_UNSIGNED " * 2^16 + "
> - HOST_WIDE_INT_PRINT_UNSIGNED ") * 2^%d)",
> - x->sig_hi, x->sig_lo, x->exp);
> -#else
> - fprintf (file, "(" HOST_WIDE_INT_PRINT_UNSIGNED " * 2^%d)", x->sig, x->exp);
> -#endif
> + fprintf (file, "(" HOST_WIDE_INT_PRINT_UNSIGNED " * 2^%d)", m_sig, m_exp);
> }
>
> DEBUG_FUNCTION void
> debug (sreal &ref)
> {
> - dump_sreal (stderr, &ref);
> + ref.dump (stderr);
> }
>
> DEBUG_FUNCTION void
> @@ -87,472 +77,195 @@ debug (sreal *ptr)
> fprintf (stderr, "<nil>\n");
> }
>
> +/* Shift this right by S bits. Needed: 0 < S <= SREAL_BITS.
> + When the most significant bit shifted out is 1, add 1 to this (rounding).
> + */
>
> -/* Copy the sreal number. */
> -
> -static inline void
> -copy (sreal *r, sreal *a)
> -{
> -#if SREAL_PART_BITS < 32
> - r->sig_lo = a->sig_lo;
> - r->sig_hi = a->sig_hi;
> -#else
> - r->sig = a->sig;
> -#endif
> - r->exp = a->exp;
> -}
> -
> -/* 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). */
> -
> -static inline void
> -shift_right (sreal *x, int s)
> +void
> +sreal::shift_right (int s)
> {
> gcc_assert (s > 0);
> gcc_assert (s <= SREAL_BITS);
> /* 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. */
> - gcc_assert (x->exp + s <= SREAL_MAX_EXP);
> + gcc_assert (m_exp + s <= SREAL_MAX_EXP);
>
> - x->exp += s;
> + m_exp += s;
>
> -#if SREAL_PART_BITS < 32
> - if (s > SREAL_PART_BITS)
> - {
> - s -= SREAL_PART_BITS;
> - x->sig_hi += (uhwi) 1 << (s - 1);
> - x->sig_lo = x->sig_hi >> s;
> - x->sig_hi = 0;
> - }
> - else
> - {
> - x->sig_lo += (uhwi) 1 << (s - 1);
> - if (x->sig_lo & ((uhwi) 1 << SREAL_PART_BITS))
> - {
> - x->sig_hi++;
> - x->sig_lo -= (uhwi) 1 << SREAL_PART_BITS;
> - }
> - x->sig_lo >>= s;
> - x->sig_lo |= (x->sig_hi & (((uhwi) 1 << s) - 1)) << (SREAL_PART_BITS - s);
> - x->sig_hi >>= s;
> - }
> -#else
> - x->sig += (uhwi) 1 << (s - 1);
> - x->sig >>= s;
> -#endif
> + m_sig += (uhwi) 1 << (s - 1);
> + m_sig >>= s;
> }
>
> -/* Normalize *X. */
> +/* Normalize *this. */
>
> -static void
> -normalize (sreal *x)
> +void
> +sreal::normalize ()
> {
> -#if SREAL_PART_BITS < 32
> - int shift;
> - HOST_WIDE_INT mask;
> -
> - if (x->sig_lo == 0 && x->sig_hi == 0)
> - {
> - x->exp = -SREAL_MAX_EXP;
> - }
> - else if (x->sig_hi < SREAL_MIN_SIG)
> - {
> - if (x->sig_hi == 0)
> - {
> - /* Move lower part of significant to higher part. */
> - x->sig_hi = x->sig_lo;
> - x->sig_lo = 0;
> - x->exp -= SREAL_PART_BITS;
> - }
> - shift = 0;
> - while (x->sig_hi < SREAL_MIN_SIG)
> - {
> - x->sig_hi <<= 1;
> - x->exp--;
> - shift++;
> - }
> - /* Check underflow. */
> - if (x->exp < -SREAL_MAX_EXP)
> - {
> - x->exp = -SREAL_MAX_EXP;
> - x->sig_hi = 0;
> - x->sig_lo = 0;
> - }
> - else if (shift)
> - {
> - mask = (1 << SREAL_PART_BITS) - (1 << (SREAL_PART_BITS - shift));
> - x->sig_hi |= (x->sig_lo & mask) >> (SREAL_PART_BITS - shift);
> - x->sig_lo = (x->sig_lo << shift) & (((uhwi) 1 << SREAL_PART_BITS) - 1);
> - }
> - }
> - else if (x->sig_hi > SREAL_MAX_SIG)
> - {
> - unsigned HOST_WIDE_INT tmp = x->sig_hi;
> -
> - /* Find out how many bits will be shifted. */
> - shift = 0;
> - do
> - {
> - tmp >>= 1;
> - shift++;
> - }
> - while (tmp > SREAL_MAX_SIG);
> -
> - /* Round the number. */
> - x->sig_lo += (uhwi) 1 << (shift - 1);
> -
> - x->sig_lo >>= shift;
> - x->sig_lo += ((x->sig_hi & (((uhwi) 1 << shift) - 1))
> - << (SREAL_PART_BITS - shift));
> - x->sig_hi >>= shift;
> - x->exp += shift;
> - if (x->sig_lo & ((uhwi) 1 << SREAL_PART_BITS))
> - {
> - x->sig_lo -= (uhwi) 1 << SREAL_PART_BITS;
> - x->sig_hi++;
> - if (x->sig_hi > SREAL_MAX_SIG)
> - {
> - /* x->sig_hi was SREAL_MAX_SIG before increment
> - so now last bit is zero. */
> - x->sig_hi >>= 1;
> - x->sig_lo >>= 1;
> - x->exp++;
> - }
> - }
> -
> - /* Check overflow. */
> - if (x->exp > SREAL_MAX_EXP)
> - {
> - x->exp = SREAL_MAX_EXP;
> - x->sig_hi = SREAL_MAX_SIG;
> - x->sig_lo = SREAL_MAX_SIG;
> - }
> - }
> -#else
> - if (x->sig == 0)
> + if (m_sig == 0)
> {
> - x->exp = -SREAL_MAX_EXP;
> + m_exp = -SREAL_MAX_EXP;
> }
> - else if (x->sig < SREAL_MIN_SIG)
> + else if (m_sig < SREAL_MIN_SIG)
> {
> do
> {
> - x->sig <<= 1;
> - x->exp--;
> + m_sig <<= 1;
> + m_exp--;
> }
> - while (x->sig < SREAL_MIN_SIG);
> + while (m_sig < SREAL_MIN_SIG);
>
> /* Check underflow. */
> - if (x->exp < -SREAL_MAX_EXP)
> + if (m_exp < -SREAL_MAX_EXP)
> {
> - x->exp = -SREAL_MAX_EXP;
> - x->sig = 0;
> + m_exp = -SREAL_MAX_EXP;
> + m_sig = 0;
> }
> }
> - else if (x->sig > SREAL_MAX_SIG)
> + else if (m_sig > SREAL_MAX_SIG)
> {
> int last_bit;
> do
> {
> - last_bit = x->sig & 1;
> - x->sig >>= 1;
> - x->exp++;
> + last_bit = m_sig & 1;
> + m_sig >>= 1;
> + m_exp++;
> }
> - while (x->sig > SREAL_MAX_SIG);
> + while (m_sig > SREAL_MAX_SIG);
>
> /* Round the number. */
> - x->sig += last_bit;
> - if (x->sig > SREAL_MAX_SIG)
> + m_sig += last_bit;
> + if (m_sig > SREAL_MAX_SIG)
> {
> - x->sig >>= 1;
> - x->exp++;
> + m_sig >>= 1;
> + m_exp++;
> }
>
> /* Check overflow. */
> - if (x->exp > SREAL_MAX_EXP)
> + if (m_exp > SREAL_MAX_EXP)
> {
> - x->exp = SREAL_MAX_EXP;
> - x->sig = SREAL_MAX_SIG;
> + m_exp = SREAL_MAX_EXP;
> + m_sig = SREAL_MAX_SIG;
> }
> }
> -#endif
> -}
> -
> -/* Set *R to SIG * 2 ^ EXP. Return R. */
> -
> -sreal *
> -sreal_init (sreal *r, unsigned HOST_WIDE_INT sig, signed int exp)
> -{
> -#if SREAL_PART_BITS < 32
> - r->sig_lo = 0;
> - r->sig_hi = sig;
> - r->exp = exp - 16;
> -#else
> - r->sig = sig;
> - r->exp = exp;
> -#endif
> - normalize (r);
> - return r;
> }
>
> -/* Return integer value of *R. */
> +/* Return integer value of *this. */
>
> -HOST_WIDE_INT
> -sreal_to_int (sreal *r)
> +int64_t
> +sreal::to_int () const
> {
> -#if SREAL_PART_BITS < 32
> - if (r->exp <= -SREAL_BITS)
> + if (m_exp <= -SREAL_BITS)
> return 0;
> - if (r->exp >= 0)
> + if (m_exp >= SREAL_PART_BITS)
> return MAX_HOST_WIDE_INT;
> - return ((r->sig_hi << SREAL_PART_BITS) + r->sig_lo) >> -r->exp;
> -#else
> - if (r->exp <= -SREAL_BITS)
> - return 0;
> - if (r->exp >= SREAL_PART_BITS)
> - return MAX_HOST_WIDE_INT;
> - if (r->exp > 0)
> - return r->sig << r->exp;
> - if (r->exp < 0)
> - return r->sig >> -r->exp;
> - return r->sig;
> -#endif
> + if (m_exp > 0)
> + return m_sig << m_exp;
> + if (m_exp < 0)
> + return m_sig >> -m_exp;
> + return m_sig;
> }
>
> -/* Compare *A and *B. Return -1 if *A < *B, 1 if *A > *B and 0 if *A == *B. */
> +/* Return *this + other. */
>
> -int
> -sreal_compare (sreal *a, sreal *b)
> -{
> - if (a->exp > b->exp)
> - return 1;
> - if (a->exp < b->exp)
> - return -1;
> -#if SREAL_PART_BITS < 32
> - if (a->sig_hi > b->sig_hi)
> - return 1;
> - if (a->sig_hi < b->sig_hi)
> - return -1;
> - if (a->sig_lo > b->sig_lo)
> - return 1;
> - if (a->sig_lo < b->sig_lo)
> - return -1;
> -#else
> - if (a->sig > b->sig)
> - return 1;
> - if (a->sig < b->sig)
> - return -1;
> -#endif
> - return 0;
> -}
> -
> -/* *R = *A + *B. Return R. */
> -
> -sreal *
> -sreal_add (sreal *r, sreal *a, sreal *b)
> +sreal
> +sreal::operator+ (const sreal &other) const
> {
> int dexp;
> - sreal tmp;
> - sreal *bb;
> + sreal tmp, r;
> +const sreal *a_p = this, *b_p = &other, *bb;
>
> - if (sreal_compare (a, b) < 0)
> + if (*a_p < *b_p)
> {
> - sreal *swap;
> - swap = a;
> - a = b;
> - b = swap;
> + const sreal *swap;
> + swap = a_p;
> + a_p = b_p;
> + b_p = swap;
> }
>
> - dexp = a->exp - b->exp;
> - r->exp = a->exp;
> + dexp = a_p->m_exp - b_p->m_exp;
> + r.m_exp = a_p->m_exp;
> if (dexp > SREAL_BITS)
> {
> -#if SREAL_PART_BITS < 32
> - r->sig_hi = a->sig_hi;
> - r->sig_lo = a->sig_lo;
> -#else
> - r->sig = a->sig;
> -#endif
> + r.m_sig = a_p->m_sig;
> return r;
> }
>
> if (dexp == 0)
> - bb = b;
> + bb = b_p;
> else
> {
> - copy (&tmp, b);
> - shift_right (&tmp, dexp);
> + tmp = *b_p;
> + tmp.shift_right (dexp);
> bb = &tmp;
> }
>
> -#if SREAL_PART_BITS < 32
> - r->sig_hi = a->sig_hi + bb->sig_hi;
> - r->sig_lo = a->sig_lo + bb->sig_lo;
> - if (r->sig_lo & ((uhwi) 1 << SREAL_PART_BITS))
> - {
> - r->sig_hi++;
> - r->sig_lo -= (uhwi) 1 << SREAL_PART_BITS;
> - }
> -#else
> - r->sig = a->sig + bb->sig;
> -#endif
> - normalize (r);
> + r.m_sig = a_p->m_sig + bb->m_sig;
> + r.normalize ();
> return r;
> }
>
> -/* *R = *A - *B. Return R. */
> +/* Return *this - other. */
>
> -sreal *
> -sreal_sub (sreal *r, sreal *a, sreal *b)
> +sreal
> +sreal::operator- (const sreal &other) const
> {
> int dexp;
> - sreal tmp;
> - sreal *bb;
> + sreal tmp, r;
> + const sreal *bb;
>
> - gcc_assert (sreal_compare (a, b) >= 0);
> + gcc_assert (*this >= other);
>
> - dexp = a->exp - b->exp;
> - r->exp = a->exp;
> + dexp = m_exp - other.m_exp;
> + r.m_exp = m_exp;
> if (dexp > SREAL_BITS)
> {
> -#if SREAL_PART_BITS < 32
> - r->sig_hi = a->sig_hi;
> - r->sig_lo = a->sig_lo;
> -#else
> - r->sig = a->sig;
> -#endif
> + r.m_sig = m_sig;
> return r;
> }
> if (dexp == 0)
> - bb = b;
> + bb = &other;
> else
> {
> - copy (&tmp, b);
> - shift_right (&tmp, dexp);
> + tmp = other;
> + tmp.shift_right (dexp);
> bb = &tmp;
> }
>
> -#if SREAL_PART_BITS < 32
> - if (a->sig_lo < bb->sig_lo)
> - {
> - r->sig_hi = a->sig_hi - bb->sig_hi - 1;
> - r->sig_lo = a->sig_lo + ((uhwi) 1 << SREAL_PART_BITS) - bb->sig_lo;
> - }
> - else
> - {
> - r->sig_hi = a->sig_hi - bb->sig_hi;
> - r->sig_lo = a->sig_lo - bb->sig_lo;
> - }
> -#else
> - r->sig = a->sig - bb->sig;
> -#endif
> - normalize (r);
> + r.m_sig = m_sig - bb->m_sig;
> + r.normalize ();
> return r;
> }
>
> -/* *R = *A * *B. Return R. */
> +/* Return *this * other. */
>
> -sreal *
> -sreal_mul (sreal *r, sreal *a, sreal *b)
> +sreal
> +sreal::operator* (const sreal &other) const
> {
> -#if SREAL_PART_BITS < 32
> - if (a->sig_hi < SREAL_MIN_SIG || b->sig_hi < SREAL_MIN_SIG)
> - {
> - r->sig_lo = 0;
> - r->sig_hi = 0;
> - r->exp = -SREAL_MAX_EXP;
> - }
> - else
> +sreal r;
> + if (m_sig < SREAL_MIN_SIG || other.m_sig < SREAL_MIN_SIG)
> {
> - unsigned HOST_WIDE_INT tmp1, tmp2, tmp3;
> - if (sreal_compare (a, b) < 0)
> - {
> - sreal *swap;
> - swap = a;
> - a = b;
> - b = swap;
> - }
> -
> - r->exp = a->exp + b->exp + SREAL_PART_BITS;
> -
> - tmp1 = a->sig_lo * b->sig_lo;
> - tmp2 = a->sig_lo * b->sig_hi;
> - tmp3 = a->sig_hi * b->sig_lo + (tmp1 >> SREAL_PART_BITS);
> -
> - r->sig_hi = a->sig_hi * b->sig_hi;
> - r->sig_hi += (tmp2 >> SREAL_PART_BITS) + (tmp3 >> SREAL_PART_BITS);
> - tmp2 &= ((uhwi) 1 << SREAL_PART_BITS) - 1;
> - tmp3 &= ((uhwi) 1 << SREAL_PART_BITS) - 1;
> - tmp1 = tmp2 + tmp3;
> -
> - r->sig_lo = tmp1 & (((uhwi) 1 << SREAL_PART_BITS) - 1);
> - r->sig_hi += tmp1 >> SREAL_PART_BITS;
> -
> - normalize (r);
> - }
> -#else
> - if (a->sig < SREAL_MIN_SIG || b->sig < SREAL_MIN_SIG)
> - {
> - r->sig = 0;
> - r->exp = -SREAL_MAX_EXP;
> + r.m_sig = 0;
> + r.m_exp = -SREAL_MAX_EXP;
> }
> else
> {
> - r->sig = a->sig * b->sig;
> - r->exp = a->exp + b->exp;
> - normalize (r);
> + r.m_sig = m_sig * other.m_sig;
> + r.m_exp = m_exp + other.m_exp;
> + r.normalize ();
> }
> -#endif
> return r;
> }
>
> -/* *R = *A / *B. Return R. */
> +/* Return *this / other. */
>
> -sreal *
> -sreal_div (sreal *r, sreal *a, sreal *b)
> +sreal
> +sreal::operator/ (const sreal &other) const
> {
> -#if SREAL_PART_BITS < 32
> - unsigned HOST_WIDE_INT tmp, tmp1, tmp2;
> -
> - gcc_assert (b->sig_hi >= SREAL_MIN_SIG);
> - if (a->sig_hi < SREAL_MIN_SIG)
> - {
> - r->sig_hi = 0;
> - r->sig_lo = 0;
> - r->exp = -SREAL_MAX_EXP;
> - }
> - else
> - {
> - /* Since division by the whole number is pretty ugly to write
> - we are dividing by first 3/4 of bits of number. */
> -
> - tmp1 = (a->sig_hi << SREAL_PART_BITS) + a->sig_lo;
> - tmp2 = ((b->sig_hi << (SREAL_PART_BITS / 2))
> - + (b->sig_lo >> (SREAL_PART_BITS / 2)));
> - if (b->sig_lo & ((uhwi) 1 << ((SREAL_PART_BITS / 2) - 1)))
> - tmp2++;
> -
> - r->sig_lo = 0;
> - tmp = tmp1 / tmp2;
> - tmp1 = (tmp1 % tmp2) << (SREAL_PART_BITS / 2);
> - r->sig_hi = tmp << SREAL_PART_BITS;
> -
> - tmp = tmp1 / tmp2;
> - tmp1 = (tmp1 % tmp2) << (SREAL_PART_BITS / 2);
> - r->sig_hi += tmp << (SREAL_PART_BITS / 2);
> -
> - tmp = tmp1 / tmp2;
> - r->sig_hi += tmp;
> -
> - r->exp = a->exp - b->exp - SREAL_BITS - SREAL_PART_BITS / 2;
> - normalize (r);
> - }
> -#else
> - gcc_assert (b->sig != 0);
> - r->sig = (a->sig << SREAL_PART_BITS) / b->sig;
> - r->exp = a->exp - b->exp - SREAL_PART_BITS;
> - normalize (r);
> -#endif
> + gcc_assert (other.m_sig != 0);
> +sreal r;
> + r.m_sig = (m_sig << SREAL_PART_BITS) / other.m_sig;
> + r.m_exp = m_exp - other.m_exp - SREAL_PART_BITS;
> + r.normalize ();
> return r;
> }
> diff --git a/gcc/sreal.h b/gcc/sreal.h
> index 08d577a..a3db3d5 100644
> --- a/gcc/sreal.h
> +++ b/gcc/sreal.h
> @@ -21,11 +21,7 @@ along with GCC; see the file COPYING3. If not see
> #define GCC_SREAL_H
>
> /* SREAL_PART_BITS has to be an even number. */
> -#if (HOST_BITS_PER_WIDE_INT / 2) % 2 == 1
> -#define SREAL_PART_BITS (HOST_BITS_PER_WIDE_INT / 2 - 1)
> -#else
> #define SREAL_PART_BITS (HOST_BITS_PER_WIDE_INT / 2)
> -#endif
>
> #define uhwi unsigned HOST_WIDE_INT
> #define MAX_HOST_WIDE_INT (((uhwi) 1 << (HOST_BITS_PER_WIDE_INT - 1)) - 1)
> @@ -34,33 +30,86 @@ along with GCC; see the file COPYING3. If not see
> #define SREAL_MAX_SIG (((uhwi) 1 << SREAL_PART_BITS) - 1)
> #define SREAL_MAX_EXP (INT_MAX / 4)
>
> -#if SREAL_PART_BITS < 32
> -#define SREAL_BITS (SREAL_PART_BITS * 2)
> -#else
> #define SREAL_BITS SREAL_PART_BITS
> -#endif
>
> /* Structure for holding a simple real number. */
> -struct sreal
> +class sreal
> {
> -#if SREAL_PART_BITS < 32
> - unsigned HOST_WIDE_INT sig_lo; /* Significant (lower part). */
> - unsigned HOST_WIDE_INT sig_hi; /* Significant (higher part). */
> -#else
> - unsigned HOST_WIDE_INT sig; /* Significant. */
> -#endif
> - signed int exp; /* Exponent. */
> +public:
> + /* Construct an uninitialized sreal. */
> + sreal () : m_sig (-1), m_exp (-1) {}
> +
> + /* Construct a sreal. */
> + sreal (uint64_t sig, int exp) : m_sig (sig), m_exp (exp) { normalize (); }
> +
> + void dump (FILE *) const;
> + int64_t to_int () const;
> +
> + sreal operator+ (const sreal &other) const;
> + sreal operator- (const sreal &other) const;
> + sreal operator* (const sreal &other) const;
> + sreal operator/ (const sreal &other) const;
> +
> + bool operator< (const sreal &other) const
> + {
> + return m_exp < other.m_exp
> + || (m_exp == other.m_exp && m_sig < other.m_sig);
> + }
> +
> + bool operator== (const sreal &other) const
> + {
> + return m_exp == other.m_exp && m_sig == other.m_sig;
> + }
> +
> +private:
> + void normalize ();
> + void shift_right (int amount);
> +
> + uint64_t m_sig; /* Significant. */
> + signed int m_exp; /* Exponent. */
> };
>
> -extern void dump_sreal (FILE *, sreal *);
> extern void debug (sreal &ref);
> extern void debug (sreal *ptr);
> -extern sreal *sreal_init (sreal *, unsigned HOST_WIDE_INT, signed int);
> -extern HOST_WIDE_INT sreal_to_int (sreal *);
> -extern int sreal_compare (sreal *, sreal *);
> -extern sreal *sreal_add (sreal *, sreal *, sreal *);
> -extern sreal *sreal_sub (sreal *, sreal *, sreal *);
> -extern sreal *sreal_mul (sreal *, sreal *, sreal *);
> -extern sreal *sreal_div (sreal *, sreal *, sreal *);
> +
> +inline sreal &operator+= (sreal &a, const sreal &b)
> +{
> + return a = a + b;
> +}
> +
> +inline sreal &operator-= (sreal &a, const sreal &b)
> +{
> +return a = a - b;
> +}
> +
> +inline sreal &operator/= (sreal &a, const sreal &b)
> +{
> +return a = a / b;
> +}
> +
> +inline sreal &operator*= (sreal &a, const sreal &b)
> +{
> + return a = a * b;
> +}
> +
> +inline bool operator!= (const sreal &a, const sreal &b)
> +{
> + return !(a == b);
> +}
> +
> +inline bool operator> (const sreal &a, const sreal &b)
> +{
> + return !(a == b || a < b);
> +}
> +
> +inline bool operator<= (const sreal &a, const sreal &b)
> +{
> + return a < b || a == b;
> +}
> +
> +inline bool operator>= (const sreal &a, const sreal &b)
> +{
> + return a == b || a > b;
> +}
>
> #endif
> --
> 2.1.1
>
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH] c++ify sreal
2014-10-24 8:56 ` Richard Biener
@ 2014-11-11 6:51 ` Andrew Pinski
0 siblings, 0 replies; 11+ messages in thread
From: Andrew Pinski @ 2014-11-11 6:51 UTC (permalink / raw)
To: Richard Biener; +Cc: Trevor Saunders, GCC Patches
On Fri, Oct 24, 2014 at 1:55 AM, Richard Biener
<richard.guenther@gmail.com> wrote:
> On Fri, Oct 24, 2014 at 8:28 AM, <tsaunders@mozilla.com> wrote:
>> From: Trevor Saunders <tsaunders@mozilla.com>
>>
>> Hi,
>>
>> do $subject, and cleanup for always 64 bit hwi.
>>
>>
>> bootstrapped + regtested x86_64-unknown-linux-gnu, ok?
>
> Ok. Can you please replace remaining HOST_WIDE_INT
> vestiges in there with [u]int64_t please?
This patch breaks the build on debian 6.0:
../../gcc/sreal.c: In member function ‘int64_t sreal::to_int() const’:
../../gcc/sreal.c:159: error: ‘INT64_MAX’ was not declared in this scope
Thanks,
Andrew Pinski
>
> Thanks,
> Richard.
>
>> Trev
>>
>> gcc/ChangeLog:
>>
>> 2014-10-24 Trevor Saunders <tsaunders@mozilla.com>
>>
>> * ipa-inline.c (edge_badness): Adjust.
>> (inline_small_functions): Likewise.
>> * predict.c (propagate_freq): Likewise.
>> (estimate_bb_frequencies): Likewise.
>> * sreal.c (sreal::dump): Rename from dump_sreal.
>> (debug): Adjust.
>> (copy): Remove function.
>> (sreal::shift_right): Rename from sreal_sift_right.
>> (sreal::normalize): Rename from normalize.
>> (sreal_init): Remove function.
>> (sreal::to_int): Rename from sreal_to_int.
>> (sreal_compare): Remove function.
>> (sreal::operator+): Rename from sreal_add.
>> (sreal::operator-): Rename from sreal_sub.
>> (sreal::operator*): Rename from sreal_mul.
>> (sreal::operator/): Rename from sreal_div.
>> * sreal.h (class sreal): Adjust.
>> (inline sreal &operator+=): New operator.
>> (inline sreal &operator-=): Likewise.
>> (inline sreal &operator/=): Likewise.
>> (inline sreal &operator*=): Likewise.
>> (inline bool operator!=): Likewise.
>> (inline bool operator>): Likewise.
>> (inline bool operator<=): Likewise.
>> (inline bool operator>=): Likewise.
>> ---
>> gcc/ipa-inline.c | 25 ++-
>> gcc/predict.c | 82 ++++------
>> gcc/sreal.c | 479 +++++++++++--------------------------------------------
>> gcc/sreal.h | 97 ++++++++---
>> 4 files changed, 213 insertions(+), 470 deletions(-)
>>
>> diff --git a/gcc/ipa-inline.c b/gcc/ipa-inline.c
>> index e79a4dd..cca1fb3 100644
>> --- a/gcc/ipa-inline.c
>> +++ b/gcc/ipa-inline.c
>> @@ -939,29 +939,28 @@ edge_badness (struct cgraph_edge *edge, bool dump)
>>
>> else if (max_count)
>> {
>> - sreal tmp, relbenefit_real, growth_real;
>> int relbenefit = relative_time_benefit (callee_info, edge, edge_time);
>> /* Capping edge->count to max_count. edge->count can be larger than
>> max_count if an inline adds new edges which increase max_count
>> after max_count is computed. */
>> gcov_type edge_count = edge->count > max_count ? max_count : edge->count;
>>
>> - sreal_init (&relbenefit_real, relbenefit, 0);
>> - sreal_init (&growth_real, growth, 0);
>> + sreal relbenefit_real (relbenefit, 0);
>> + sreal growth_real (growth, 0);
>>
>> /* relative_edge_count. */
>> - sreal_init (&tmp, edge_count, 0);
>> - sreal_div (&tmp, &tmp, &max_count_real);
>> + sreal tmp (edge_count, 0);
>> + tmp /= max_count_real;
>>
>> /* relative_time_benefit. */
>> - sreal_mul (&tmp, &tmp, &relbenefit_real);
>> - sreal_div (&tmp, &tmp, &max_relbenefit_real);
>> + tmp *= relbenefit_real;
>> + tmp /= max_relbenefit_real;
>>
>> /* growth_f_caller. */
>> - sreal_mul (&tmp, &tmp, &half_int_min_real);
>> - sreal_div (&tmp, &tmp, &growth_real);
>> + tmp *= half_int_min_real;
>> + tmp /= growth_real;
>>
>> - badness = -1 * sreal_to_int (&tmp);
>> + badness = -1 * tmp.to_int ();
>>
>> if (dump)
>> {
>> @@ -1604,9 +1603,9 @@ inline_small_functions (void)
>> if (max_count < edge->count)
>> max_count = edge->count;
>> }
>> - sreal_init (&max_count_real, max_count, 0);
>> - sreal_init (&max_relbenefit_real, RELATIVE_TIME_BENEFIT_RANGE, 0);
>> - sreal_init (&half_int_min_real, INT_MAX / 2, 0);
>> + max_count_real = sreal (max_count, 0);
>> + max_relbenefit_real = sreal (RELATIVE_TIME_BENEFIT_RANGE, 0);
>> + half_int_min_real = sreal (INT_MAX / 2, 0);
>> ipa_free_postorder_info ();
>> initialize_growth_caches ();
>>
>> diff --git a/gcc/predict.c b/gcc/predict.c
>> index 5f5d4a5..10675c3 100644
>> --- a/gcc/predict.c
>> +++ b/gcc/predict.c
>> @@ -2571,15 +2571,13 @@ propagate_freq (basic_block head, bitmap tovisit)
>> bb->count = bb->frequency = 0;
>> }
>>
>> - memcpy (&BLOCK_INFO (head)->frequency, &real_one, sizeof (real_one));
>> + BLOCK_INFO (head)->frequency = real_one;
>> last = head;
>> for (bb = head; bb; bb = nextbb)
>> {
>> edge_iterator ei;
>> - sreal cyclic_probability, frequency;
>> -
>> - memcpy (&cyclic_probability, &real_zero, sizeof (real_zero));
>> - memcpy (&frequency, &real_zero, sizeof (real_zero));
>> + sreal cyclic_probability = real_zero;
>> + sreal frequency = real_zero;
>>
>> nextbb = BLOCK_INFO (bb)->next;
>> BLOCK_INFO (bb)->next = NULL;
>> @@ -2596,42 +2594,34 @@ propagate_freq (basic_block head, bitmap tovisit)
>> FOR_EACH_EDGE (e, ei, bb->preds)
>> if (EDGE_INFO (e)->back_edge)
>> {
>> - sreal_add (&cyclic_probability, &cyclic_probability,
>> - &EDGE_INFO (e)->back_edge_prob);
>> + cyclic_probability += EDGE_INFO (e)->back_edge_prob;
>> }
>> else if (!(e->flags & EDGE_DFS_BACK))
>> {
>> - sreal tmp;
>> -
>> /* frequency += (e->probability
>> * BLOCK_INFO (e->src)->frequency /
>> REG_BR_PROB_BASE); */
>>
>> - sreal_init (&tmp, e->probability, 0);
>> - sreal_mul (&tmp, &tmp, &BLOCK_INFO (e->src)->frequency);
>> - sreal_mul (&tmp, &tmp, &real_inv_br_prob_base);
>> - sreal_add (&frequency, &frequency, &tmp);
>> + sreal tmp (e->probability, 0);
>> + tmp *= BLOCK_INFO (e->src)->frequency;
>> + tmp *= real_inv_br_prob_base;
>> + frequency += tmp;
>> }
>>
>> - if (sreal_compare (&cyclic_probability, &real_zero) == 0)
>> + if (cyclic_probability == real_zero)
>> {
>> - memcpy (&BLOCK_INFO (bb)->frequency, &frequency,
>> - sizeof (frequency));
>> + BLOCK_INFO (bb)->frequency = frequency;
>> }
>> else
>> {
>> - if (sreal_compare (&cyclic_probability, &real_almost_one) > 0)
>> - {
>> - memcpy (&cyclic_probability, &real_almost_one,
>> - sizeof (real_almost_one));
>> - }
>> + if (cyclic_probability > real_almost_one)
>> + cyclic_probability = real_almost_one;
>>
>> /* BLOCK_INFO (bb)->frequency = frequency
>> / (1 - cyclic_probability) */
>>
>> - sreal_sub (&cyclic_probability, &real_one, &cyclic_probability);
>> - sreal_div (&BLOCK_INFO (bb)->frequency,
>> - &frequency, &cyclic_probability);
>> + cyclic_probability = real_one - cyclic_probability;
>> + BLOCK_INFO (bb)->frequency = frequency / cyclic_probability;
>> }
>> }
>>
>> @@ -2640,16 +2630,13 @@ propagate_freq (basic_block head, bitmap tovisit)
>> e = find_edge (bb, head);
>> if (e)
>> {
>> - sreal tmp;
>> -
>> /* EDGE_INFO (e)->back_edge_prob
>> = ((e->probability * BLOCK_INFO (bb)->frequency)
>> / REG_BR_PROB_BASE); */
>>
>> - sreal_init (&tmp, e->probability, 0);
>> - sreal_mul (&tmp, &tmp, &BLOCK_INFO (bb)->frequency);
>> - sreal_mul (&EDGE_INFO (e)->back_edge_prob,
>> - &tmp, &real_inv_br_prob_base);
>> + sreal tmp (e->probability, 0);
>> + tmp *= BLOCK_INFO (bb)->frequency;
>> + EDGE_INFO (e)->back_edge_prob = tmp * real_inv_br_prob_base;
>> }
>>
>> /* Propagate to successor blocks. */
>> @@ -2929,13 +2916,13 @@ estimate_bb_frequencies (bool force)
>> if (!real_values_initialized)
>> {
>> real_values_initialized = 1;
>> - sreal_init (&real_zero, 0, 0);
>> - sreal_init (&real_one, 1, 0);
>> - sreal_init (&real_br_prob_base, REG_BR_PROB_BASE, 0);
>> - sreal_init (&real_bb_freq_max, BB_FREQ_MAX, 0);
>> - sreal_init (&real_one_half, 1, -1);
>> - sreal_div (&real_inv_br_prob_base, &real_one, &real_br_prob_base);
>> - sreal_sub (&real_almost_one, &real_one, &real_inv_br_prob_base);
>> + real_zero = sreal (0, 0);
>> + real_one = sreal (1, 0);
>> + real_br_prob_base = sreal (REG_BR_PROB_BASE, 0);
>> + real_bb_freq_max = sreal (BB_FREQ_MAX, 0);
>> + real_one_half = sreal (1, -1);
>> + real_inv_br_prob_base = real_one / real_br_prob_base;
>> + real_almost_one = real_one - real_inv_br_prob_base;
>> }
>>
>> mark_dfs_back_edges ();
>> @@ -2953,10 +2940,8 @@ estimate_bb_frequencies (bool force)
>>
>> FOR_EACH_EDGE (e, ei, bb->succs)
>> {
>> - sreal_init (&EDGE_INFO (e)->back_edge_prob, e->probability, 0);
>> - sreal_mul (&EDGE_INFO (e)->back_edge_prob,
>> - &EDGE_INFO (e)->back_edge_prob,
>> - &real_inv_br_prob_base);
>> + EDGE_INFO (e)->back_edge_prob = sreal (e->probability, 0);
>> + EDGE_INFO (e)->back_edge_prob *= real_inv_br_prob_base;
>> }
>> }
>>
>> @@ -2964,19 +2949,16 @@ estimate_bb_frequencies (bool force)
>> to outermost to examine frequencies for back edges. */
>> estimate_loops ();
>>
>> - memcpy (&freq_max, &real_zero, sizeof (real_zero));
>> + freq_max = real_zero;
>> FOR_EACH_BB_FN (bb, cfun)
>> - if (sreal_compare (&freq_max, &BLOCK_INFO (bb)->frequency) < 0)
>> - memcpy (&freq_max, &BLOCK_INFO (bb)->frequency, sizeof (freq_max));
>> + if (freq_max < BLOCK_INFO (bb)->frequency)
>> + freq_max = BLOCK_INFO (bb)->frequency;
>>
>> - sreal_div (&freq_max, &real_bb_freq_max, &freq_max);
>> + freq_max = real_bb_freq_max / freq_max;
>> FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun), NULL, next_bb)
>> {
>> - sreal tmp;
>> -
>> - sreal_mul (&tmp, &BLOCK_INFO (bb)->frequency, &freq_max);
>> - sreal_add (&tmp, &tmp, &real_one_half);
>> - bb->frequency = sreal_to_int (&tmp);
>> + sreal tmp = BLOCK_INFO (bb)->frequency * freq_max + real_one_half;
>> + bb->frequency = tmp.to_int ();
>> }
>>
>> free_aux_for_blocks ();
>> diff --git a/gcc/sreal.c b/gcc/sreal.c
>> index 5c429c5..c99aa1e 100644
>> --- a/gcc/sreal.c
>> +++ b/gcc/sreal.c
>> @@ -54,28 +54,18 @@ along with GCC; see the file COPYING3. If not see
>> #include "coretypes.h"
>> #include "sreal.h"
>>
>> -static inline void copy (sreal *, sreal *);
>> -static inline void shift_right (sreal *, int);
>> -static void normalize (sreal *);
>> -
>> /* Print the content of struct sreal. */
>>
>> void
>> -dump_sreal (FILE *file, sreal *x)
>> +sreal::dump (FILE *file) const
>> {
>> -#if SREAL_PART_BITS < 32
>> - fprintf (file, "((" HOST_WIDE_INT_PRINT_UNSIGNED " * 2^16 + "
>> - HOST_WIDE_INT_PRINT_UNSIGNED ") * 2^%d)",
>> - x->sig_hi, x->sig_lo, x->exp);
>> -#else
>> - fprintf (file, "(" HOST_WIDE_INT_PRINT_UNSIGNED " * 2^%d)", x->sig, x->exp);
>> -#endif
>> + fprintf (file, "(" HOST_WIDE_INT_PRINT_UNSIGNED " * 2^%d)", m_sig, m_exp);
>> }
>>
>> DEBUG_FUNCTION void
>> debug (sreal &ref)
>> {
>> - dump_sreal (stderr, &ref);
>> + ref.dump (stderr);
>> }
>>
>> DEBUG_FUNCTION void
>> @@ -87,472 +77,195 @@ debug (sreal *ptr)
>> fprintf (stderr, "<nil>\n");
>> }
>>
>> +/* Shift this right by S bits. Needed: 0 < S <= SREAL_BITS.
>> + When the most significant bit shifted out is 1, add 1 to this (rounding).
>> + */
>>
>> -/* Copy the sreal number. */
>> -
>> -static inline void
>> -copy (sreal *r, sreal *a)
>> -{
>> -#if SREAL_PART_BITS < 32
>> - r->sig_lo = a->sig_lo;
>> - r->sig_hi = a->sig_hi;
>> -#else
>> - r->sig = a->sig;
>> -#endif
>> - r->exp = a->exp;
>> -}
>> -
>> -/* 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). */
>> -
>> -static inline void
>> -shift_right (sreal *x, int s)
>> +void
>> +sreal::shift_right (int s)
>> {
>> gcc_assert (s > 0);
>> gcc_assert (s <= SREAL_BITS);
>> /* 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. */
>> - gcc_assert (x->exp + s <= SREAL_MAX_EXP);
>> + gcc_assert (m_exp + s <= SREAL_MAX_EXP);
>>
>> - x->exp += s;
>> + m_exp += s;
>>
>> -#if SREAL_PART_BITS < 32
>> - if (s > SREAL_PART_BITS)
>> - {
>> - s -= SREAL_PART_BITS;
>> - x->sig_hi += (uhwi) 1 << (s - 1);
>> - x->sig_lo = x->sig_hi >> s;
>> - x->sig_hi = 0;
>> - }
>> - else
>> - {
>> - x->sig_lo += (uhwi) 1 << (s - 1);
>> - if (x->sig_lo & ((uhwi) 1 << SREAL_PART_BITS))
>> - {
>> - x->sig_hi++;
>> - x->sig_lo -= (uhwi) 1 << SREAL_PART_BITS;
>> - }
>> - x->sig_lo >>= s;
>> - x->sig_lo |= (x->sig_hi & (((uhwi) 1 << s) - 1)) << (SREAL_PART_BITS - s);
>> - x->sig_hi >>= s;
>> - }
>> -#else
>> - x->sig += (uhwi) 1 << (s - 1);
>> - x->sig >>= s;
>> -#endif
>> + m_sig += (uhwi) 1 << (s - 1);
>> + m_sig >>= s;
>> }
>>
>> -/* Normalize *X. */
>> +/* Normalize *this. */
>>
>> -static void
>> -normalize (sreal *x)
>> +void
>> +sreal::normalize ()
>> {
>> -#if SREAL_PART_BITS < 32
>> - int shift;
>> - HOST_WIDE_INT mask;
>> -
>> - if (x->sig_lo == 0 && x->sig_hi == 0)
>> - {
>> - x->exp = -SREAL_MAX_EXP;
>> - }
>> - else if (x->sig_hi < SREAL_MIN_SIG)
>> - {
>> - if (x->sig_hi == 0)
>> - {
>> - /* Move lower part of significant to higher part. */
>> - x->sig_hi = x->sig_lo;
>> - x->sig_lo = 0;
>> - x->exp -= SREAL_PART_BITS;
>> - }
>> - shift = 0;
>> - while (x->sig_hi < SREAL_MIN_SIG)
>> - {
>> - x->sig_hi <<= 1;
>> - x->exp--;
>> - shift++;
>> - }
>> - /* Check underflow. */
>> - if (x->exp < -SREAL_MAX_EXP)
>> - {
>> - x->exp = -SREAL_MAX_EXP;
>> - x->sig_hi = 0;
>> - x->sig_lo = 0;
>> - }
>> - else if (shift)
>> - {
>> - mask = (1 << SREAL_PART_BITS) - (1 << (SREAL_PART_BITS - shift));
>> - x->sig_hi |= (x->sig_lo & mask) >> (SREAL_PART_BITS - shift);
>> - x->sig_lo = (x->sig_lo << shift) & (((uhwi) 1 << SREAL_PART_BITS) - 1);
>> - }
>> - }
>> - else if (x->sig_hi > SREAL_MAX_SIG)
>> - {
>> - unsigned HOST_WIDE_INT tmp = x->sig_hi;
>> -
>> - /* Find out how many bits will be shifted. */
>> - shift = 0;
>> - do
>> - {
>> - tmp >>= 1;
>> - shift++;
>> - }
>> - while (tmp > SREAL_MAX_SIG);
>> -
>> - /* Round the number. */
>> - x->sig_lo += (uhwi) 1 << (shift - 1);
>> -
>> - x->sig_lo >>= shift;
>> - x->sig_lo += ((x->sig_hi & (((uhwi) 1 << shift) - 1))
>> - << (SREAL_PART_BITS - shift));
>> - x->sig_hi >>= shift;
>> - x->exp += shift;
>> - if (x->sig_lo & ((uhwi) 1 << SREAL_PART_BITS))
>> - {
>> - x->sig_lo -= (uhwi) 1 << SREAL_PART_BITS;
>> - x->sig_hi++;
>> - if (x->sig_hi > SREAL_MAX_SIG)
>> - {
>> - /* x->sig_hi was SREAL_MAX_SIG before increment
>> - so now last bit is zero. */
>> - x->sig_hi >>= 1;
>> - x->sig_lo >>= 1;
>> - x->exp++;
>> - }
>> - }
>> -
>> - /* Check overflow. */
>> - if (x->exp > SREAL_MAX_EXP)
>> - {
>> - x->exp = SREAL_MAX_EXP;
>> - x->sig_hi = SREAL_MAX_SIG;
>> - x->sig_lo = SREAL_MAX_SIG;
>> - }
>> - }
>> -#else
>> - if (x->sig == 0)
>> + if (m_sig == 0)
>> {
>> - x->exp = -SREAL_MAX_EXP;
>> + m_exp = -SREAL_MAX_EXP;
>> }
>> - else if (x->sig < SREAL_MIN_SIG)
>> + else if (m_sig < SREAL_MIN_SIG)
>> {
>> do
>> {
>> - x->sig <<= 1;
>> - x->exp--;
>> + m_sig <<= 1;
>> + m_exp--;
>> }
>> - while (x->sig < SREAL_MIN_SIG);
>> + while (m_sig < SREAL_MIN_SIG);
>>
>> /* Check underflow. */
>> - if (x->exp < -SREAL_MAX_EXP)
>> + if (m_exp < -SREAL_MAX_EXP)
>> {
>> - x->exp = -SREAL_MAX_EXP;
>> - x->sig = 0;
>> + m_exp = -SREAL_MAX_EXP;
>> + m_sig = 0;
>> }
>> }
>> - else if (x->sig > SREAL_MAX_SIG)
>> + else if (m_sig > SREAL_MAX_SIG)
>> {
>> int last_bit;
>> do
>> {
>> - last_bit = x->sig & 1;
>> - x->sig >>= 1;
>> - x->exp++;
>> + last_bit = m_sig & 1;
>> + m_sig >>= 1;
>> + m_exp++;
>> }
>> - while (x->sig > SREAL_MAX_SIG);
>> + while (m_sig > SREAL_MAX_SIG);
>>
>> /* Round the number. */
>> - x->sig += last_bit;
>> - if (x->sig > SREAL_MAX_SIG)
>> + m_sig += last_bit;
>> + if (m_sig > SREAL_MAX_SIG)
>> {
>> - x->sig >>= 1;
>> - x->exp++;
>> + m_sig >>= 1;
>> + m_exp++;
>> }
>>
>> /* Check overflow. */
>> - if (x->exp > SREAL_MAX_EXP)
>> + if (m_exp > SREAL_MAX_EXP)
>> {
>> - x->exp = SREAL_MAX_EXP;
>> - x->sig = SREAL_MAX_SIG;
>> + m_exp = SREAL_MAX_EXP;
>> + m_sig = SREAL_MAX_SIG;
>> }
>> }
>> -#endif
>> -}
>> -
>> -/* Set *R to SIG * 2 ^ EXP. Return R. */
>> -
>> -sreal *
>> -sreal_init (sreal *r, unsigned HOST_WIDE_INT sig, signed int exp)
>> -{
>> -#if SREAL_PART_BITS < 32
>> - r->sig_lo = 0;
>> - r->sig_hi = sig;
>> - r->exp = exp - 16;
>> -#else
>> - r->sig = sig;
>> - r->exp = exp;
>> -#endif
>> - normalize (r);
>> - return r;
>> }
>>
>> -/* Return integer value of *R. */
>> +/* Return integer value of *this. */
>>
>> -HOST_WIDE_INT
>> -sreal_to_int (sreal *r)
>> +int64_t
>> +sreal::to_int () const
>> {
>> -#if SREAL_PART_BITS < 32
>> - if (r->exp <= -SREAL_BITS)
>> + if (m_exp <= -SREAL_BITS)
>> return 0;
>> - if (r->exp >= 0)
>> + if (m_exp >= SREAL_PART_BITS)
>> return MAX_HOST_WIDE_INT;
>> - return ((r->sig_hi << SREAL_PART_BITS) + r->sig_lo) >> -r->exp;
>> -#else
>> - if (r->exp <= -SREAL_BITS)
>> - return 0;
>> - if (r->exp >= SREAL_PART_BITS)
>> - return MAX_HOST_WIDE_INT;
>> - if (r->exp > 0)
>> - return r->sig << r->exp;
>> - if (r->exp < 0)
>> - return r->sig >> -r->exp;
>> - return r->sig;
>> -#endif
>> + if (m_exp > 0)
>> + return m_sig << m_exp;
>> + if (m_exp < 0)
>> + return m_sig >> -m_exp;
>> + return m_sig;
>> }
>>
>> -/* Compare *A and *B. Return -1 if *A < *B, 1 if *A > *B and 0 if *A == *B. */
>> +/* Return *this + other. */
>>
>> -int
>> -sreal_compare (sreal *a, sreal *b)
>> -{
>> - if (a->exp > b->exp)
>> - return 1;
>> - if (a->exp < b->exp)
>> - return -1;
>> -#if SREAL_PART_BITS < 32
>> - if (a->sig_hi > b->sig_hi)
>> - return 1;
>> - if (a->sig_hi < b->sig_hi)
>> - return -1;
>> - if (a->sig_lo > b->sig_lo)
>> - return 1;
>> - if (a->sig_lo < b->sig_lo)
>> - return -1;
>> -#else
>> - if (a->sig > b->sig)
>> - return 1;
>> - if (a->sig < b->sig)
>> - return -1;
>> -#endif
>> - return 0;
>> -}
>> -
>> -/* *R = *A + *B. Return R. */
>> -
>> -sreal *
>> -sreal_add (sreal *r, sreal *a, sreal *b)
>> +sreal
>> +sreal::operator+ (const sreal &other) const
>> {
>> int dexp;
>> - sreal tmp;
>> - sreal *bb;
>> + sreal tmp, r;
>> +const sreal *a_p = this, *b_p = &other, *bb;
>>
>> - if (sreal_compare (a, b) < 0)
>> + if (*a_p < *b_p)
>> {
>> - sreal *swap;
>> - swap = a;
>> - a = b;
>> - b = swap;
>> + const sreal *swap;
>> + swap = a_p;
>> + a_p = b_p;
>> + b_p = swap;
>> }
>>
>> - dexp = a->exp - b->exp;
>> - r->exp = a->exp;
>> + dexp = a_p->m_exp - b_p->m_exp;
>> + r.m_exp = a_p->m_exp;
>> if (dexp > SREAL_BITS)
>> {
>> -#if SREAL_PART_BITS < 32
>> - r->sig_hi = a->sig_hi;
>> - r->sig_lo = a->sig_lo;
>> -#else
>> - r->sig = a->sig;
>> -#endif
>> + r.m_sig = a_p->m_sig;
>> return r;
>> }
>>
>> if (dexp == 0)
>> - bb = b;
>> + bb = b_p;
>> else
>> {
>> - copy (&tmp, b);
>> - shift_right (&tmp, dexp);
>> + tmp = *b_p;
>> + tmp.shift_right (dexp);
>> bb = &tmp;
>> }
>>
>> -#if SREAL_PART_BITS < 32
>> - r->sig_hi = a->sig_hi + bb->sig_hi;
>> - r->sig_lo = a->sig_lo + bb->sig_lo;
>> - if (r->sig_lo & ((uhwi) 1 << SREAL_PART_BITS))
>> - {
>> - r->sig_hi++;
>> - r->sig_lo -= (uhwi) 1 << SREAL_PART_BITS;
>> - }
>> -#else
>> - r->sig = a->sig + bb->sig;
>> -#endif
>> - normalize (r);
>> + r.m_sig = a_p->m_sig + bb->m_sig;
>> + r.normalize ();
>> return r;
>> }
>>
>> -/* *R = *A - *B. Return R. */
>> +/* Return *this - other. */
>>
>> -sreal *
>> -sreal_sub (sreal *r, sreal *a, sreal *b)
>> +sreal
>> +sreal::operator- (const sreal &other) const
>> {
>> int dexp;
>> - sreal tmp;
>> - sreal *bb;
>> + sreal tmp, r;
>> + const sreal *bb;
>>
>> - gcc_assert (sreal_compare (a, b) >= 0);
>> + gcc_assert (*this >= other);
>>
>> - dexp = a->exp - b->exp;
>> - r->exp = a->exp;
>> + dexp = m_exp - other.m_exp;
>> + r.m_exp = m_exp;
>> if (dexp > SREAL_BITS)
>> {
>> -#if SREAL_PART_BITS < 32
>> - r->sig_hi = a->sig_hi;
>> - r->sig_lo = a->sig_lo;
>> -#else
>> - r->sig = a->sig;
>> -#endif
>> + r.m_sig = m_sig;
>> return r;
>> }
>> if (dexp == 0)
>> - bb = b;
>> + bb = &other;
>> else
>> {
>> - copy (&tmp, b);
>> - shift_right (&tmp, dexp);
>> + tmp = other;
>> + tmp.shift_right (dexp);
>> bb = &tmp;
>> }
>>
>> -#if SREAL_PART_BITS < 32
>> - if (a->sig_lo < bb->sig_lo)
>> - {
>> - r->sig_hi = a->sig_hi - bb->sig_hi - 1;
>> - r->sig_lo = a->sig_lo + ((uhwi) 1 << SREAL_PART_BITS) - bb->sig_lo;
>> - }
>> - else
>> - {
>> - r->sig_hi = a->sig_hi - bb->sig_hi;
>> - r->sig_lo = a->sig_lo - bb->sig_lo;
>> - }
>> -#else
>> - r->sig = a->sig - bb->sig;
>> -#endif
>> - normalize (r);
>> + r.m_sig = m_sig - bb->m_sig;
>> + r.normalize ();
>> return r;
>> }
>>
>> -/* *R = *A * *B. Return R. */
>> +/* Return *this * other. */
>>
>> -sreal *
>> -sreal_mul (sreal *r, sreal *a, sreal *b)
>> +sreal
>> +sreal::operator* (const sreal &other) const
>> {
>> -#if SREAL_PART_BITS < 32
>> - if (a->sig_hi < SREAL_MIN_SIG || b->sig_hi < SREAL_MIN_SIG)
>> - {
>> - r->sig_lo = 0;
>> - r->sig_hi = 0;
>> - r->exp = -SREAL_MAX_EXP;
>> - }
>> - else
>> +sreal r;
>> + if (m_sig < SREAL_MIN_SIG || other.m_sig < SREAL_MIN_SIG)
>> {
>> - unsigned HOST_WIDE_INT tmp1, tmp2, tmp3;
>> - if (sreal_compare (a, b) < 0)
>> - {
>> - sreal *swap;
>> - swap = a;
>> - a = b;
>> - b = swap;
>> - }
>> -
>> - r->exp = a->exp + b->exp + SREAL_PART_BITS;
>> -
>> - tmp1 = a->sig_lo * b->sig_lo;
>> - tmp2 = a->sig_lo * b->sig_hi;
>> - tmp3 = a->sig_hi * b->sig_lo + (tmp1 >> SREAL_PART_BITS);
>> -
>> - r->sig_hi = a->sig_hi * b->sig_hi;
>> - r->sig_hi += (tmp2 >> SREAL_PART_BITS) + (tmp3 >> SREAL_PART_BITS);
>> - tmp2 &= ((uhwi) 1 << SREAL_PART_BITS) - 1;
>> - tmp3 &= ((uhwi) 1 << SREAL_PART_BITS) - 1;
>> - tmp1 = tmp2 + tmp3;
>> -
>> - r->sig_lo = tmp1 & (((uhwi) 1 << SREAL_PART_BITS) - 1);
>> - r->sig_hi += tmp1 >> SREAL_PART_BITS;
>> -
>> - normalize (r);
>> - }
>> -#else
>> - if (a->sig < SREAL_MIN_SIG || b->sig < SREAL_MIN_SIG)
>> - {
>> - r->sig = 0;
>> - r->exp = -SREAL_MAX_EXP;
>> + r.m_sig = 0;
>> + r.m_exp = -SREAL_MAX_EXP;
>> }
>> else
>> {
>> - r->sig = a->sig * b->sig;
>> - r->exp = a->exp + b->exp;
>> - normalize (r);
>> + r.m_sig = m_sig * other.m_sig;
>> + r.m_exp = m_exp + other.m_exp;
>> + r.normalize ();
>> }
>> -#endif
>> return r;
>> }
>>
>> -/* *R = *A / *B. Return R. */
>> +/* Return *this / other. */
>>
>> -sreal *
>> -sreal_div (sreal *r, sreal *a, sreal *b)
>> +sreal
>> +sreal::operator/ (const sreal &other) const
>> {
>> -#if SREAL_PART_BITS < 32
>> - unsigned HOST_WIDE_INT tmp, tmp1, tmp2;
>> -
>> - gcc_assert (b->sig_hi >= SREAL_MIN_SIG);
>> - if (a->sig_hi < SREAL_MIN_SIG)
>> - {
>> - r->sig_hi = 0;
>> - r->sig_lo = 0;
>> - r->exp = -SREAL_MAX_EXP;
>> - }
>> - else
>> - {
>> - /* Since division by the whole number is pretty ugly to write
>> - we are dividing by first 3/4 of bits of number. */
>> -
>> - tmp1 = (a->sig_hi << SREAL_PART_BITS) + a->sig_lo;
>> - tmp2 = ((b->sig_hi << (SREAL_PART_BITS / 2))
>> - + (b->sig_lo >> (SREAL_PART_BITS / 2)));
>> - if (b->sig_lo & ((uhwi) 1 << ((SREAL_PART_BITS / 2) - 1)))
>> - tmp2++;
>> -
>> - r->sig_lo = 0;
>> - tmp = tmp1 / tmp2;
>> - tmp1 = (tmp1 % tmp2) << (SREAL_PART_BITS / 2);
>> - r->sig_hi = tmp << SREAL_PART_BITS;
>> -
>> - tmp = tmp1 / tmp2;
>> - tmp1 = (tmp1 % tmp2) << (SREAL_PART_BITS / 2);
>> - r->sig_hi += tmp << (SREAL_PART_BITS / 2);
>> -
>> - tmp = tmp1 / tmp2;
>> - r->sig_hi += tmp;
>> -
>> - r->exp = a->exp - b->exp - SREAL_BITS - SREAL_PART_BITS / 2;
>> - normalize (r);
>> - }
>> -#else
>> - gcc_assert (b->sig != 0);
>> - r->sig = (a->sig << SREAL_PART_BITS) / b->sig;
>> - r->exp = a->exp - b->exp - SREAL_PART_BITS;
>> - normalize (r);
>> -#endif
>> + gcc_assert (other.m_sig != 0);
>> +sreal r;
>> + r.m_sig = (m_sig << SREAL_PART_BITS) / other.m_sig;
>> + r.m_exp = m_exp - other.m_exp - SREAL_PART_BITS;
>> + r.normalize ();
>> return r;
>> }
>> diff --git a/gcc/sreal.h b/gcc/sreal.h
>> index 08d577a..a3db3d5 100644
>> --- a/gcc/sreal.h
>> +++ b/gcc/sreal.h
>> @@ -21,11 +21,7 @@ along with GCC; see the file COPYING3. If not see
>> #define GCC_SREAL_H
>>
>> /* SREAL_PART_BITS has to be an even number. */
>> -#if (HOST_BITS_PER_WIDE_INT / 2) % 2 == 1
>> -#define SREAL_PART_BITS (HOST_BITS_PER_WIDE_INT / 2 - 1)
>> -#else
>> #define SREAL_PART_BITS (HOST_BITS_PER_WIDE_INT / 2)
>> -#endif
>>
>> #define uhwi unsigned HOST_WIDE_INT
>> #define MAX_HOST_WIDE_INT (((uhwi) 1 << (HOST_BITS_PER_WIDE_INT - 1)) - 1)
>> @@ -34,33 +30,86 @@ along with GCC; see the file COPYING3. If not see
>> #define SREAL_MAX_SIG (((uhwi) 1 << SREAL_PART_BITS) - 1)
>> #define SREAL_MAX_EXP (INT_MAX / 4)
>>
>> -#if SREAL_PART_BITS < 32
>> -#define SREAL_BITS (SREAL_PART_BITS * 2)
>> -#else
>> #define SREAL_BITS SREAL_PART_BITS
>> -#endif
>>
>> /* Structure for holding a simple real number. */
>> -struct sreal
>> +class sreal
>> {
>> -#if SREAL_PART_BITS < 32
>> - unsigned HOST_WIDE_INT sig_lo; /* Significant (lower part). */
>> - unsigned HOST_WIDE_INT sig_hi; /* Significant (higher part). */
>> -#else
>> - unsigned HOST_WIDE_INT sig; /* Significant. */
>> -#endif
>> - signed int exp; /* Exponent. */
>> +public:
>> + /* Construct an uninitialized sreal. */
>> + sreal () : m_sig (-1), m_exp (-1) {}
>> +
>> + /* Construct a sreal. */
>> + sreal (uint64_t sig, int exp) : m_sig (sig), m_exp (exp) { normalize (); }
>> +
>> + void dump (FILE *) const;
>> + int64_t to_int () const;
>> +
>> + sreal operator+ (const sreal &other) const;
>> + sreal operator- (const sreal &other) const;
>> + sreal operator* (const sreal &other) const;
>> + sreal operator/ (const sreal &other) const;
>> +
>> + bool operator< (const sreal &other) const
>> + {
>> + return m_exp < other.m_exp
>> + || (m_exp == other.m_exp && m_sig < other.m_sig);
>> + }
>> +
>> + bool operator== (const sreal &other) const
>> + {
>> + return m_exp == other.m_exp && m_sig == other.m_sig;
>> + }
>> +
>> +private:
>> + void normalize ();
>> + void shift_right (int amount);
>> +
>> + uint64_t m_sig; /* Significant. */
>> + signed int m_exp; /* Exponent. */
>> };
>>
>> -extern void dump_sreal (FILE *, sreal *);
>> extern void debug (sreal &ref);
>> extern void debug (sreal *ptr);
>> -extern sreal *sreal_init (sreal *, unsigned HOST_WIDE_INT, signed int);
>> -extern HOST_WIDE_INT sreal_to_int (sreal *);
>> -extern int sreal_compare (sreal *, sreal *);
>> -extern sreal *sreal_add (sreal *, sreal *, sreal *);
>> -extern sreal *sreal_sub (sreal *, sreal *, sreal *);
>> -extern sreal *sreal_mul (sreal *, sreal *, sreal *);
>> -extern sreal *sreal_div (sreal *, sreal *, sreal *);
>> +
>> +inline sreal &operator+= (sreal &a, const sreal &b)
>> +{
>> + return a = a + b;
>> +}
>> +
>> +inline sreal &operator-= (sreal &a, const sreal &b)
>> +{
>> +return a = a - b;
>> +}
>> +
>> +inline sreal &operator/= (sreal &a, const sreal &b)
>> +{
>> +return a = a / b;
>> +}
>> +
>> +inline sreal &operator*= (sreal &a, const sreal &b)
>> +{
>> + return a = a * b;
>> +}
>> +
>> +inline bool operator!= (const sreal &a, const sreal &b)
>> +{
>> + return !(a == b);
>> +}
>> +
>> +inline bool operator> (const sreal &a, const sreal &b)
>> +{
>> + return !(a == b || a < b);
>> +}
>> +
>> +inline bool operator<= (const sreal &a, const sreal &b)
>> +{
>> + return a < b || a == b;
>> +}
>> +
>> +inline bool operator>= (const sreal &a, const sreal &b)
>> +{
>> + return a == b || a > b;
>> +}
>>
>> #endif
>> --
>> 2.1.1
>>
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH] c++ify sreal
@ 2014-11-11 8:04 Uros Bizjak
2014-11-11 8:31 ` Jakub Jelinek
0 siblings, 1 reply; 11+ messages in thread
From: Uros Bizjak @ 2014-11-11 8:04 UTC (permalink / raw)
To: gcc-patches; +Cc: Andrew Pinski, Richard Biener, Trevor Saunders
Hello!
>>> do $subject, and cleanup for always 64 bit hwi.
>>>
>>>
>>> bootstrapped + regtested x86_64-unknown-linux-gnu, ok?
>>
>> Ok. Can you please replace remaining HOST_WIDE_INT
>> vestiges in there with [u]int64_t please?
>
>
> This patch breaks the build on debian 6.0:
>
> ../../gcc/sreal.c: In member function âint64_t sreal::to_int() constâ:
> ../../gcc/sreal.c:159: error: âINT64_MAXâ was not declared in this scope
Index: system.h
===================================================================
--- system.h (revision 217338)
+++ system.h (working copy)
@@ -27,6 +27,7 @@
event inttypes.h gets pulled in by another header it is already
defined. */
#define __STDC_FORMAT_MACROS
+#define __STDC_LIMIT_MACROS
/* We must include stdarg.h before stdio.h. */
#include <stdarg.h>
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH] c++ify sreal
2014-11-11 8:04 Uros Bizjak
@ 2014-11-11 8:31 ` Jakub Jelinek
2014-11-11 8:48 ` Uros Bizjak
2014-11-11 9:24 ` Marc Glisse
0 siblings, 2 replies; 11+ messages in thread
From: Jakub Jelinek @ 2014-11-11 8:31 UTC (permalink / raw)
To: Uros Bizjak; +Cc: gcc-patches, Andrew Pinski, Richard Biener, Trevor Saunders
On Tue, Nov 11, 2014 at 08:51:41AM +0100, Uros Bizjak wrote:
> Hello!
>
> >>> do $subject, and cleanup for always 64 bit hwi.
> >>>
> >>>
> >>> bootstrapped + regtested x86_64-unknown-linux-gnu, ok?
> >>
> >> Ok. Can you please replace remaining HOST_WIDE_INT
> >> vestiges in there with [u]int64_t please?
> >
> >
> > This patch breaks the build on debian 6.0:
> >
> > ../../gcc/sreal.c: In member function âint64_t sreal::to_int() constâ:
> > ../../gcc/sreal.c:159: error: âINT64_MAXâ was not declared in this scope
>
> Index: system.h
> ===================================================================
> --- system.h (revision 217338)
> +++ system.h (working copy)
> @@ -27,6 +27,7 @@
> event inttypes.h gets pulled in by another header it is already
> defined. */
> #define __STDC_FORMAT_MACROS
> +#define __STDC_LIMIT_MACROS
>
> /* We must include stdarg.h before stdio.h. */
> #include <stdarg.h>
Still, I don't believe it will be portable everywhere.
Can't you use
INTTYPE_MAXIMUM (int64_t) instead of INT64_MAX? We already use that
in GCC...
Jakub
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH] c++ify sreal
2014-11-11 8:31 ` Jakub Jelinek
@ 2014-11-11 8:48 ` Uros Bizjak
2014-11-11 8:55 ` Jakub Jelinek
2014-11-11 9:24 ` Marc Glisse
1 sibling, 1 reply; 11+ messages in thread
From: Uros Bizjak @ 2014-11-11 8:48 UTC (permalink / raw)
To: Jakub Jelinek; +Cc: gcc-patches, Andrew Pinski, Richard Biener, Trevor Saunders
On Tue, Nov 11, 2014 at 9:11 AM, Jakub Jelinek <jakub@redhat.com> wrote:
>> >>> do $subject, and cleanup for always 64 bit hwi.
>> >>>
>> >>>
>> >>> bootstrapped + regtested x86_64-unknown-linux-gnu, ok?
>> >>
>> >> Ok. Can you please replace remaining HOST_WIDE_INT
>> >> vestiges in there with [u]int64_t please?
>> >
>> >
>> > This patch breaks the build on debian 6.0:
>> >
>> > ../../gcc/sreal.c: In member function āint64_t sreal::to_int() constā:
>> > ../../gcc/sreal.c:159: error: āINT64_MAXā was not declared in this scope
>>
> Still, I don't believe it will be portable everywhere.
> Can't you use
> INTTYPE_MAXIMUM (int64_t) instead of INT64_MAX? We already use that
> in GCC...
Yes, following patch also bootstraps:
--cut here--
Index: sreal.c
===================================================================
--- sreal.c (revision 217338)
+++ sreal.c (working copy)
@@ -156,7 +156,7 @@ sreal::to_int () const
if (m_exp <= -SREAL_BITS)
return 0;
if (m_exp >= SREAL_PART_BITS)
- return INT64_MAX;
+ return INTTYPE_MAXIMUM (int64_t);
if (m_exp > 0)
return m_sig << m_exp;
if (m_exp < 0)
--cut here--
Uros.
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH] c++ify sreal
2014-11-11 8:48 ` Uros Bizjak
@ 2014-11-11 8:55 ` Jakub Jelinek
0 siblings, 0 replies; 11+ messages in thread
From: Jakub Jelinek @ 2014-11-11 8:55 UTC (permalink / raw)
To: Uros Bizjak; +Cc: gcc-patches, Andrew Pinski, Richard Biener, Trevor Saunders
On Tue, Nov 11, 2014 at 09:45:38AM +0100, Uros Bizjak wrote:
> On Tue, Nov 11, 2014 at 9:11 AM, Jakub Jelinek <jakub@redhat.com> wrote:
>
> >> >>> do $subject, and cleanup for always 64 bit hwi.
> >> >>>
> >> >>>
> >> >>> bootstrapped + regtested x86_64-unknown-linux-gnu, ok?
> >> >>
> >> >> Ok. Can you please replace remaining HOST_WIDE_INT
> >> >> vestiges in there with [u]int64_t please?
> >> >
> >> >
> >> > This patch breaks the build on debian 6.0:
> >> >
> >> > ../../gcc/sreal.c: In member function Äint64_t sreal::to_int() constÄ:
> >> > ../../gcc/sreal.c:159: error: ÄINT64_MAXÄ was not declared in this scope
> >>
>
> > Still, I don't believe it will be portable everywhere.
> > Can't you use
> > INTTYPE_MAXIMUM (int64_t) instead of INT64_MAX? We already use that
> > in GCC...
>
> Yes, following patch also bootstraps:
This is ok for trunk with appropriate ChangeLog entry. Thanks.
> --- sreal.c (revision 217338)
> +++ sreal.c (working copy)
> @@ -156,7 +156,7 @@ sreal::to_int () const
> if (m_exp <= -SREAL_BITS)
> return 0;
> if (m_exp >= SREAL_PART_BITS)
> - return INT64_MAX;
> + return INTTYPE_MAXIMUM (int64_t);
> if (m_exp > 0)
> return m_sig << m_exp;
> if (m_exp < 0)
> --cut here--
Jakub
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH] c++ify sreal
2014-11-11 8:31 ` Jakub Jelinek
2014-11-11 8:48 ` Uros Bizjak
@ 2014-11-11 9:24 ` Marc Glisse
2014-11-11 12:11 ` Andrew Pinski
1 sibling, 1 reply; 11+ messages in thread
From: Marc Glisse @ 2014-11-11 9:24 UTC (permalink / raw)
To: Jakub Jelinek
Cc: Uros Bizjak, gcc-patches, Andrew Pinski, Richard Biener, Trevor Saunders
On Tue, 11 Nov 2014, Jakub Jelinek wrote:
> On Tue, Nov 11, 2014 at 08:51:41AM +0100, Uros Bizjak wrote:
>> Hello!
>>
>>>>> do $subject, and cleanup for always 64 bit hwi.
>>>>>
>>>>>
>>>>> bootstrapped + regtested x86_64-unknown-linux-gnu, ok?
>>>>
>>>> Ok. Can you please replace remaining HOST_WIDE_INT
>>>> vestiges in there with [u]int64_t please?
>>>
>>>
>>> This patch breaks the build on debian 6.0:
>>>
>>> ../../gcc/sreal.c: In member function âint64_t sreal::to_int() constâ:
>>> ../../gcc/sreal.c:159: error: âINT64_MAXâ was not declared in this scope
>>
>> Index: system.h
>> ===================================================================
>> --- system.h (revision 217338)
>> +++ system.h (working copy)
>> @@ -27,6 +27,7 @@
>> event inttypes.h gets pulled in by another header it is already
>> defined. */
>> #define __STDC_FORMAT_MACROS
>> +#define __STDC_LIMIT_MACROS
>>
>> /* We must include stdarg.h before stdio.h. */
>> #include <stdarg.h>
>
> Still, I don't believe it will be portable everywhere.
> Can't you use
> INTTYPE_MAXIMUM (int64_t) instead of INT64_MAX? We already use that
> in GCC...
We could also start using the standard C++ mechanism (numeric_limits).
(nothing wrong with INTTYPE_MAXIMUM, just an alternative)
--
Marc Glisse
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH] c++ify sreal
2014-11-11 9:24 ` Marc Glisse
@ 2014-11-11 12:11 ` Andrew Pinski
2014-11-11 12:56 ` Richard Biener
0 siblings, 1 reply; 11+ messages in thread
From: Andrew Pinski @ 2014-11-11 12:11 UTC (permalink / raw)
To: GCC Patches; +Cc: Jakub Jelinek, Uros Bizjak, Richard Biener, Trevor Saunders
On Tue, Nov 11, 2014 at 1:23 AM, Marc Glisse <marc.glisse@inria.fr> wrote:
> On Tue, 11 Nov 2014, Jakub Jelinek wrote:
>
>> On Tue, Nov 11, 2014 at 08:51:41AM +0100, Uros Bizjak wrote:
>>>
>>> Hello!
>>>
>>>>>> do $subject, and cleanup for always 64 bit hwi.
>>>>>>
>>>>>>
>>>>>> bootstrapped + regtested x86_64-unknown-linux-gnu, ok?
>>>>>
>>>>>
>>>>> Ok. Can you please replace remaining HOST_WIDE_INT
>>>>> vestiges in there with [u]int64_t please?
>>>>
>>>>
>>>>
>>>> This patch breaks the build on debian 6.0:
>>>>
>>>> ../../gcc/sreal.c: In member function āint64_t sreal::to_int() constā:
>>>> ../../gcc/sreal.c:159: error: āINT64_MAXā was not declared in this scope
>>>
>>>
>>> Index: system.h
>>> ===================================================================
>>> --- system.h (revision 217338)
>>> +++ system.h (working copy)
>>> @@ -27,6 +27,7 @@
>>> event inttypes.h gets pulled in by another header it is already
>>> defined. */
>>> #define __STDC_FORMAT_MACROS
>>> +#define __STDC_LIMIT_MACROS
>>>
>>> /* We must include stdarg.h before stdio.h. */
>>> #include <stdarg.h>
>>
>>
>> Still, I don't believe it will be portable everywhere.
>> Can't you use
>> INTTYPE_MAXIMUM (int64_t) instead of INT64_MAX? We already use that
>> in GCC...
>
>
> We could also start using the standard C++ mechanism (numeric_limits).
Except int64_t does not have to be defined for a C++ implementation.
Thanks,
Andrew
>
> (nothing wrong with INTTYPE_MAXIMUM, just an alternative)
>
> --
> Marc Glisse
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH] c++ify sreal
2014-11-11 12:11 ` Andrew Pinski
@ 2014-11-11 12:56 ` Richard Biener
2014-11-11 12:57 ` Andrew Pinski
0 siblings, 1 reply; 11+ messages in thread
From: Richard Biener @ 2014-11-11 12:56 UTC (permalink / raw)
To: Andrew Pinski; +Cc: GCC Patches, Jakub Jelinek, Uros Bizjak, Trevor Saunders
On Tue, Nov 11, 2014 at 1:08 PM, Andrew Pinski <pinskia@gmail.com> wrote:
> On Tue, Nov 11, 2014 at 1:23 AM, Marc Glisse <marc.glisse@inria.fr> wrote:
>> On Tue, 11 Nov 2014, Jakub Jelinek wrote:
>>
>>> On Tue, Nov 11, 2014 at 08:51:41AM +0100, Uros Bizjak wrote:
>>>>
>>>> Hello!
>>>>
>>>>>>> do $subject, and cleanup for always 64 bit hwi.
>>>>>>>
>>>>>>>
>>>>>>> bootstrapped + regtested x86_64-unknown-linux-gnu, ok?
>>>>>>
>>>>>>
>>>>>> Ok. Can you please replace remaining HOST_WIDE_INT
>>>>>> vestiges in there with [u]int64_t please?
>>>>>
>>>>>
>>>>>
>>>>> This patch breaks the build on debian 6.0:
>>>>>
>>>>> ../../gcc/sreal.c: In member function āint64_t sreal::to_int() constā:
>>>>> ../../gcc/sreal.c:159: error: āINT64_MAXā was not declared in this scope
>>>>
>>>>
>>>> Index: system.h
>>>> ===================================================================
>>>> --- system.h (revision 217338)
>>>> +++ system.h (working copy)
>>>> @@ -27,6 +27,7 @@
>>>> event inttypes.h gets pulled in by another header it is already
>>>> defined. */
>>>> #define __STDC_FORMAT_MACROS
>>>> +#define __STDC_LIMIT_MACROS
>>>>
>>>> /* We must include stdarg.h before stdio.h. */
>>>> #include <stdarg.h>
>>>
>>>
>>> Still, I don't believe it will be portable everywhere.
>>> Can't you use
>>> INTTYPE_MAXIMUM (int64_t) instead of INT64_MAX? We already use that
>>> in GCC...
>>
>>
>> We could also start using the standard C++ mechanism (numeric_limits).
>
> Except int64_t does not have to be defined for a C++ implementation.
Also not through stdint.h / cstdint? Note that we should only care
for what happens in practice here. I hope that at least for more recent
standards than C++04 (which is what we require IIRC) they are on
parity with C99.
Richard.
> Thanks,
> Andrew
>
>>
>> (nothing wrong with INTTYPE_MAXIMUM, just an alternative)
>>
>> --
>> Marc Glisse
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH] c++ify sreal
2014-11-11 12:56 ` Richard Biener
@ 2014-11-11 12:57 ` Andrew Pinski
0 siblings, 0 replies; 11+ messages in thread
From: Andrew Pinski @ 2014-11-11 12:57 UTC (permalink / raw)
To: Richard Biener; +Cc: GCC Patches, Jakub Jelinek, Uros Bizjak, Trevor Saunders
On Tue, Nov 11, 2014 at 4:54 AM, Richard Biener
<richard.guenther@gmail.com> wrote:
> On Tue, Nov 11, 2014 at 1:08 PM, Andrew Pinski <pinskia@gmail.com> wrote:
>> On Tue, Nov 11, 2014 at 1:23 AM, Marc Glisse <marc.glisse@inria.fr> wrote:
>>> On Tue, 11 Nov 2014, Jakub Jelinek wrote:
>>>
>>>> On Tue, Nov 11, 2014 at 08:51:41AM +0100, Uros Bizjak wrote:
>>>>>
>>>>> Hello!
>>>>>
>>>>>>>> do $subject, and cleanup for always 64 bit hwi.
>>>>>>>>
>>>>>>>>
>>>>>>>> bootstrapped + regtested x86_64-unknown-linux-gnu, ok?
>>>>>>>
>>>>>>>
>>>>>>> Ok. Can you please replace remaining HOST_WIDE_INT
>>>>>>> vestiges in there with [u]int64_t please?
>>>>>>
>>>>>>
>>>>>>
>>>>>> This patch breaks the build on debian 6.0:
>>>>>>
>>>>>> ../../gcc/sreal.c: In member function āint64_t sreal::to_int() constā:
>>>>>> ../../gcc/sreal.c:159: error: āINT64_MAXā was not declared in this scope
>>>>>
>>>>>
>>>>> Index: system.h
>>>>> ===================================================================
>>>>> --- system.h (revision 217338)
>>>>> +++ system.h (working copy)
>>>>> @@ -27,6 +27,7 @@
>>>>> event inttypes.h gets pulled in by another header it is already
>>>>> defined. */
>>>>> #define __STDC_FORMAT_MACROS
>>>>> +#define __STDC_LIMIT_MACROS
>>>>>
>>>>> /* We must include stdarg.h before stdio.h. */
>>>>> #include <stdarg.h>
>>>>
>>>>
>>>> Still, I don't believe it will be portable everywhere.
>>>> Can't you use
>>>> INTTYPE_MAXIMUM (int64_t) instead of INT64_MAX? We already use that
>>>> in GCC...
>>>
>>>
>>> We could also start using the standard C++ mechanism (numeric_limits).
>>
>> Except int64_t does not have to be defined for a C++ implementation.
>
> Also not through stdint.h / cstdint? Note that we should only care
> for what happens in practice here. I hope that at least for more recent
> standards than C++04 (which is what we require IIRC) they are on
> parity with C99.
C++03 did not add long long, only C++11 did.
Thanks,
Andrew Pinski
>
> Richard.
>
>> Thanks,
>> Andrew
>>
>>>
>>> (nothing wrong with INTTYPE_MAXIMUM, just an alternative)
>>>
>>> --
>>> Marc Glisse
^ permalink raw reply [flat|nested] 11+ messages in thread
end of thread, other threads:[~2014-11-11 12:57 UTC | newest]
Thread overview: 11+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2014-10-24 6:30 [PATCH] c++ify sreal tsaunders
2014-10-24 8:56 ` Richard Biener
2014-11-11 6:51 ` Andrew Pinski
2014-11-11 8:04 Uros Bizjak
2014-11-11 8:31 ` Jakub Jelinek
2014-11-11 8:48 ` Uros Bizjak
2014-11-11 8:55 ` Jakub Jelinek
2014-11-11 9:24 ` Marc Glisse
2014-11-11 12:11 ` Andrew Pinski
2014-11-11 12:56 ` Richard Biener
2014-11-11 12:57 ` Andrew Pinski
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).