I think you need to use -frounding-math.  GCC assumes by default the rounding mode is round-to-nearest.  See http://gcc.gnu.org/onlinedocs/gcc-4.5.2/gcc/Optimize-Options.html#index-frounding_002dmath-819 .

(In reply to comment #1)
> I think you need to use -frounding-math.  GCC assumes by default the rounding
> mode is round-to-nearest.  See
> http://gcc.gnu.org/onlinedocs/gcc-4.5.2/gcc/Optimize-Options.html#index-frounding_002dmath-819
> .

Hi Andrew, 

  thanks for writing. I tried -frounding-math and the result is still the same. Adding/removing -mfpmath=sse doesn't change it either. Is there any additional information I can provide?

Thanks!

Can you provide non-preprocessed source?  I have difficulties in compiling with
newer releases.

Created attachment 23273 [details]
source file

Here's the source code. Rename to round.c.

(In reply to comment #4)
> Created attachment 23273 [details]
> source file
> 
> Here's the source code. Rename to round.c.

Hi Richard,

  here's the source code. Rename to round.c. 

  I think I must be doing something wrong here. Someone would have noticed that results from _mm_cvtps_pi16 weren't changing when _MM_SET_ROUNDING_MODE() was called. -) I'm puzzled by it working with -g, but not with -O3.

  Any additional information I can provide?

  Thanks!

The problem is the same as recorded as PR 34678.  We are optimizing all the _mm_cvtps_pi16 to one of them because we don't see the rounding mode has changed.  To get the correct values each time do the following:

void test_rounding(void)
{
 __m128 source = {-1.1, 0.0, 1.1, 1.5};
 __m64 dest;
 unsigned int initial_mode;

 initial_mode = _MM_GET_ROUNDING_MODE();
 print_rounding_mode("initial rounding mode", initial_mode);
 
 /* now set the rounding mode to each value to see the result  */
 
 asm("":"+X"(source)); // force source to be different but the same
 _MM_SET_ROUNDING_MODE(_MM_ROUND_NEAREST);

 dest = _mm_cvtps_pi16(source);
 _mm_empty();
 print_round_results("with _MM_ROUND_NEAREST ", source, dest);

 asm("":"+X"(source)); // force source to be different but the same
 _MM_SET_ROUNDING_MODE(_MM_ROUND_DOWN);

 dest = _mm_cvtps_pi16(source);
 _mm_empty();
 print_round_results("with _MM_ROUND_DOWN ", source, dest);
 
 asm("":"+X"(source)); // force source to be different but the same
 _MM_SET_ROUNDING_MODE(_MM_ROUND_UP);

 dest = _mm_cvtps_pi16(source);
 _mm_empty();
 print_round_results("with _MM_ROUND_UP ", source, dest);

 asm("":"+X"(source)); // force source to be different but the same
 _MM_SET_ROUNDING_MODE(_MM_ROUND_TOWARD_ZERO);

 dest = _mm_cvtps_pi16(source);
 _mm_empty();
 print_round_results("with _MM_ROUND_TOWARD_ZERO ", source, dest);

 /* restore initial rounding mode  */
  _MM_SET_ROUNDING_MODE(initial_mode);
  
}

*** This bug has been marked as a duplicate of bug 34678 ***

Well, this case is slightly different as we simply have const/pure builtins
that do not only depend on their arguments (but the FP state).  Thus we'd need
to trop the attributes from these functions for -frounding-math.  Not that
it would help a lot, given PR34678 ...

Hi folks,

  First, thanks for working on this.

  Second, I read the link and I _think_ I understand it. Let me paraphrase it back to you and you can tell me if I've got the point:

  There is an optimizer that extracts common expressions and evaluates them once instead of every time they occur. (What's the name of that so I can call it by the right name?) In my code it finds the expression:

  dest = _mm_cvtps_pi16(source);

  Several times. Since it doesn't see source changing, this expression only gets evaluated once. Now, the change to rounding mode that happens with _MM_SET_ROUNDING_MODE(...) isn't detected as something that would change the value of the _mm_cvtps_pi16(...) expression, so the optimization is not removed. Recognizing that change to rounding mode and reacting to it is what's at the heart of bug 34678, and that's why this is a duplicate.

  The work-arounds are:

1)insert 'asm("":"+X"(source));' before changing rounding mode to make the compiler re-evaluate expressions that use source.

2) do _MM_SET_ROUNDING_MODE(...) before any divisions or integer conversions that might get optimized out. The scope of the optimization is a function body and any inlined code. So do _MM_SET_ROUNDING_MODE early within that scope. 

  Is my understanding correct? 

  A few more questions:

  Will this bug exist on non-X86 processors?

  What does the 'asm("":"+X"(source));' expression do ?

  Will this syntax work for non-X86 processors?

  To be correct, should I compile with -frounding-math ?


Thanks!

Hi folks,

  I tried the asm("":"+X"(source));  as shown. I get an error: inconsistent operand constraints in an ‘asm’.

  The info pages make it look like this should work, but the Inline Assembly Howto doesn't mention the X constraint. If the compiler should agree with the info pages, I'm doing something wrong. What am I missing?

thanks