Everyone gets a namespace {}.

src/core/SkNx.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkNx_DEFINED
 #define SkNx_DEFINED
 
 
 #define SKNX_NO_SIMDx  // Remove the x to disable SIMD for all SkNx types.
 
 
 #include "SkScalar.h"
 #include "SkTypes.h"
 #include <math.h>
 #define REQUIRE(x) static_assert(x, #x)
 
+// This file may be included multiple times by .cpp files with different flags, leading
+// to different definitions.  Usually that doesn't matter because it's all inlined, but
+// in Debug modes the compilers may not inline everything.  So wrap everything in an
+// anonymous namespace to give each includer their own silo of this code (or the linker
+// will probably pick one randomly for us, which is rarely correct).
+namespace {
+
 // The default implementations just fall back on a pair of size N/2.
 
 // SkNb is a _very_ minimal class representing a vector of bools returned by comparison operators.
 // We pass along the byte size of the compared types (Bytes) to help platform specializations.
 template <int N, int Bytes>
 class SkNb {
 public:
     SkNb() {}
     SkNb(const SkNb<N/2, Bytes>& lo, const SkNb<N/2, Bytes>& hi) : fLo(lo), fHi(hi) {}
 
@@ skipping 214 matching lines @@
 
 protected:
     // We do double sqrts natively, or via floats for any other type.
     template <typename U>
     static U      Sqrt(U      val) { return (U) ::sqrtf((float)val); }
     static double Sqrt(double val) { return     ::sqrt (       val); }
 
     T fVal;
 };
 
+}  // namespace
 
 // Generic syntax sugar that should work equally well for all implementations.
 template <typename T> T operator - (const T& l) { return T(0) - l; }
 
 template <typename L, typename R> L& operator += (L& l, const R& r) { return (l = l + r); }
 template <typename L, typename R> L& operator -= (L& l, const R& r) { return (l = l - r); }
 template <typename L, typename R> L& operator *= (L& l, const R& r) { return (l = l * r); }
 template <typename L, typename R> L& operator /= (L& l, const R& r) { return (l = l / r); }
 
 template <typename L> L& operator <<= (L& l, int bits) { return (l = l << bits); }
@@ skipping 21 matching lines @@
 typedef SkNi<4,  uint16_t> Sk4h;
 typedef SkNi<8,  uint16_t> Sk8h;
 typedef SkNi<16, uint16_t> Sk16h;
 
 typedef SkNi<16, uint8_t> Sk16b;
 
 typedef SkNi<4,  int32_t> Sk4i;
 typedef SkNi<4, uint32_t> Sk4u;
 
 #endif//SkNx_DEFINED