When cross-compiling for ia32, do not build 'host' targets with -m32

BUG=94852
TEST=it (cross-)compiles


Review URL: http://codereview.chromium.org/7811014

git-svn-id: http://src.chromium.org/svn/trunk/src/build@101014 4ff67af0-8c30-449e-8e8b-ad334ec8d88c

common.gypi

@@ -1429,6 +1429,8 @@
         },
         'conditions': [
           ['target_arch=="ia32"', {
+            'target_conditions': [
+              ['_toolset=="target"', {
                 'asflags': [
                   # Needed so that libs with .s files (e.g. libicudata.a)
                   # are compatible with the general 32-bit-ness.
@@ -1446,19 +1448,19 @@
                 # 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.
+                # 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.
+                # 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.
                 'conditions': [
                   ['branding=="Chromium" and disable_sse2==0', {
                     'cflags': [
@@ -1469,8 +1471,8 @@
                   }],
                   # ChromeOS targets Pinetrail, which is sse3, but most of the
                   # benefit comes from sse2 so this setting allows ChromeOS
-              # to build on other CPUs.  In the future -march=atom would help
-              # but requires a newer compiler.
+                  # to build on other CPUs.  In the future -march=atom would
+                  # help but requires a newer compiler.
                   ['chromeos==1 and disable_sse2==0', {
                     'cflags': [
                       '-msse2',
@@ -1497,6 +1499,8 @@
                   '-m32',
                 ],
               }],
+            ],
+          }],
           ['target_arch=="arm"', {
             'target_conditions': [
               ['_toolset=="target"', {