Compiler: Rename __forceinline define to DOLPHIN_FORCE_INLINE

This is much better as prefixed double underscores are reserved for the
implementation when it comes to identifiers. Another reason its better,
is that, on Windows, where __forceinline is a compiler built-in, with
the previous define, header inclusion software that detects unnecessary
includes will erroneously flag usages of Compiler.h as unnecessary
(despite being necessary on other platforms). So we define a macro
that's used by Windows and other platforms to ensure this doesn't
happen.

Source/Core/Common/BitField.h

@@ -137,7 +137,7 @@ struct BitField
   BitField& operator=(const BitField&) = delete;
 #endif
 
-  __forceinline BitField& operator=(T val)
+  DOLPHIN_FORCE_INLINE BitField& operator=(T val)
   {
     storage = (storage & ~GetMask()) | ((static_cast<StorageType>(val) << position) & GetMask());
     return *this;

Source/Core/Common/ChunkFile.h

@@ -257,7 +257,7 @@ class PointerWrap
     DoEachElement(x, [](PointerWrap& p, typename T::value_type& elem) { p.Do(elem); });
   }
 
-  __forceinline void DoVoid(void* data, u32 size)
+  DOLPHIN_FORCE_INLINE void DoVoid(void* data, u32 size)
   {
     switch (mode)
     {

Source/Core/Common/Compiler.h

@@ -12,6 +12,8 @@
 #define UNUSED
 #endif
 
-#ifndef _WIN32
-#define __forceinline inline __attribute__((always_inline))
+#ifdef _WIN32
+#define DOLPHIN_FORCE_INLINE __forceinline
+#else
+#define DOLPHIN_FORCE_INLINE inline __attribute__((always_inline))
 #endif

Source/Core/VideoCommon/BPMemory.h

@@ -903,7 +903,7 @@ union AlphaTest
     PASS = 2,
   };
 
-  __forceinline TEST_RESULT TestResult() const
+  DOLPHIN_FORCE_INLINE TEST_RESULT TestResult() const
   {
     switch (logic)
     {

Source/Core/VideoCommon/DataReader.h

@@ -25,7 +25,7 @@ class DataReader
 
   size_t size() const { return end - buffer; }
   template <typename T, bool swapped = true>
-  __forceinline T Peek(int offset = 0) const
+  DOLPHIN_FORCE_INLINE T Peek(int offset = 0) const
   {
     T data;
     std::memcpy(&data, &buffer[offset], sizeof(T));
@@ -37,15 +37,15 @@ class DataReader
   }
 
   template <typename T, bool swapped = true>
-  __forceinline T Read()
+  DOLPHIN_FORCE_INLINE T Read()
   {
     const T result = Peek<T, swapped>();
     buffer += sizeof(T);
     return result;
   }
 
   template <typename T, bool swapped = false>
-  __forceinline void Write(T data)
+  DOLPHIN_FORCE_INLINE void Write(T data)
   {
     if (swapped)
       data = Common::FromBigEndian(data);

Source/Core/VideoCommon/IndexGenerator.cpp

@@ -58,7 +58,8 @@ void IndexGenerator::AddIndices(int primitive, u32 numVerts)
 
 // Triangles
 template <bool pr>
-__forceinline u16* IndexGenerator::WriteTriangle(u16* Iptr, u32 index1, u32 index2, u32 index3)
+DOLPHIN_FORCE_INLINE u16* IndexGenerator::WriteTriangle(u16* Iptr, u32 index1, u32 index2,
+                                                        u32 index3)
 {
   *Iptr++ = index1;
   *Iptr++ = index2;

Source/Core/VideoCommon/VertexLoaderUtils.h

@@ -12,49 +12,49 @@
 extern u8* g_video_buffer_read_ptr;
 extern u8* g_vertex_manager_write_ptr;
 
-__forceinline void DataSkip(u32 skip)
+DOLPHIN_FORCE_INLINE void DataSkip(u32 skip)
 {
   g_video_buffer_read_ptr += skip;
 }
 
 // probably unnecessary
 template <int count>
-__forceinline void DataSkip()
+DOLPHIN_FORCE_INLINE void DataSkip()
 {
   g_video_buffer_read_ptr += count;
 }
 
 template <typename T>
-__forceinline T DataPeek(int _uOffset, u8* bufp = g_video_buffer_read_ptr)
+DOLPHIN_FORCE_INLINE T DataPeek(int _uOffset, u8* bufp = g_video_buffer_read_ptr)
 {
   T result;
   std::memcpy(&result, &bufp[_uOffset], sizeof(T));
   return Common::FromBigEndian(result);
 }
 
 template <typename T>
-__forceinline T DataRead(u8** bufp = &g_video_buffer_read_ptr)
+DOLPHIN_FORCE_INLINE T DataRead(u8** bufp = &g_video_buffer_read_ptr)
 {
   auto const result = DataPeek<T>(0, *bufp);
   *bufp += sizeof(T);
   return result;
 }
 
-__forceinline u32 DataReadU32Unswapped()
+DOLPHIN_FORCE_INLINE u32 DataReadU32Unswapped()
 {
   u32 result;
   std::memcpy(&result, g_video_buffer_read_ptr, sizeof(u32));
   g_video_buffer_read_ptr += sizeof(u32);
   return result;
 }
 
-__forceinline u8* DataGetPosition()
+DOLPHIN_FORCE_INLINE u8* DataGetPosition()
 {
   return g_video_buffer_read_ptr;
 }
 
 template <typename T>
-__forceinline void DataWrite(T data)
+DOLPHIN_FORCE_INLINE void DataWrite(T data)
 {
   std::memcpy(g_vertex_manager_write_ptr, &data, sizeof(T));
   g_vertex_manager_write_ptr += sizeof(T);

Source/Core/VideoCommon/VertexLoader_Normal.cpp

@@ -26,7 +26,7 @@ VertexLoader_Normal::Set VertexLoader_Normal::m_Table[NUM_NRM_TYPE][NUM_NRM_INDI
 namespace
 {
 template <typename T>
-__forceinline float FracAdjust(T val)
+DOLPHIN_FORCE_INLINE float FracAdjust(T val)
 {
   // auto const S8FRAC = 1.f / (1u << 6);
   // auto const U8FRAC = 1.f / (1u << 7);
@@ -38,13 +38,13 @@ __forceinline float FracAdjust(T val)
 }
 
 template <>
-__forceinline float FracAdjust(float val)
+DOLPHIN_FORCE_INLINE float FracAdjust(float val)
 {
   return val;
 }
 
 template <typename T, int N>
-__forceinline void ReadIndirect(const T* data)
+DOLPHIN_FORCE_INLINE void ReadIndirect(const T* data)
 {
   static_assert(3 == N || 9 == N, "N is only sane as 3 or 9!");
   DataReader dst(g_vertex_manager_write_ptr, nullptr);
@@ -72,7 +72,7 @@ struct Normal_Direct
 };
 
 template <typename I, typename T, int N, int Offset>
-__forceinline void Normal_Index_Offset()
+DOLPHIN_FORCE_INLINE void Normal_Index_Offset()
 {
   static_assert(std::is_unsigned<I>::value, "Only unsigned I is sane!");