Cycles: remove prefix from source code file names

Remove prefix of filenames that is the same as the folder name. This used
to help when #includes were using individual files, but now they are always
relative to the cycles root directory and so the prefixes are redundant.

For patches and branches, git merge and rebase should be able to detect the
renames and move over code to the right file.

1 files changed, 646 insertions, 0 deletions

diff --git a/intern/cycles/util/ssei.h b/intern/cycles/util/ssei.h
new file mode 100644
index 00000000000..94412fb77e7
--- /dev/null
+++ b/intern/cycles/util/ssei.h
@@ -0,0 +1,646 @@
+/*
+ * Copyright 2011-2013 Intel Corporation
+ * Modifications Copyright 2014, Blender Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0(the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __UTIL_SSEI_H__
+#define __UTIL_SSEI_H__
+
+CCL_NAMESPACE_BEGIN
+
+#ifdef __KERNEL_SSE2__
+
+struct sseb;
+struct ssef;
+
+/*! 4-wide SSE integer type. */
+struct ssei {
+  typedef sseb Mask;   // mask type
+  typedef ssei Int;    // int type
+  typedef ssef Float;  // float type
+
+  enum { size = 4 };  // number of SIMD elements
+  union {
+    __m128i m128;
+    int32_t i[4];
+  };  // data
+
+  ////////////////////////////////////////////////////////////////////////////////
+  /// Constructors, Assignment & Cast Operators
+  ////////////////////////////////////////////////////////////////////////////////
+
+  __forceinline ssei()
+  {
+  }
+  __forceinline ssei(const ssei &a)
+  {
+    m128 = a.m128;
+  }
+  __forceinline ssei &operator=(const ssei &a)
+  {
+    m128 = a.m128;
+    return *this;
+  }
+
+  __forceinline ssei(const __m128i a) : m128(a)
+  {
+  }
+  __forceinline operator const __m128i &(void) const
+  {
+    return m128;
+  }
+  __forceinline operator __m128i &(void)
+  {
+    return m128;
+  }
+
+  __forceinline ssei(const int a) : m128(_mm_set1_epi32(a))
+  {
+  }
+  __forceinline ssei(int a, int b, int c, int d) : m128(_mm_setr_epi32(a, b, c, d))
+  {
+  }
+
+  __forceinline explicit ssei(const __m128 a) : m128(_mm_cvtps_epi32(a))
+  {
+  }
+
+  ////////////////////////////////////////////////////////////////////////////////
+  /// Array Access
+  ////////////////////////////////////////////////////////////////////////////////
+
+  __forceinline const int32_t &operator[](const size_t index) const
+  {
+    assert(index < 4);
+    return i[index];
+  }
+  __forceinline int32_t &operator[](const size_t index)
+  {
+    assert(index < 4);
+    return i[index];
+  }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+/// Unary Operators
+////////////////////////////////////////////////////////////////////////////////
+
+__forceinline const ssei cast(const __m128 &a)
+{
+  return _mm_castps_si128(a);
+}
+__forceinline const ssei operator+(const ssei &a)
+{
+  return a;
+}
+__forceinline const ssei operator-(const ssei &a)
+{
+  return _mm_sub_epi32(_mm_setzero_si128(), a.m128);
+}
+#  if defined(__KERNEL_SSSE3__)
+__forceinline const ssei abs(const ssei &a)
+{
+  return _mm_abs_epi32(a.m128);
+}
+#  endif
+
+////////////////////////////////////////////////////////////////////////////////
+/// Binary Operators
+////////////////////////////////////////////////////////////////////////////////
+
+__forceinline const ssei operator+(const ssei &a, const ssei &b)
+{
+  return _mm_add_epi32(a.m128, b.m128);
+}
+__forceinline const ssei operator+(const ssei &a, const int32_t &b)
+{
+  return a + ssei(b);
+}
+__forceinline const ssei operator+(const int32_t &a, const ssei &b)
+{
+  return ssei(a) + b;
+}
+
+__forceinline const ssei operator-(const ssei &a, const ssei &b)
+{
+  return _mm_sub_epi32(a.m128, b.m128);
+}
+__forceinline const ssei operator-(const ssei &a, const int32_t &b)
+{
+  return a - ssei(b);
+}
+__forceinline const ssei operator-(const int32_t &a, const ssei &b)
+{
+  return ssei(a) - b;
+}
+
+#  if defined(__KERNEL_SSE41__)
+__forceinline const ssei operator*(const ssei &a, const ssei &b)
+{
+  return _mm_mullo_epi32(a.m128, b.m128);
+}
+__forceinline const ssei operator*(const ssei &a, const int32_t &b)
+{
+  return a * ssei(b);
+}
+__forceinline const ssei operator*(const int32_t &a, const ssei &b)
+{
+  return ssei(a) * b;
+}
+#  endif
+
+__forceinline const ssei operator&(const ssei &a, const ssei &b)
+{
+  return _mm_and_si128(a.m128, b.m128);
+}
+__forceinline const ssei operator&(const ssei &a, const int32_t &b)
+{
+  return a & ssei(b);
+}
+__forceinline const ssei operator&(const int32_t &a, const ssei &b)
+{
+  return ssei(a) & b;
+}
+
+__forceinline const ssei operator|(const ssei &a, const ssei &b)
+{
+  return _mm_or_si128(a.m128, b.m128);
+}
+__forceinline const ssei operator|(const ssei &a, const int32_t &b)
+{
+  return a | ssei(b);
+}
+__forceinline const ssei operator|(const int32_t &a, const ssei &b)
+{
+  return ssei(a) | b;
+}
+
+__forceinline const ssei operator^(const ssei &a, const ssei &b)
+{
+  return _mm_xor_si128(a.m128, b.m128);
+}
+__forceinline const ssei operator^(const ssei &a, const int32_t &b)
+{
+  return a ^ ssei(b);
+}
+__forceinline const ssei operator^(const int32_t &a, const ssei &b)
+{
+  return ssei(a) ^ b;
+}
+
+__forceinline const ssei operator<<(const ssei &a, const int32_t &n)
+{
+  return _mm_slli_epi32(a.m128, n);
+}
+__forceinline const ssei operator>>(const ssei &a, const int32_t &n)
+{
+  return _mm_srai_epi32(a.m128, n);
+}
+
+__forceinline const ssei andnot(const ssei &a, const ssei &b)
+{
+  return _mm_andnot_si128(a.m128, b.m128);
+}
+__forceinline const ssei andnot(const sseb &a, const ssei &b)
+{
+  return _mm_andnot_si128(cast(a.m128), b.m128);
+}
+__forceinline const ssei andnot(const ssei &a, const sseb &b)
+{
+  return _mm_andnot_si128(a.m128, cast(b.m128));
+}
+
+__forceinline const ssei sra(const ssei &a, const int32_t &b)
+{
+  return _mm_srai_epi32(a.m128, b);
+}
+__forceinline const ssei srl(const ssei &a, const int32_t &b)
+{
+  return _mm_srli_epi32(a.m128, b);
+}
+
+#  if defined(__KERNEL_SSE41__)
+__forceinline const ssei min(const ssei &a, const ssei &b)
+{
+  return _mm_min_epi32(a.m128, b.m128);
+}
+__forceinline const ssei min(const ssei &a, const int32_t &b)
+{
+  return min(a, ssei(b));
+}
+__forceinline const ssei min(const int32_t &a, const ssei &b)
+{
+  return min(ssei(a), b);
+}
+
+__forceinline const ssei max(const ssei &a, const ssei &b)
+{
+  return _mm_max_epi32(a.m128, b.m128);
+}
+__forceinline const ssei max(const ssei &a, const int32_t &b)
+{
+  return max(a, ssei(b));
+}
+__forceinline const ssei max(const int32_t &a, const ssei &b)
+{
+  return max(ssei(a), b);
+}
+#  endif
+
+////////////////////////////////////////////////////////////////////////////////
+/// Assignment Operators
+////////////////////////////////////////////////////////////////////////////////
+
+__forceinline ssei &operator+=(ssei &a, const ssei &b)
+{
+  return a = a + b;
+}
+__forceinline ssei &operator+=(ssei &a, const int32_t &b)
+{
+  return a = a + b;
+}
+
+__forceinline ssei &operator-=(ssei &a, const ssei &b)
+{
+  return a = a - b;
+}
+__forceinline ssei &operator-=(ssei &a, const int32_t &b)
+{
+  return a = a - b;
+}
+
+#  if defined(__KERNEL_SSE41__)
+__forceinline ssei &operator*=(ssei &a, const ssei &b)
+{
+  return a = a * b;
+}
+__forceinline ssei &operator*=(ssei &a, const int32_t &b)
+{
+  return a = a * b;
+}
+#  endif
+
+__forceinline ssei &operator&=(ssei &a, const ssei &b)
+{
+  return a = a & b;
+}
+__forceinline ssei &operator&=(ssei &a, const int32_t &b)
+{
+  return a = a & b;
+}
+
+__forceinline ssei &operator|=(ssei &a, const ssei &b)
+{
+  return a = a | b;
+}
+__forceinline ssei &operator|=(ssei &a, const int32_t &b)
+{
+  return a = a | b;
+}
+
+__forceinline ssei &operator^=(ssei &a, const ssei &b)
+{
+  return a = a ^ b;
+}
+__forceinline ssei &operator^=(ssei &a, const int32_t &b)
+{
+  return a = a ^ b;
+}
+
+__forceinline ssei &operator<<=(ssei &a, const int32_t &b)
+{
+  return a = a << b;
+}
+__forceinline ssei &operator>>=(ssei &a, const int32_t &b)
+{
+  return a = a >> b;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Comparison Operators + Select
+////////////////////////////////////////////////////////////////////////////////
+
+__forceinline const sseb operator==(const ssei &a, const ssei &b)
+{
+  return _mm_castsi128_ps(_mm_cmpeq_epi32(a.m128, b.m128));
+}
+__forceinline const sseb operator==(const ssei &a, const int32_t &b)
+{
+  return a == ssei(b);
+}
+__forceinline const sseb operator==(const int32_t &a, const ssei &b)
+{
+  return ssei(a) == b;
+}
+
+__forceinline const sseb operator!=(const ssei &a, const ssei &b)
+{
+  return !(a == b);
+}
+__forceinline const sseb operator!=(const ssei &a, const int32_t &b)
+{
+  return a != ssei(b);
+}
+__forceinline const sseb operator!=(const int32_t &a, const ssei &b)
+{
+  return ssei(a) != b;
+}
+
+__forceinline const sseb operator<(const ssei &a, const ssei &b)
+{
+  return _mm_castsi128_ps(_mm_cmplt_epi32(a.m128, b.m128));
+}
+__forceinline const sseb operator<(const ssei &a, const int32_t &b)
+{
+  return a < ssei(b);
+}
+__forceinline const sseb operator<(const int32_t &a, const ssei &b)
+{
+  return ssei(a) < b;
+}
+
+__forceinline const sseb operator>=(const ssei &a, const ssei &b)
+{
+  return !(a < b);
+}
+__forceinline const sseb operator>=(const ssei &a, const int32_t &b)
+{
+  return a >= ssei(b);
+}
+__forceinline const sseb operator>=(const int32_t &a, const ssei &b)
+{
+  return ssei(a) >= b;
+}
+
+__forceinline const sseb operator>(const ssei &a, const ssei &b)
+{
+  return _mm_castsi128_ps(_mm_cmpgt_epi32(a.m128, b.m128));
+}
+__forceinline const sseb operator>(const ssei &a, const int32_t &b)
+{
+  return a > ssei(b);
+}
+__forceinline const sseb operator>(const int32_t &a, const ssei &b)
+{
+  return ssei(a) > b;
+}
+
+__forceinline const sseb operator<=(const ssei &a, const ssei &b)
+{
+  return !(a > b);
+}
+__forceinline const sseb operator<=(const ssei &a, const int32_t &b)
+{
+  return a <= ssei(b);
+}
+__forceinline const sseb operator<=(const int32_t &a, const ssei &b)
+{
+  return ssei(a) <= b;
+}
+
+__forceinline const ssei select(const sseb &m, const ssei &t, const ssei &f)
+{
+#  ifdef __KERNEL_SSE41__
+  return _mm_castps_si128(_mm_blendv_ps(_mm_castsi128_ps(f), _mm_castsi128_ps(t), m));
+#  else
+  return _mm_or_si128(_mm_and_si128(m, t), _mm_andnot_si128(m, f));
+#  endif
+}
+
+__forceinline const ssei select(const int mask, const ssei &t, const ssei &f)
+{
+#  if defined(__KERNEL_SSE41__) && \
+      ((!defined(__clang__) && !defined(_MSC_VER)) || defined(__INTEL_COMPILER))
+  return _mm_castps_si128(_mm_blend_ps(_mm_castsi128_ps(f), _mm_castsi128_ps(t), mask));
+#  else
+  return select(sseb(mask), t, f);
+#  endif
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Movement/Shifting/Shuffling Functions
+////////////////////////////////////////////////////////////////////////////////
+
+__forceinline ssei unpacklo(const ssei &a, const ssei &b)
+{
+  return _mm_unpacklo_epi32(a, b);
+}
+__forceinline ssei unpackhi(const ssei &a, const ssei &b)
+{
+  return _mm_unpackhi_epi32(a, b);
+}
+
+template<size_t i0, size_t i1, size_t i2, size_t i3>
+__forceinline const ssei shuffle(const ssei &a)
+{
+#  ifdef __KERNEL_NEON__
+  int32x4_t result = shuffle_neon<int32x4_t, i0, i1, i2, i3>(vreinterpretq_s32_m128i(a));
+  return vreinterpretq_m128i_s32(result);
+#  else
+  return _mm_shuffle_epi32(a, _MM_SHUFFLE(i3, i2, i1, i0));
+#  endif
+}
+
+template<size_t i0, size_t i1, size_t i2, size_t i3>
+__forceinline const ssei shuffle(const ssei &a, const ssei &b)
+{
+#  ifdef __KERNEL_NEON__
+  int32x4_t result = shuffle_neon<int32x4_t, i0, i1, i2, i3>(vreinterpretq_s32_m128i(a),
+                                                             vreinterpretq_s32_m128i(b));
+  return vreinterpretq_m128i_s32(result);
+#  else
+  return _mm_castps_si128(
+      _mm_shuffle_ps(_mm_castsi128_ps(a), _mm_castsi128_ps(b), _MM_SHUFFLE(i3, i2, i1, i0)));
+#  endif
+}
+
+template<size_t i0> __forceinline const ssei shuffle(const ssei &b)
+{
+  return shuffle<i0, i0, i0, i0>(b);
+}
+
+#  if defined(__KERNEL_SSE41__)
+template<size_t src> __forceinline int extract(const ssei &b)
+{
+  return _mm_extract_epi32(b, src);
+}
+template<size_t dst> __forceinline const ssei insert(const ssei &a, const int32_t b)
+{
+  return _mm_insert_epi32(a, b, dst);
+}
+#  else
+template<size_t src> __forceinline int extract(const ssei &b)
+{
+  return b[src];
+}
+template<size_t dst> __forceinline const ssei insert(const ssei &a, const int32_t b)
+{
+  ssei c = a;
+  c[dst] = b;
+  return c;
+}
+#  endif
+
+////////////////////////////////////////////////////////////////////////////////
+/// Reductions
+////////////////////////////////////////////////////////////////////////////////
+
+#  if defined(__KERNEL_SSE41__)
+__forceinline const ssei vreduce_min(const ssei &v)
+{
+  ssei h = min(shuffle<1, 0, 3, 2>(v), v);
+  return min(shuffle<2, 3, 0, 1>(h), h);
+}
+__forceinline const ssei vreduce_max(const ssei &v)
+{
+  ssei h = max(shuffle<1, 0, 3, 2>(v), v);
+  return max(shuffle<2, 3, 0, 1>(h), h);
+}
+__forceinline const ssei vreduce_add(const ssei &v)
+{
+  ssei h = shuffle<1, 0, 3, 2>(v) + v;
+  return shuffle<2, 3, 0, 1>(h) + h;
+}
+
+__forceinline int reduce_min(const ssei &v)
+{
+#    ifdef __KERNEL_NEON__
+  return vminvq_s32(vreinterpretq_s32_m128i(v));
+#    else
+  return extract<0>(vreduce_min(v));
+#    endif
+}
+__forceinline int reduce_max(const ssei &v)
+{
+#    ifdef __KERNEL_NEON__
+  return vmaxvq_s32(vreinterpretq_s32_m128i(v));
+#    else
+  return extract<0>(vreduce_max(v));
+#    endif
+}
+__forceinline int reduce_add(const ssei &v)
+{
+#    ifdef __KERNEL_NEON__
+  return vaddvq_s32(vreinterpretq_s32_m128i(v));
+#    else
+  return extract<0>(vreduce_add(v));
+#    endif
+}
+
+__forceinline uint32_t select_min(const ssei &v)
+{
+  return __bsf(movemask(v == vreduce_min(v)));
+}
+__forceinline uint32_t select_max(const ssei &v)
+{
+  return __bsf(movemask(v == vreduce_max(v)));
+}
+
+__forceinline uint32_t select_min(const sseb &valid, const ssei &v)
+{
+  const ssei a = select(valid, v, ssei((int)pos_inf));
+  return __bsf(movemask(valid & (a == vreduce_min(a))));
+}
+__forceinline uint32_t select_max(const sseb &valid, const ssei &v)
+{
+  const ssei a = select(valid, v, ssei((int)neg_inf));
+  return __bsf(movemask(valid & (a == vreduce_max(a))));
+}
+
+#  else
+
+__forceinline int ssei_min(int a, int b)
+{
+  return (a < b) ? a : b;
+}
+__forceinline int ssei_max(int a, int b)
+{
+  return (a > b) ? a : b;
+}
+__forceinline int reduce_min(const ssei &v)
+{
+  return ssei_min(ssei_min(v[0], v[1]), ssei_min(v[2], v[3]));
+}
+__forceinline int reduce_max(const ssei &v)
+{
+  return ssei_max(ssei_max(v[0], v[1]), ssei_max(v[2], v[3]));
+}
+__forceinline int reduce_add(const ssei &v)
+{
+  return v[0] + v[1] + v[2] + v[3];
+}
+
+#  endif
+
+////////////////////////////////////////////////////////////////////////////////
+/// Memory load and store operations
+////////////////////////////////////////////////////////////////////////////////
+
+__forceinline ssei load4i(const void *const a)
+{
+  return _mm_load_si128((__m128i *)a);
+}
+
+__forceinline void store4i(void *ptr, const ssei &v)
+{
+  _mm_store_si128((__m128i *)ptr, v);
+}
+
+__forceinline void storeu4i(void *ptr, const ssei &v)
+{
+  _mm_storeu_si128((__m128i *)ptr, v);
+}
+
+__forceinline void store4i(const sseb &mask, void *ptr, const ssei &i)
+{
+#  if defined(__KERNEL_AVX__)
+  _mm_maskstore_ps((float *)ptr, (__m128i)mask, _mm_castsi128_ps(i));
+#  else
+  *(ssei *)ptr = select(mask, i, *(ssei *)ptr);
+#  endif
+}
+
+__forceinline ssei load4i_nt(void *ptr)
+{
+#  if defined(__KERNEL_SSE41__)
+  return _mm_stream_load_si128((__m128i *)ptr);
+#  else
+  return _mm_load_si128((__m128i *)ptr);
+#  endif
+}
+
+__forceinline void store4i_nt(void *ptr, const ssei &v)
+{
+#  if defined(__KERNEL_SSE41__)
+  _mm_stream_ps((float *)ptr, _mm_castsi128_ps(v));
+#  else
+  _mm_store_si128((__m128i *)ptr, v);
+#  endif
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Debug Functions
+////////////////////////////////////////////////////////////////////////////////
+
+ccl_device_inline void print_ssei(const char *label, const ssei &a)
+{
+  printf("%s: %df %df %df %d\n", label, a[0], a[1], a[2], a[3]);
+}
+
+#endif
+
+CCL_NAMESPACE_END
+
+#endif