Merge branch 'master' into wii-network

Conflicts:
	Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE.cpp
	Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_Device_FileIO.cpp
	Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_Device_es.cpp
	Source/VSProps/Dolphin.Win32.props
	Source/VSProps/Dolphin.x64.props

Source/Core/Common/Src/BreakPoints.cpp

@@ -18,6 +18,7 @@
 #include "Common.h"
 #include "DebugInterface.h"
 #include "BreakPoints.h"
+#include "../../Core/Src/PowerPC/JitCommon/JitBase.h"
 #include <sstream>
 
 bool BreakPoints::IsAddressBreakPoint(u32 _iAddress)
@@ -70,7 +71,11 @@ void BreakPoints::AddFromStrings(const TBreakPointsStr& bps)
 void BreakPoints::Add(const TBreakPoint& bp)
 {
 	if (!IsAddressBreakPoint(bp.iAddress))
+	{
 		m_BreakPoints.push_back(bp);
+		if (jit)
+			jit->GetBlockCache()->InvalidateICache(bp.iAddress, 4);
+	}
 }
 
 void BreakPoints::Add(u32 em_address, bool temp)
@@ -83,21 +88,35 @@ void BreakPoints::Add(u32 em_address, bool temp)
 		pt.iAddress = em_address;
 
 		m_BreakPoints.push_back(pt);
+
+		if (jit)
+			jit->GetBlockCache()->InvalidateICache(em_address, 4);
 	}
 }
 
-void BreakPoints::Remove(u32 _iAddress)
+void BreakPoints::Remove(u32 em_address)
 {
 	for (TBreakPoints::iterator i = m_BreakPoints.begin(); i != m_BreakPoints.end(); ++i)
 	{
-		if (i->iAddress == _iAddress)
+		if (i->iAddress == em_address)
 		{
 			m_BreakPoints.erase(i);
+			if (jit)
+				jit->GetBlockCache()->InvalidateICache(em_address, 4);
 			return;
 		}
 	}
 }
 
