Some cflags questions...

For discussions about programming, programming questions/advice, and projects that don't really have anything to do with Puppy.
Post Reply
Message
Author
ITAmember
Posts: 167
Joined: Sun 13 Sep 2009, 18:50
Location: The middle of a cornfield

Some cflags questions...

#1 Post by ITAmember »

This is a snippet from a chromium build configuration file

Code: Select all

  'conditions': [
    [ 'OS=="linux"', {
      'target_defaults': {
        'asflags': [
          # Needed so that libs with .s files (e.g. libicudata.a)
          # are compatible with the general 32-bit-ness.
          '-32',
        ],
        # All floating-point computations on x87 happens in 80-bit
        # precision.  Because the C and C++ language standards allow
        # the compiler to keep the floating-point values in higher
        # precision than what's specified in the source and doing so
        # is more efficient than constantly rounding up to 64-bit or
        # 32-bit precision as specified in the source, the compiler,
        # especially in the optimized mode, tries very hard to keep
        # values in x87 floating-point stack (in 80-bit precision)
        # as long as possible. This has important side effects, that
        # the real value used in computation may change depending on
        # how the compiler did the optimization - that is, the value
        # kept in 80-bit is different than the value rounded down to
        # 64-bit or 32-bit. There are possible compiler options to make
        # this behavior consistent (e.g. -ffloat-store would keep all
        # floating-values in the memory, thus force them to be rounded
        # to its original precision) but they have significant runtime
        # performance penalty.
        #
        # -mfpmath=sse -msse2 makes the compiler use SSE instructions
        # which keep floating-point values in SSE registers in its
        # native precision (32-bit for single precision, and 64-bit for
        # double precision values). This means the floating-point value
        # used during computation does not change depending on how the
        # compiler optimized the code, since the value is always kept
        # in its specified precision.
        'cflags': [
          '-m32',
          '-pthread',
          '-march=pentium4',
          '-fno-exceptions',
          '-msse2',
          '-mfpmath=sse',
        ],
SSE2 instructions are not supported on AMD athalon, pentium 3, or AMD k6 processors. (and probably more) I know I'm going to have to take out the '-msse2' line but what about the other lines?

Post Reply