+void BreakPoints::Clear()
+{
+	for (TBreakPoints::iterator i = m_BreakPoints.begin(); i != m_BreakPoints.end(); ++i)
+	{
+		if (jit)
+			jit->GetBlockCache()->InvalidateICache(i->iAddress, 4);
+		m_BreakPoints.erase(i);
+	}
+}
 
 MemChecks::TMemChecksStr MemChecks::GetStrings() const
 {

Source/Core/Common/Src/BreakPoints.h

@@ -78,7 +78,7 @@ public:
 
 	// Remove Breakpoint
 	void Remove(u32 _iAddress);
-	void Clear() { m_BreakPoints.clear(); };
+	void Clear();
 
     void DeleteByAddress(u32 _Address);
 

Source/Core/Common/Src/Common.h

@@ -103,8 +103,6 @@ private:
 		//CrtDebugBreak breakAt(614);
 	#endif // end DEBUG/FAST
 
-#elif defined HAVE_CONFIG_H
-#include "config.h"	// SCons autoconfiguration defines
 #endif
 
 // Windows compatibility

Source/Core/Common/Src/CommonFuncs.h

@@ -21,6 +21,7 @@
 #ifdef _WIN32
 #define SLEEP(x) Sleep(x)
 #else
+#include <unistd.h>
 #define SLEEP(x) usleep(x*1000)
 #endif
 

Source/Core/Common/Src/CommonPaths.h

@@ -121,6 +121,8 @@
 #define GC_MEMCARDA	"MemoryCardA"
 #define GC_MEMCARDB	"MemoryCardB"
 
+#define WII_STATE 	"state.dat"
+
 #define WII_SETTING 	"setting.txt"
 
 #define GECKO_CODE_HANDLER "codehandler.bin"

Source/Core/Common/Src/LinearDiskCache.h

@@ -24,7 +24,7 @@
 // Increment this every time you change shader generation code.
 enum
 {
-	LINEAR_DISKCACHE_VER = 6972
+	LINEAR_DISKCACHE_VER = 6975
 };
 
 // On disk format:

Source/Core/Common/Src/MathUtil.h

@@ -161,6 +161,7 @@ void LoadDefaultSSEState();
 float MathFloatVectorSum(const std::vector<float>&);
 
 #define ROUND_UP(x, a)		(((x) + (a) - 1) & ~((a) - 1))
+#define ROUND_DOWN(x, a)	((x) & ~((a) - 1))
 
 
 // Tiny matrix/vector library.

Source/Core/Common/Src/MemoryUtil.cpp

@@ -1,207 +1,207 @@
-// Copyright (C) 2003 Dolphin Project.
-
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, version 2.0.
-
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License 2.0 for more details.
-
-// A copy of the GPL 2.0 should have been included with the program.
-// If not, see http://www.gnu.org/licenses/
-
-// Official SVN repository and contact information can be found at
-// http://code.google.com/p/dolphin-emu/
-
-#include "Common.h"
-#include "MemoryUtil.h"
-#include "StringUtil.h"
-
-#ifdef _WIN32
-#include <windows.h>
-#include <psapi.h>
-#else
-#include <errno.h>
-#include <stdio.h>
-#endif
-
-#if !defined(_WIN32) && defined(__x86_64__) && !defined(MAP_32BIT)
-#include <unistd.h>
-#define PAGE_MASK     (getpagesize() - 1)
-#define round_page(x) ((((unsigned long)(x)) + PAGE_MASK) & ~(PAGE_MASK))
-#endif
-
-// This is purposely not a full wrapper for virtualalloc/mmap, but it
-// provides exactly the primitive operations that Dolphin needs.
-
-void* AllocateExecutableMemory(size_t size, bool low)
-{
+// Copyright (C) 2003 Dolphin Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official SVN repository and contact information can be found at
+// http://code.google.com/p/dolphin-emu/
+
+#include "Common.h"
+#include "MemoryUtil.h"
+#include "StringUtil.h"
+
+#ifdef _WIN32
+#include <windows.h>
+#include <psapi.h>
+#else
+#include <errno.h>
+#include <stdio.h>
+#endif
+
+#if !defined(_WIN32) && defined(__x86_64__) && !defined(MAP_32BIT)
+#include <unistd.h>
+#define PAGE_MASK     (getpagesize() - 1)
+#define round_page(x) ((((unsigned long)(x)) + PAGE_MASK) & ~(PAGE_MASK))
+#endif
+
+// This is purposely not a full wrapper for virtualalloc/mmap, but it
+// provides exactly the primitive operations that Dolphin needs.
+
+void* AllocateExecutableMemory(size_t size, bool low)
+{
 #if defined(_WIN32)
 	void* ptr = VirtualAlloc(0, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
-#else
-	static char *map_hint = 0;
-#if defined(__x86_64__) && !defined(MAP_32BIT)
-	// This OS has no flag to enforce allocation below the 4 GB boundary,
-	// but if we hint that we want a low address it is very likely we will
-	// get one.
-	// An older version of this code used MAP_FIXED, but that has the side
-	// effect of discarding already mapped pages that happen to be in the
-	// requested virtual memory range (such as the emulated RAM, sometimes).
-	if (low && (!map_hint))
-		map_hint = (char*)round_page(512*1024*1024); /* 0.5 GB rounded up to the next page */
-#endif
-	void* ptr = mmap(map_hint, size, PROT_READ | PROT_WRITE | PROT_EXEC,
-		MAP_ANON | MAP_PRIVATE
-#if defined(__x86_64__) && defined(MAP_32BIT)
-		| (low ? MAP_32BIT : 0)
-#endif
-		, -1, 0);
-#endif /* defined(_WIN32) */
-
-	// printf("Mapped executable memory at %p (size %ld)\n", ptr,
-	//	(unsigned long)size);
-	
-#if defined(__FreeBSD__)
-	if (ptr == MAP_FAILED)
-	{
-		ptr = NULL;
-#else
-	if (ptr == NULL)
-	{
-#endif	
-		PanicAlert("Failed to allocate executable memory");
-	}
-#if !defined(_WIN32) && defined(__x86_64__) && !defined(MAP_32BIT)
-	else
-	{
-		if (low)
-		{
-			map_hint += size;
-			map_hint = (char*)round_page(map_hint); /* round up to the next page */
-			// printf("Next map will (hopefully) be at %p\n", map_hint);
-		}
-	}
-#endif
-
-#if defined(_M_X64)
-	if ((u64)ptr >= 0x80000000 && low == true)
-		PanicAlert("Executable memory ended up above 2GB!");
-#endif
-
-	return ptr;
-}
-
-void* AllocateMemoryPages(size_t size)
-{
-#ifdef _WIN32
-	void* ptr = VirtualAlloc(0, size, MEM_COMMIT, PAGE_READWRITE);
-#else
-	void* ptr = mmap(0, size, PROT_READ | PROT_WRITE,
-			MAP_ANON | MAP_PRIVATE, -1, 0);
-#endif
-
-	// printf("Mapped memory at %p (size %ld)\n", ptr,
-	//	(unsigned long)size);
-
-	if (ptr == NULL)
-		PanicAlert("Failed to allocate raw memory");
-
-	return ptr;
-}
-
-void* AllocateAlignedMemory(size_t size,size_t alignment)
-{
-#ifdef _WIN32
-	void* ptr =  _aligned_malloc(size,alignment);
-#else
-	void* ptr = NULL;
-	posix_memalign(&ptr, alignment, size);
-;
-#endif
-
-	// printf("Mapped memory at %p (size %ld)\n", ptr,
-	//	(unsigned long)size);
-
-	if (ptr == NULL)
-		PanicAlert("Failed to allocate aligned memory");
-
-	return ptr;
-}
-
-void FreeMemoryPages(void* ptr, size_t size)
-{
-	if (ptr)
-	{
-#ifdef _WIN32
-	
-		if (!VirtualFree(ptr, 0, MEM_RELEASE))
-			PanicAlert("FreeMemoryPages failed!\n%s", GetLastErrorMsg());
-		ptr = NULL; // Is this our responsibility?
-	
-#else
-		munmap(ptr, size);
-#endif
-	}
-}
-
-void FreeAlignedMemory(void* ptr)
-{
-	if (ptr)
-	{
-#ifdef _WIN32
-	
-		_aligned_free(ptr);
-	
-#else
-	free(ptr);
-#endif
-	}
-}
-
-void WriteProtectMemory(void* ptr, size_t size, bool allowExecute)
-{
-#ifdef _WIN32
-	DWORD oldValue;
-	if (!VirtualProtect(ptr, size, allowExecute ? PAGE_EXECUTE_READ : PAGE_READONLY, &oldValue))
-		PanicAlert("WriteProtectMemory failed!\n%s", GetLastErrorMsg());
-#else
-	mprotect(ptr, size, allowExecute ? (PROT_READ | PROT_EXEC) : PROT_READ);
-#endif
-}
-
-void UnWriteProtectMemory(void* ptr, size_t size, bool allowExecute)
-{
-#ifdef _WIN32
-	DWORD oldValue;
-	if (!VirtualProtect(ptr, size, allowExecute ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE, &oldValue))
-		PanicAlert("UnWriteProtectMemory failed!\n%s", GetLastErrorMsg());
-#else
-	mprotect(ptr, size, allowExecute ? (PROT_READ | PROT_WRITE | PROT_EXEC) : PROT_WRITE | PROT_READ);
-#endif
-}
-
-std::string MemUsage()
-{
-#ifdef _WIN32
-#pragma comment(lib, "psapi")
-	DWORD processID = GetCurrentProcessId();
-	HANDLE hProcess;
-	PROCESS_MEMORY_COUNTERS pmc;
-	std::string Ret;
-
-	// Print information about the memory usage of the process.
-
-	hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, processID);
-	if (NULL == hProcess) return "MemUsage Error";
-
-	if (GetProcessMemoryInfo(hProcess, &pmc, sizeof(pmc)))
-		Ret = StringFromFormat("%s K", ThousandSeparate(pmc.WorkingSetSize / 1024, 7).c_str());
-
-	CloseHandle(hProcess);
-	return Ret;
-#else
-	return "";
-#endif
-}
+#else
+	static char *map_hint = 0;
+#if defined(__x86_64__) && !defined(MAP_32BIT)
+	// This OS has no flag to enforce allocation below the 4 GB boundary,
+	// but if we hint that we want a low address it is very likely we will
+	// get one.
+	// An older version of this code used MAP_FIXED, but that has the side
+	// effect of discarding already mapped pages that happen to be in the
+	// requested virtual memory range (such as the emulated RAM, sometimes).
+	if (low && (!map_hint))
+		map_hint = (char*)round_page(512*1024*1024); /* 0.5 GB rounded up to the next page */
+#endif
+	void* ptr = mmap(map_hint, size, PROT_READ | PROT_WRITE | PROT_EXEC,
+		MAP_ANON | MAP_PRIVATE
+#if defined(__x86_64__) && defined(MAP_32BIT)
+		| (low ? MAP_32BIT : 0)
+#endif
+		, -1, 0);
+#endif /* defined(_WIN32) */
+
+	// printf("Mapped executable memory at %p (size %ld)\n", ptr,
+	//	(unsigned long)size);
+	
+#if defined(__FreeBSD__)
+	if (ptr == MAP_FAILED)
+	{
+		ptr = NULL;
+#else
+	if (ptr == NULL)
+	{
+#endif	
+		PanicAlert("Failed to allocate executable memory");
+	}
+#if !defined(_WIN32) && defined(__x86_64__) && !defined(MAP_32BIT)
+	else
+	{
+		if (low)
+		{
+			map_hint += size;
+			map_hint = (char*)round_page(map_hint); /* round up to the next page */
+			// printf("Next map will (hopefully) be at %p\n", map_hint);
+		}
+	}
+#endif
+
+#if defined(_M_X64)
+	if ((u64)ptr >= 0x80000000 && low == true)
+		PanicAlert("Executable memory ended up above 2GB!");
+#endif
+
+	return ptr;
+}
+
+void* AllocateMemoryPages(size_t size)
+{
+#ifdef _WIN32
+	void* ptr = VirtualAlloc(0, size, MEM_COMMIT, PAGE_READWRITE);
+#else
+	void* ptr = mmap(0, size, PROT_READ | PROT_WRITE,
+			MAP_ANON | MAP_PRIVATE, -1, 0);
+#endif
+
+	// printf("Mapped memory at %p (size %ld)\n", ptr,
+	//	(unsigned long)size);
+
+	if (ptr == NULL)
+		PanicAlert("Failed to allocate raw memory");
+
+	return ptr;
+}
+
+void* AllocateAlignedMemory(size_t size,size_t alignment)
+{
+#ifdef _WIN32
+	void* ptr =  _aligned_malloc(size,alignment);
+#else
+	void* ptr = NULL;
+	posix_memalign(&ptr, alignment, size);
+;
+#endif
+
+	// printf("Mapped memory at %p (size %ld)\n", ptr,
+	//	(unsigned long)size);
+
+	if (ptr == NULL)
+		PanicAlert("Failed to allocate aligned memory");
+
+	return ptr;
+}
+
+void FreeMemoryPages(void* ptr, size_t size)
+{
+	if (ptr)
+	{
+#ifdef _WIN32
+	
+		if (!VirtualFree(ptr, 0, MEM_RELEASE))
+			PanicAlert("FreeMemoryPages failed!\n%s", GetLastErrorMsg());
+		ptr = NULL; // Is this our responsibility?
+	
+#else
+		munmap(ptr, size);
+#endif
+	}
+}
+
+void FreeAlignedMemory(void* ptr)
+{
+	if (ptr)
+	{
+#ifdef _WIN32
+	
+		_aligned_free(ptr);
+	
+#else
+	free(ptr);
+#endif
+	}
+}
+
+void WriteProtectMemory(void* ptr, size_t size, bool allowExecute)
+{
+#ifdef _WIN32
+	DWORD oldValue;
+	if (!VirtualProtect(ptr, size, allowExecute ? PAGE_EXECUTE_READ : PAGE_READONLY, &oldValue))
+		PanicAlert("WriteProtectMemory failed!\n%s", GetLastErrorMsg());
+#else
+	mprotect(ptr, size, allowExecute ? (PROT_READ | PROT_EXEC) : PROT_READ);
+#endif
+}
+
+void UnWriteProtectMemory(void* ptr, size_t size, bool allowExecute)
+{
+#ifdef _WIN32
+	DWORD oldValue;
+	if (!VirtualProtect(ptr, size, allowExecute ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE, &oldValue))
+		PanicAlert("UnWriteProtectMemory failed!\n%s", GetLastErrorMsg());
+#else
+	mprotect(ptr, size, allowExecute ? (PROT_READ | PROT_WRITE | PROT_EXEC) : PROT_WRITE | PROT_READ);
+#endif
+}
+
+std::string MemUsage()
+{
+#ifdef _WIN32
+#pragma comment(lib, "psapi")
+	DWORD processID = GetCurrentProcessId();
+	HANDLE hProcess;
+	PROCESS_MEMORY_COUNTERS pmc;
+	std::string Ret;
+
+	// Print information about the memory usage of the process.
+
+	hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, processID);
+	if (NULL == hProcess) return "MemUsage Error";
+
+	if (GetProcessMemoryInfo(hProcess, &pmc, sizeof(pmc)))
+		Ret = StringFromFormat("%s K", ThousandSeparate(pmc.WorkingSetSize / 1024, 7).c_str());
+
+	CloseHandle(hProcess);
+	return Ret;
+#else
+	return "";
+#endif
+}

Source/Core/Common/Src/SysConf.cpp

@@ -387,7 +387,7 @@ bool SysConf::SaveToFile(const char *filename)
 		}
 		else if (i->type == Type_SmallArray)
 		{
-			const u8 len = i->dataLength;
+			const u8 len = (u8)(i->dataLength);
 			f.WriteArray(&len, 1);
 		}
 

Source/Core/Common/Src/VideoBackendBase.h

@@ -119,6 +119,7 @@ public:
 	virtual void Video_GatherPipeBursted() = 0;
 
 	virtual bool Video_IsPossibleWaitingSetDrawDone() = 0;
+	virtual bool Video_IsHiWatermarkActive() = 0;
 	virtual void Video_AbortFrame() = 0;
 
 	virtual readFn16  Video_CPRead16() = 0;
@@ -159,6 +160,7 @@ class VideoBackendHardware : public VideoBackend
 	void Video_GatherPipeBursted();
 
 	bool Video_IsPossibleWaitingSetDrawDone();
+	bool Video_IsHiWatermarkActive();
 	void Video_AbortFrame();
 
 	readFn16  Video_CPRead16();