Various changes suggested by cppcheck

- remove unused variables
- reduce the scope where it makes sense
- correct limits (did you know that strcat()'s last parameter does not
  include the \0 that is always added?)
- set some free()'d pointers to NULL

Source/Core/AudioCommon/OpenALStream.cpp

@@ -15,22 +15,19 @@ soundtouch::SoundTouch soundTouch;
 //
 bool OpenALStream::Start()
 {
-	ALDeviceList *pDeviceList = NULL;
-	ALCcontext *pContext = NULL;
-	ALCdevice *pDevice = NULL;
 	bool bReturn = false;
 
-	pDeviceList = new ALDeviceList();
+	ALDeviceList *pDeviceList = new ALDeviceList();
 	if ((pDeviceList) && (pDeviceList->GetNumDevices()))
 	{
 		char *defDevName = pDeviceList->GetDeviceName(pDeviceList->GetDefaultDevice());
 
 		WARN_LOG(AUDIO, "Found OpenAL device %s", defDevName);
 
-		pDevice = alcOpenDevice(defDevName);
+		ALCdevice *pDevice = alcOpenDevice(defDevName);
 		if (pDevice)
 		{
-			pContext = alcCreateContext(pDevice, NULL);
+			ALCcontext *pContext = alcCreateContext(pDevice, NULL);
 			if (pContext)
 			{
 				// Used to determine an appropriate period size (2x period = total buffer size)

Source/Core/AudioCommon/aldlist.cpp

@@ -42,10 +42,6 @@
 ALDeviceList::ALDeviceList()
 {
 	ALDEVICEINFO ALDeviceInfo;
-	char *devices;
-	s32 index;
-	const char *defaultDeviceName = NULL;
-	const char *actualDeviceName = NULL;
 
 	// DeviceInfo vector stores, for each enumerated device, it's device name, selection status, spec version #, and extension support
 	vDeviceInfo.clear();
@@ -57,11 +53,10 @@ ALDeviceList::ALDeviceList()
 	//if (LoadOAL10Library(NULL, &ALFunction) == TRUE) {
 		if (alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT"))
 		{
-			devices = (char *)alcGetString(NULL, ALC_DEVICE_SPECIFIER);
+			const char *devices = alcGetString(NULL, ALC_DEVICE_SPECIFIER);
-			defaultDeviceName = (char *)alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);
+			const char *defaultDeviceName = alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);
-			index = 0;
 			// go through device list (each device terminated with a single NULL, list terminated with double NULL)
-			while (devices != NULL && strlen(devices) > 0)
+			for (s32 index = 0; devices != NULL && strlen(devices) > 0; index++, devices += strlen(devices) + 1)
 			{
 				if (strcmp(defaultDeviceName, devices) == 0)
 				{
@@ -75,7 +70,7 @@ ALDeviceList::ALDeviceList()
 					{
 						alcMakeContextCurrent(context);
 						// if new actual device name isn't already in the list, then add it...
-						actualDeviceName = alcGetString(device, ALC_DEVICE_SPECIFIER);
+						const char *actualDeviceName = alcGetString(device, ALC_DEVICE_SPECIFIER);
 						bool bNewName = true;
 						for (s32 i = 0; i < GetNumDevices(); i++)
 						{
@@ -130,8 +125,6 @@ ALDeviceList::ALDeviceList()
 					}
 					alcCloseDevice(device);
 				}
-				devices += strlen(devices) + 1;
-				index += 1;
 			}
 		}
 	//}

Source/Core/Common/ArmEmitter.h

@@ -735,8 +735,8 @@ public:
 	{
 #ifndef __SYMBIAN32__
 		FreeMemoryPages(region, region_size);
-#endif
 		region = NULL;
+#endif
 		region_size = 0;
 	}
 

Source/Core/Common/CDUtils.cpp

@@ -196,7 +196,7 @@ std::vector<std::string> cdio_get_devices ()
 		for (unsigned int j = checklist[i].num_min; j <= checklist[i].num_max; ++j)
 		{
 			std::string drive = StringFromFormat(checklist[i].format, j);
-			if ( (is_cdrom(drive, NULL)) > 0 )
+			if (is_cdrom(drive, NULL))
 			{
 				drives.push_back(std::move(drive));
 			}

Source/Core/Common/Common.h

@@ -25,6 +25,14 @@ extern const char *netplay_dolphin_ver;
 #define LOGGING 1
 #endif
 
+#if defined(__GNUC__) || __clang__
+// Disable "unused function" warnings for the ones manually marked as such.
+#define UNUSED __attribute__((unused))
+#else
+// Not sure MSVC even checks this...
+#define UNUSED
+#endif
+
 #define STACKALIGN
 
 #if __cplusplus >= 201103 || defined(_MSC_VER) || defined(__GXX_EXPERIMENTAL_CXX0X__)

Source/Core/Common/ExtendedTrace.cpp

@@ -362,8 +362,6 @@ void StackTrace(HANDLE hThread, const char* lpszMessage, FILE *file, DWORD eip,
 {
 	STACKFRAME     callStack;
 	BOOL           bResult;
-	TCHAR          symInfo[BUFFERSIZE] = _T("?");
-	TCHAR          srcInfo[BUFFERSIZE] = _T("?");
 	HANDLE         hProcess = GetCurrentProcess();
 
 	// If it's not this thread, let's suspend it, and resume it at the end

Source/Core/Common/FPURoundMode.h

@@ -20,11 +20,11 @@ namespace FPURoundMode
 		PREC_53 = 1,
 		PREC_64 = 2
 	};
-	void SetRoundMode(enum RoundModes mode);
+	void SetRoundMode(RoundModes mode);
 
-	void SetPrecisionMode(enum PrecisionModes mode);
+	void SetPrecisionMode(PrecisionModes mode);
 
-	void SetSIMDMode(enum RoundModes rounding_mode, bool non_ieee_mode);
+	void SetSIMDMode(RoundModes rounding_mode, bool non_ieee_mode);
 
 /*
  * There are two different flavors of float to int conversion:

Source/Core/Common/GenericFPURoundMode.cpp

@@ -21,13 +21,13 @@
 // Generic, do nothing
 namespace FPURoundMode
 {
-	void SetRoundMode(enum RoundModes mode)
+	void SetRoundMode(RoundModes mode)
 	{
 	}
-	void SetPrecisionMode(enum PrecisionModes mode)
+	void SetPrecisionMode(PrecisionModes mode)
 	{
 	}
-	void SetSIMDMode(enum RoundModes rounding_mode, bool non_ieee_mode)
+	void SetSIMDMode(RoundModes rounding_mode, bool non_ieee_mode)
 	{
 	}
 	void SaveSIMDState()

Source/Core/Common/IniFile.cpp

@@ -124,13 +124,12 @@ bool IniFile::Section::Get(const std::string& key, std::vector<std::string>& out
 	}
 	// ignore starting , if any
 	size_t subStart = temp.find_first_not_of(",");
-	size_t subEnd;
 
 	// split by ,
 	while (subStart != std::string::npos)
 	{
 		// Find next ,
-		subEnd = temp.find_first_of(",", subStart);
+		size_t subEnd = temp.find_first_of(",", subStart);
 		if (subStart != subEnd)
 			// take from first char until next ,
 			out.push_back(StripSpaces(temp.substr(subStart, subEnd - subStart)));

Source/Core/Common/MemArena.cpp

@@ -36,7 +36,7 @@ int AshmemCreateFileMapping(const char *name, size_t size)
 		return fd;
 
 	// We don't really care if we can't set the name, it is optional
-	ret = ioctl(fd, ASHMEM_SET_NAME, name);
+	ioctl(fd, ASHMEM_SET_NAME, name);
 
 	ret = ioctl(fd, ASHMEM_SET_SIZE, size);
 	if (ret < 0)

Source/Core/Common/MemoryUtil.cpp

@@ -129,11 +129,10 @@ 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
@@ -145,9 +144,9 @@ void FreeAlignedMemory(void* ptr)
 	if (ptr)
 	{
 #ifdef _WIN32
-	_aligned_free(ptr);
+		_aligned_free(ptr);
 #else
-	free(ptr);
+		free(ptr);
 #endif
 	}
 }

Source/Core/Common/x64FPURoundMode.cpp

@@ -18,7 +18,7 @@ namespace FPURoundMode
 	static u32 saved_sse_state = _mm_getcsr();
 	static const u32 default_sse_state = _mm_getcsr();
 
-	void SetRoundMode(enum RoundModes mode)
+	void SetRoundMode(RoundModes mode)
 	{
 		// Set FPU rounding mode to mimic the PowerPC's
 		#ifdef _M_IX86
@@ -49,7 +49,7 @@ namespace FPURoundMode
 		#endif
 	}
 
-	void SetPrecisionMode(enum PrecisionModes mode)
+	void SetPrecisionMode(PrecisionModes mode)
 	{
 		#ifdef _M_IX86
 			// sets the floating-point lib to 53-bit
@@ -75,7 +75,7 @@ namespace FPURoundMode
 		#endif
 	}
 
-	void SetSIMDMode(enum RoundModes rounding_mode, bool non_ieee_mode)
+	void SetSIMDMode(RoundModes rounding_mode, bool non_ieee_mode)
 	{
 		// OR-mask for disabling FPU exceptions (bits 7-12 in the MXCSR register)
 		const u32 EXCEPTION_MASK = 0x1F80;

Source/Core/Core/ARDecrypt.cpp

@@ -145,51 +145,56 @@ const u32 table7[0x40] = {
 
 void generateseeds(u32 *seeds, const u8 *seedtable, u8 doreverse)
 {
-	int i,j;
 	u32 tmp3;
 	u8 array0[0x38],array1[0x38],array2[0x08];
 	u8 tmp,tmp2;
 
-	i = 0;
+	for (int i = 0; i < 0x38; ++i)
-	while (i < 0x38)
 	{
 		tmp = (gentable0[i] - 1);
-		array0[i++] = ((u32)(0-(seedtable[tmp>>3] & gentable1[tmp&7])) >> 31);
+		array0[i] = ((u32)(0-(seedtable[tmp>>3] & gentable1[tmp&7])) >> 31);
 	}
 
-	i = 0;
+	for (int i = 0; i < 0x10; ++i)
-	while (i < 0x10)
 	{
 		memset(array2,0,8);
 		tmp2 = gentable2[i];
 
-		for (j = 0; j < 0x38; j++)
+		for (int j = 0; j < 0x38; j++)
 		{
 			tmp = (tmp2+j);
 
 			if (j > 0x1B)
 			{
-				if (tmp > 0x37) tmp-=0x1C;
+				if (tmp > 0x37)
+				{
+					tmp-=0x1C;
+				}
+			}
+			else if (tmp > 0x1B)
+			{
+				tmp-=0x1C;
 			}
-			else if (tmp > 0x1B) tmp-=0x1C;
 
 			array1[j] = array0[tmp];
 		}
-		for (j = 0; j < 0x30; j++)
+		for (int j = 0; j < 0x30; j++)
 		{
-			if (!array1[gentable3[j]-1]) continue;
+			if (!array1[gentable3[j]-1])
+			{
+				continue;
+			}
 			tmp = (((j*0x2AAB)>>16) - (j>>0x1F));
 			array2[tmp] |= (gentable1[j-(tmp*6)]>>2);
 		}
 		seeds[i<<1] = ((array2[0]<<24)|(array2[2]<<16)|(array2[4]<<8)|array2[6]);
 		seeds[(i<<1)+1] = ((array2[1]<<24)|(array2[3]<<16)|(array2[5]<<8)|array2[7]);
-		i++;
 	}
 
 	if (!doreverse)
 	{
-		j = 0x1F;
+		int j = 0x1F;
-		for (i = 0; i < 16; i+=2)
+		for (int i = 0; i < 16; i+=2)
 		{
 			tmp3 = seeds[i];
 			seeds[i] = seeds[j-1];
@@ -222,20 +227,17 @@ void setcode(u32 *dst, u32 addr, u32 val)
 
 u16 gencrc16(u32 *codes, u16 size)
 {
-	u16 ret=0;
+	u16 ret = 0;
-	u8 tmp=0,tmp2;
-	int i;
 
 	if (size > 0)
 	{
-		while (tmp < size)
+		for (u8 tmp = 0; tmp < size; ++tmp)
 		{
-			for (i = 0; i < 4; i++)
+			for (int i = 0; i < 4; ++i)
 			{
-				tmp2 = ((codes[tmp] >> (i<<3))^ret);
+				u8 tmp2 = ((codes[tmp] >> (i<<3))^ret);
 				ret = ((crctable0[(tmp2>>4)&0x0F]^crctable1[tmp2&0x0F])^(ret>>8));
 			}
-			tmp++;
 		}
 	}
 	return ret;
@@ -243,9 +245,7 @@ u16 gencrc16(u32 *codes, u16 size)
 
 u8 verifycode(u32 *codes, u16 size)
 {
-	u16 tmp;
+	u16 tmp = gencrc16(codes,size);
-
-	tmp = gencrc16(codes,size);
 	return (((tmp>>12)^(tmp>>8)^(tmp>>4)^tmp)&0x0F);
 }
 
@@ -338,7 +338,10 @@ bool getbitstring(u32 *ctrl, u32 *out, u8 len)
 			ctrl[1]++;
 			tmp = (ctrl[0]+(ctrl[1]<<2));
 		}
-		if (ctrl[1] >= ctrl[3]) return false;
+		if (ctrl[1] >= ctrl[3])
+		{
+			return false;
+		}
 		*out = ((*out<<1) | ((tmp >> (0x1F-ctrl[2])) & 1));
 		ctrl[2]++;
 	}
@@ -372,13 +375,16 @@ bool batchdecrypt(u32 *codes, u16 size)
 	getbitstring(tmparray,tmparray2+5,2);  // Region
 
 	// Grab gameid and region from the last decrypted code
-	// Maybe check this against dolphin's GameID? - "code is for wrong game" type msg
+	// TODO: Maybe check this against dolphin's GameID? - "code is for wrong game" type msg
 	//gameid = tmparray2[1];
 	//region = tmparray2[5];
 
 	tmp = codes[0];
 	codes[0] &= 0x0FFFFFFF;
-	if ((tmp>>28) != verifycode(codes,size)) return false;
+	if ((tmp>>28) != verifycode(codes,size))
+	{
+		return false;
+	}
 
 	return true;
 
@@ -406,23 +412,24 @@ int GetVal(const char *flt, char chr)
 
 int alphatobin(u32 *dst, std::vector<std::string> alpha, int size)
 {
-	int i,j=0,k;
+	int j = 0;
-	int ret=0,org=(size+1);
+	int ret = 0;
+	int org = size + 1;
 	u32 bin[2];
 	u8 parity;
 
-	while (size)
+	for (; size; --size)
 	{
-		bin[0]=0;
+		bin[0] = 0;
-		for (i = 0; i < 6; i++)
+		for (int i = 0; i < 6; i++)
 		{
 			bin[0] |= (GetVal(filter,alpha[j>>1][i]) << (((5-i)*5)+2));
 		}
 		bin[0] |= (GetVal(filter,alpha[j>>1][6]) >> 3);
 		dst[j++] = bin[0];
 
-		bin[1]=0;
+		bin[1] = 0;
-		for (i = 0; i < 6; i++)
+		for (int i = 0; i < 6; i++)
 		{
 			bin[1] |= (GetVal(filter,alpha[j>>1][i+6]) << (((5-i)*5)+4));
 		}
@@ -430,16 +437,20 @@ int alphatobin(u32 *dst, std::vector<std::string> alpha, int size)
 		dst[j++] = bin[1];
 
 		//verify parity bit
-		k=0;
+		int k = 0;
-		parity=0;
+		parity = 0;
-		for (i = 0; i < 64; i++)
+		for (int i = 0; i < 64; i++)
 		{
-			if (i == 32) k++;
+			if (i == 32)
+			{
+				k++;
+			}
 			parity ^= (bin[k] >> (i-(k<<5)));
 		}
-		if ((parity&1) != (GetVal(filter,alpha[(j-2)>>1][12])&1)) ret=(org-size);
+		if ((parity&1) != (GetVal(filter,alpha[(j-2)>>1][12])&1))
-
+		{
-		size--;
+			ret=(org-size);
+		}
 	}
 
 	return ret;
@@ -451,12 +462,11 @@ void DecryptARCode(std::vector<std::string> vCodes, std::vector<AREntry> &ops)
 	buildseeds();
 
 	u32 uCodes[1200];
-	u32 i,ret;
+	u32 ret;
 
-	for(i = 0; i < vCodes.size(); ++i)
+	for (std::string& s : vCodes)
 	{
-		transform(vCodes[i].begin(), vCodes[i].end(), vCodes[i].begin(), toupper);
+		std::transform(s.begin(), s.end(), s.begin(), toupper);
-		//PanicAlert("Encrypted AR Code\n%s", vCodes[i].c_str());
 	}
 
 	if ((ret=alphatobin(uCodes, vCodes, (int)vCodes.size())))
@@ -470,7 +480,7 @@ void DecryptARCode(std::vector<std::string> vCodes, std::vector<AREntry> &ops)
 		//PanicAlert("Action Replay Code Decryption Error:\nCRC Check Failed\n\n"
 		// "First Code in Block(should be verification code):\n%s", vCodes[0].c_str());
 
-		for (i = 0; i < (vCodes.size()<<1); i+=2)
+		for (size_t i = 0; i < (vCodes.size()<<1); i+=2)
 		{
 			AREntry op;
 			op.cmd_addr = uCodes[i];
@@ -482,7 +492,7 @@ void DecryptARCode(std::vector<std::string> vCodes, std::vector<AREntry> &ops)
 	else
 	{
 		// Skip passing the verification code back
-		for (i = 2; i < (vCodes.size()<<1); i+=2)
+		for (size_t i = 2; i < (vCodes.size()<<1); i+=2)
 		{
 			AREntry op;
 			op.cmd_addr = uCodes[i];

Source/Core/Core/ActionReplay.cpp

@@ -100,14 +100,14 @@ struct ARAddr
 };
 
 void LogInfo(const char *format, ...);
-bool Subtype_RamWriteAndFill(const ARAddr addr, const u32 data);
+bool Subtype_RamWriteAndFill(const ARAddr& addr, const u32 data);
-bool Subtype_WriteToPointer(const ARAddr addr, const u32 data);
+bool Subtype_WriteToPointer(const ARAddr& addr, const u32 data);
-bool Subtype_AddCode(const ARAddr addr, const u32 data);
+bool Subtype_AddCode(const ARAddr& addr, const u32 data);
-bool Subtype_MasterCodeAndWriteToCCXXXXXX(const ARAddr addr, const u32 data);
+bool Subtype_MasterCodeAndWriteToCCXXXXXX(const ARAddr& addr, const u32 data);
-bool ZeroCode_FillAndSlide(const u32 val_last, const ARAddr addr, const u32 data);
+bool ZeroCode_FillAndSlide(const u32 val_last, const ARAddr& addr, const u32 data);
-bool ZeroCode_MemoryCopy(const u32 val_last, const ARAddr addr, const u32 data);
+bool ZeroCode_MemoryCopy(const u32 val_last, const ARAddr& addr, const u32 data);
-bool NormalCode(const ARAddr addr, const u32 data);
+bool NormalCode(const ARAddr& addr, const u32 data);
-bool ConditionalCode(const ARAddr addr, const u32 data, int* const pSkipCount);
+bool ConditionalCode(const ARAddr& addr, const u32 data, int* const pSkipCount);
 bool CompareValues(const u32 val1, const u32 val2, const int type);
 
 // ----------------------
@@ -487,7 +487,7 @@ bool IsSelfLogging()
 
 // ----------------------
 // Code Functions
-bool Subtype_RamWriteAndFill(const ARAddr addr, const u32 data)
+bool Subtype_RamWriteAndFill(const ARAddr& addr, const u32 data)
 {
 	const u32 new_addr = addr.GCAddress();
 
@@ -544,7 +544,7 @@ bool Subtype_RamWriteAndFill(const ARAddr addr, const u32 data)
 	return true;
 }
 
-bool Subtype_WriteToPointer(const ARAddr addr, const u32 data)
+bool Subtype_WriteToPointer(const ARAddr& addr, const u32 data)
 {
 	const u32 new_addr = addr.GCAddress();
 	const u32 ptr = Memory::Read_U32(new_addr);
@@ -603,7 +603,7 @@ bool Subtype_WriteToPointer(const ARAddr addr, const u32 data)
 	return true;
 }
 
-bool Subtype_AddCode(const ARAddr addr, const u32 data)
+bool Subtype_AddCode(const ARAddr& addr, const u32 data)
 {
 	// Used to increment/decrement a value in memory
 	const u32 new_addr = addr.GCAddress();
@@ -663,7 +663,7 @@ bool Subtype_AddCode(const ARAddr addr, const u32 data)
 	return true;
 }
 
-bool Subtype_MasterCodeAndWriteToCCXXXXXX(const ARAddr addr, const u32 data)
+bool Subtype_MasterCodeAndWriteToCCXXXXXX(const ARAddr& addr, const u32 data)
 {
 	// code not yet implemented - TODO
 	// u32 new_addr = (addr & 0x01FFFFFF) | 0x80000000;
@@ -675,7 +675,7 @@ bool Subtype_MasterCodeAndWriteToCCXXXXXX(const ARAddr addr, const u32 data)
 	return false;
 }
 
-bool ZeroCode_FillAndSlide(const u32 val_last, const ARAddr addr, const u32 data) // This needs more testing
+bool ZeroCode_FillAndSlide(const u32 val_last, const ARAddr& addr, const u32 data) // This needs more testing
 {
 	const u32 new_addr = ((ARAddr*)&val_last)->GCAddress();
 	const u8 size = ((ARAddr*)&val_last)->size;
@@ -750,7 +750,7 @@ bool ZeroCode_FillAndSlide(const u32 val_last, const ARAddr addr, const u32 data
 }
 
 // Looks like this is new?? - untested
-bool ZeroCode_MemoryCopy(const u32 val_last, const ARAddr addr, const u32 data)
+bool ZeroCode_MemoryCopy(const u32 val_last, const ARAddr& addr, const u32 data)
 {
 	const u32 addr_dest = val_last | 0x06000000;
 	const u32 addr_src = addr.GCAddress();
@@ -796,7 +796,7 @@ bool ZeroCode_MemoryCopy(const u32 val_last, const ARAddr addr, const u32 data)
 	return true;
 }
 
-bool NormalCode(const ARAddr addr, const u32 data)
+bool NormalCode(const ARAddr& addr, const u32 data)
 {
 	switch (addr.subtype)
 	{
@@ -834,7 +834,7 @@ bool NormalCode(const ARAddr addr, const u32 data)
 	return true;
 }
 
-bool ConditionalCode(const ARAddr addr, const u32 data, int* const pSkipCount)
+bool ConditionalCode(const ARAddr& addr, const u32 data, int* const pSkipCount)
 {
 	const u32 new_addr = addr.GCAddress();
 

Source/Core/Core/Boot/Boot_BS2Emu.cpp

@@ -392,7 +392,6 @@ bool CBoot::EmulatedBS2_Wii()
 		Memory::Write_U32(firmwareVer ? firmwareVer : 0x00090204, 0x00003140);
 
 		// Load patches and run startup patches
-		std::string gameID = VolumeHandler::GetVolume()->GetUniqueID();
 		PatchEngine::LoadPatches();
 
 		// return

Source/Core/Core/BootManager.cpp

@@ -48,7 +48,7 @@ namespace BootManager
 struct ConfigCache
 {
 	bool valid, bCPUThread, bSkipIdle, bEnableFPRF, bMMU, bDCBZOFF, m_EnableJIT, bDSPThread,
-		bVBeamSpeedHack, bSyncGPU, bFastDiscSpeed, bMergeBlocks, bDSPHLE, bHLE_BS2, bTLBHack, bUseFPS;
+	     bVBeamSpeedHack, bSyncGPU, bFastDiscSpeed, bMergeBlocks, bDSPHLE, bHLE_BS2, bTLBHack;
 	int iCPUCore, Volume;
 	int iWiimoteSource[MAX_BBMOTES];
 	SIDevices Pads[MAX_SI_CHANNELS];

Source/Core/Core/DSP/DSPCore.cpp

@@ -134,6 +134,7 @@ static void DSPCore_FreeMemoryPages()
 	FreeMemoryPages(g_dsp.iram, DSP_IRAM_BYTE_SIZE);
 	FreeMemoryPages(g_dsp.dram, DSP_DRAM_BYTE_SIZE);
 	FreeMemoryPages(g_dsp.coef, DSP_COEF_BYTE_SIZE);
+	g_dsp.irom = g_dsp.iram = g_dsp.dram = g_dsp.coef = NULL;
 }
 
 bool DSPCore_Init(const char *irom_filename, const char *coef_filename,

Source/Core/Core/DSP/Jit/DSPJitRegCache.cpp

@@ -35,12 +35,18 @@ static void *reg_ptr(int reg)
 	case DSP_REG_ACH0:
 	case DSP_REG_ACH1:
 		return &g_dsp.r.ac[reg - DSP_REG_ACH0].h;
-	case DSP_REG_CR:     return &g_dsp.r.cr;
+	case DSP_REG_CR:
-	case DSP_REG_SR:     return &g_dsp.r.sr;
+		return &g_dsp.r.cr;
-	case DSP_REG_PRODL:  return &g_dsp.r.prod.l;
+	case DSP_REG_SR:
-	case DSP_REG_PRODM:  return &g_dsp.r.prod.m;
+		return &g_dsp.r.sr;
-	case DSP_REG_PRODH:  return &g_dsp.r.prod.h;
+	case DSP_REG_PRODL:
-	case DSP_REG_PRODM2: return &g_dsp.r.prod.m2;
+		return &g_dsp.r.prod.l;
+	case DSP_REG_PRODM:
+		return &g_dsp.r.prod.m;
+	case DSP_REG_PRODH:
+		return &g_dsp.r.prod.h;
+	case DSP_REG_PRODM2:
+		return &g_dsp.r.prod.m2;
 	case DSP_REG_AXL0:
 	case DSP_REG_AXL1:
 		return &g_dsp.r.ax[reg - DSP_REG_AXL0].l;
@@ -81,24 +87,24 @@ DSPJitRegCache::DSPJitRegCache(DSPEmitter &_emitter)
 		xreg.pushed = false;
 	}
 
-	xregs[RAX].guest_reg = DSP_REG_STATIC;// reserved for MUL/DIV
+	xregs[RAX].guest_reg = DSP_REG_STATIC; // reserved for MUL/DIV
-	xregs[RDX].guest_reg = DSP_REG_STATIC;// reserved for MUL/DIV
+	xregs[RDX].guest_reg = DSP_REG_STATIC; // reserved for MUL/DIV
-	xregs[RCX].guest_reg = DSP_REG_STATIC;// reserved for shifts
+	xregs[RCX].guest_reg = DSP_REG_STATIC; // reserved for shifts
 
-	xregs[RBX].guest_reg = DSP_REG_STATIC;//extended op backing store
+	xregs[RBX].guest_reg = DSP_REG_STATIC; // extended op backing store
 
-	xregs[RSP].guest_reg = DSP_REG_STATIC;//stack pointer
+	xregs[RSP].guest_reg = DSP_REG_STATIC; // stack pointer
 
-	xregs[RBP].guest_reg = DSP_REG_NONE;//definitely usable in dsplle because
+	xregs[RBP].guest_reg = DSP_REG_NONE; // definitely usable in dsplle because
-										//all external calls are protected
+	                                     // all external calls are protected
 
 	xregs[RSI].guest_reg = DSP_REG_NONE;
 	xregs[RDI].guest_reg = DSP_REG_NONE;
 
 #ifdef _M_X64
 #ifdef STATIC_REG_ACCS
-	xregs[R8].guest_reg = DSP_REG_STATIC;//acc0
+	xregs[R8].guest_reg = DSP_REG_STATIC; //acc0
-	xregs[R9].guest_reg = DSP_REG_STATIC;//acc1
+	xregs[R9].guest_reg = DSP_REG_STATIC; //acc1
 #else
 	xregs[R8].guest_reg = DSP_REG_NONE;
 	xregs[R9].guest_reg = DSP_REG_NONE;
@@ -121,12 +127,13 @@ DSPJitRegCache::DSPJitRegCache(DSPEmitter &_emitter)
 		regs[i].parentReg = DSP_REG_NONE;
 		regs[i].shift = 0;
 		regs[i].host_reg = INVALID_REG;
-
 		regs[i].loc = M(regs[i].mem);
 	}
 
 	for(unsigned int i = 0; i < 32; i++)
+	{
 		regs[i].size = 2;
+	}
 	//special composite registers
 #ifdef _M_X64
 #ifdef STATIC_REG_ACCS
@@ -170,8 +177,8 @@ DSPJitRegCache::DSPJitRegCache(DSPEmitter &_emitter)
 DSPJitRegCache::DSPJitRegCache(const DSPJitRegCache &cache)
 	: emitter(cache.emitter), temporary(true), merged(false)
 {
-	memcpy(xregs,cache.xregs,sizeof(xregs));
+	memcpy(xregs, cache.xregs, sizeof(xregs));
-	memcpy(regs,cache.regs,sizeof(regs));
+	memcpy(regs, cache.regs, sizeof(regs));
 }
 
 DSPJitRegCache& DSPJitRegCache::operator=(const DSPJitRegCache &cache)
@@ -179,8 +186,8 @@ DSPJitRegCache& DSPJitRegCache::operator=(const DSPJitRegCache &cache)
 	_assert_msg_(DSPLLE, &emitter == &cache.emitter, "emitter does not match");
 	_assert_msg_(DSPLLE, temporary, "register cache not temporary??");
 	merged = false;
-	memcpy(xregs,cache.xregs,sizeof(xregs));
+	memcpy(xregs, cache.xregs, sizeof(xregs));
-	memcpy(regs,cache.regs,sizeof(regs));
+	memcpy(regs, cache.regs, sizeof(regs));
 
 	return *this;
 }
@@ -199,18 +206,20 @@ void DSPJitRegCache::flushRegs(DSPJitRegCache &cache, bool emit)
 {
 	cache.merged = true;
 
-	unsigned int i;
+	size_t i;
 
-	//drop all guest register not used by cache
+	// drop all guest register not used by cache
 	for(i = 0; i <= DSP_REG_MAX_MEM_BACKED; i++)
 	{
-		regs[i].used = false;//used is restored later
+		regs[i].used = false; //used is restored later
 		if (regs[i].loc.IsSimpleReg() &&
-			!cache.regs[i].loc.IsSimpleReg())
+		    !cache.regs[i].loc.IsSimpleReg())
+		{
 			movToMemory(i);
+		}
 	}
 
-	//try to move guest regs in the wrong host reg to the correct one
+	// try to move guest regs in the wrong host reg to the correct one
 	int movcnt;
 	do
 	{
@@ -228,16 +237,18 @@ void DSPJitRegCache::flushRegs(DSPJitRegCache &cache, bool emit)
 		}
 	} while (movcnt != 0);
 
-	//free all host regs that are not used for the same guest reg
+	// free all host regs that are not used for the same guest reg
 	for(i = 0; i <= DSP_REG_MAX_MEM_BACKED; i++)
 	{
 		if (cache.regs[i].loc.GetSimpleReg() !=
-			regs[i].loc.GetSimpleReg() &&
+		    regs[i].loc.GetSimpleReg() &&
-			regs[i].loc.IsSimpleReg())
+		    regs[i].loc.IsSimpleReg())
+		{
 			movToMemory(i);
+		}
 	}
 
-	//load all guest regs that are in memory and should be in host reg
+	// load all guest regs that are in memory and should be in host reg
 	for(i = 0; i <= DSP_REG_MAX_MEM_BACKED; i++)
 	{
 		if (cache.regs[i].loc.IsSimpleReg())
@@ -255,43 +266,48 @@ void DSPJitRegCache::flushRegs(DSPJitRegCache &cache, bool emit)
 		regs[i].last_use_ctr = cache.regs[i].last_use_ctr;
 	}
 
-	//sync the freely used xregs
+	// sync the freely used xregs
 	if (!emit) {
-		for(i = 0; i < NUMXREGS; i++) {
+		for(i = 0; i < NUMXREGS; i++)
+		{
 			if (cache.xregs[i].guest_reg == DSP_REG_USED &&
 			    xregs[i].guest_reg == DSP_REG_NONE)
+			{
 				xregs[i].guest_reg = DSP_REG_USED;
+			}
 			if (cache.xregs[i].guest_reg == DSP_REG_NONE &&
 			    xregs[i].guest_reg == DSP_REG_USED)
+			{
 				xregs[i].guest_reg = DSP_REG_NONE;
+			}
 		}
 	}
 
-	//consistency checks
+	// consistency checks
 	for(i = 0; i < NUMXREGS; i++)
 	{
 		_assert_msg_(DSPLLE,
 			     xregs[i].guest_reg == cache.xregs[i].guest_reg,
-			     "cache and current xreg guest_reg mismatch for %d", i);
+			     "cache and current xreg guest_reg mismatch for %zi", i);
 	}
 
 	for(i = 0; i <= DSP_REG_MAX_MEM_BACKED; i++)
 	{
 		_assert_msg_(DSPLLE,
 			     regs[i].loc.IsImm() == cache.regs[i].loc.IsImm(),
-			     "cache and current reg loc mismatch for %x", i);
+			     "cache and current reg loc mismatch for %zi", i);
 		_assert_msg_(DSPLLE,
 			     regs[i].loc.GetSimpleReg() == cache.regs[i].loc.GetSimpleReg(),
-			     "cache and current reg loc mismatch for %x", i);
+			     "cache and current reg loc mismatch for %zi", i);
 		_assert_msg_(DSPLLE,
 			     regs[i].dirty || !cache.regs[i].dirty,
-			     "cache and current reg dirty mismatch for %x", i);
+			     "cache and current reg dirty mismatch for %zi", i);
 		_assert_msg_(DSPLLE,
 			     regs[i].used == cache.regs[i].used,
-			     "cache and current reg used mismatch for %x", i);
+			     "cache and current reg used mismatch for %zi", i);
 		_assert_msg_(DSPLLE,
 			     regs[i].shift == cache.regs[i].shift,
-			     "cache and current reg shift mismatch for %x", i);
+			     "cache and current reg shift mismatch for %zi", i);
 	}
 
 	use_ctr = cache.use_ctr;
@@ -299,9 +315,9 @@ void DSPJitRegCache::flushRegs(DSPJitRegCache &cache, bool emit)
 
 void DSPJitRegCache::flushMemBackedRegs()
 {
-	//also needs to undo any dynamic changes to static allocated regs
+	// also needs to undo any dynamic changes to static allocated regs
-	//this should have the same effect as
+	// this should have the same effect as
-	//merge(DSPJitRegCache(emitter));
+	// merge(DSPJitRegCache(emitter));
 
 	for(unsigned int i = 0; i <= DSP_REG_MAX_MEM_BACKED; i++)
 	{
@@ -309,7 +325,9 @@ void DSPJitRegCache::flushMemBackedRegs()
 			     "register %x still in use", i);
 
 		if (regs[i].used)
+		{
 			emitter.INT3();
+		}
 
 		if (regs[i].host_reg != INVALID_REG)
 		{
@@ -330,65 +348,67 @@ void DSPJitRegCache::flushRegs()
 	for(unsigned int i = 0; i <= DSP_REG_MAX_MEM_BACKED; i++)
 	{
 		if (regs[i].host_reg != INVALID_REG)
+		{
 			movToMemory(i);
+		}
 	}
 
 	for(unsigned int i = 0; i <= DSP_REG_MAX_MEM_BACKED; i++)
 	{
 		_assert_msg_(DSPLLE,
-			     !regs[i].loc.IsSimpleReg(),
+		             !regs[i].loc.IsSimpleReg(),
-			     "register %x is still a simple reg", i);
+		             "register %x is still a simple reg", i);
 	}
 
 	_assert_msg_(DSPLLE,
-		     xregs[RSP].guest_reg == DSP_REG_STATIC,
+	             xregs[RSP].guest_reg == DSP_REG_STATIC,
-		     "wrong xreg state for %d", RSP);
+	             "wrong xreg state for %d", RSP);
 	_assert_msg_(DSPLLE,
-		     xregs[RBX].guest_reg == DSP_REG_STATIC,
+	             xregs[RBX].guest_reg == DSP_REG_STATIC,
-		     "wrong xreg state for %d", RBX);
+	             "wrong xreg state for %d", RBX);
 	_assert_msg_(DSPLLE,
-		     xregs[RBP].guest_reg == DSP_REG_NONE,
+	             xregs[RBP].guest_reg == DSP_REG_NONE,
-		     "wrong xreg state for %d", RBP);
+	             "wrong xreg state for %d", RBP);
 	_assert_msg_(DSPLLE,
-		     xregs[RSI].guest_reg == DSP_REG_NONE,
+	             xregs[RSI].guest_reg == DSP_REG_NONE,
-		     "wrong xreg state for %d", RSI);
+	             "wrong xreg state for %d", RSI);
 	_assert_msg_(DSPLLE,
-		     xregs[RDI].guest_reg == DSP_REG_NONE,
+	             xregs[RDI].guest_reg == DSP_REG_NONE,
-		     "wrong xreg state for %d", RDI);
+	             "wrong xreg state for %d", RDI);
 #ifdef _M_X64
 #ifdef STATIC_REG_ACCS
 	_assert_msg_(DSPLLE,
-		     xregs[R8].guest_reg == DSP_REG_STATIC,
+	             xregs[R8].guest_reg == DSP_REG_STATIC,
-		     "wrong xreg state for %d", R8);
+	             "wrong xreg state for %d", R8);
 	_assert_msg_(DSPLLE,
-		     xregs[R9].guest_reg == DSP_REG_STATIC,
+	             xregs[R9].guest_reg == DSP_REG_STATIC,
-		     "wrong xreg state for %d", R9);
+	             "wrong xreg state for %d", R9);
 #else
 	_assert_msg_(DSPLLE,
-		     xregs[R8].guest_reg == DSP_REG_NONE,
+	             xregs[R8].guest_reg == DSP_REG_NONE,
-		     "wrong xreg state for %d", R8);
+	             "wrong xreg state for %d", R8);
 	_assert_msg_(DSPLLE,
-		     xregs[R9].guest_reg == DSP_REG_NONE,
+	             xregs[R9].guest_reg == DSP_REG_NONE,
-		     "wrong xreg state for %d", R9);
+	             "wrong xreg state for %d", R9);
 #endif
 	_assert_msg_(DSPLLE,
-		     xregs[R10].guest_reg == DSP_REG_NONE,
+	             xregs[R10].guest_reg == DSP_REG_NONE,
-		     "wrong xreg state for %d", R10);
+	             "wrong xreg state for %d", R10);
 	_assert_msg_(DSPLLE,
-		     xregs[R11].guest_reg == DSP_REG_NONE,
+	             xregs[R11].guest_reg == DSP_REG_NONE,
-		     "wrong xreg state for %d", R11);
+	             "wrong xreg state for %d", R11);
 	_assert_msg_(DSPLLE,
-		     xregs[R12].guest_reg == DSP_REG_NONE,
+	             xregs[R12].guest_reg == DSP_REG_NONE,
-		     "wrong xreg state for %d", R12);
+	             "wrong xreg state for %d", R12);
 	_assert_msg_(DSPLLE,
-		     xregs[R13].guest_reg == DSP_REG_NONE,
+	             xregs[R13].guest_reg == DSP_REG_NONE,
-		     "wrong xreg state for %d", R13);
+	             "wrong xreg state for %d", R13);
 	_assert_msg_(DSPLLE,
-		     xregs[R14].guest_reg == DSP_REG_NONE,
+	             xregs[R14].guest_reg == DSP_REG_NONE,
-		     "wrong xreg state for %d", R14);
+	             "wrong xreg state for %d", R14);
 	_assert_msg_(DSPLLE,
-		     xregs[R15].guest_reg == DSP_REG_NONE,
+	             xregs[R15].guest_reg == DSP_REG_NONE,
-		     "wrong xreg state for %d", R15);
+	             "wrong xreg state for %d", R15);
 #endif
 
 	use_ctr = 0;
@@ -401,7 +421,9 @@ void DSPJitRegCache::loadRegs(bool emit)
 	for(unsigned int i = 0; i <= DSP_REG_MAX_MEM_BACKED; i++)
 	{
 		if (regs[i].host_reg != INVALID_REG)
+		{
 			movToHostReg(i,regs[i].host_reg, emit);
+		}
 	}
 
 	if (emit)
@@ -421,14 +443,16 @@ void DSPJitRegCache::saveRegs()
 	for(unsigned int i = 0; i <= DSP_REG_MAX_MEM_BACKED; i++)
 	{
 		if (regs[i].host_reg != INVALID_REG)
+		{
 			movToMemory(i);
+		}
 	}
 
 	for(unsigned int i = 0; i <= DSP_REG_MAX_MEM_BACKED; i++)
 	{
 		_assert_msg_(DSPLLE,
-			     !regs[i].loc.IsSimpleReg(),
+		             !regs[i].loc.IsSimpleReg(),
-			     "register %x is still a simple reg", i);
+		             "register %x is still a simple reg", i);
 	}
 
 #ifdef _M_X64
@@ -445,7 +469,9 @@ void DSPJitRegCache::pushRegs()
 	for(unsigned int i = 0; i <= DSP_REG_MAX_MEM_BACKED; i++)
 	{
 		if (regs[i].host_reg != INVALID_REG)
+		{
 			movToMemory(i);
+		}
 	}
 
 	int push_count = 0;
@@ -458,10 +484,14 @@ void DSPJitRegCache::pushRegs()
 	//hardcoding alignment to 16 bytes
 #ifdef _M_X64
 	if (push_count & 1)
+	{
 		emitter.SUB(64,R(RSP),Imm32(8));
+	}
 #else
 	if (push_count & 3)
+	{
 		emitter.SUB(32,R(ESP),Imm32(16 - 4 * (push_count & 3)));
+	}
 #endif
 
 	for(unsigned int i = 0; i < NUMXREGS; i++)
@@ -477,16 +507,16 @@ void DSPJitRegCache::pushRegs()
 	for(unsigned int i = 0; i <= DSP_REG_MAX_MEM_BACKED; i++)
 	{
 		_assert_msg_(DSPLLE,
-			     !regs[i].loc.IsSimpleReg(),
+		             !regs[i].loc.IsSimpleReg(),
-			     "register %x is still a simple reg", i);
+		             "register %x is still a simple reg", i);
 	}
 
 	for(unsigned int i = 0; i < NUMXREGS; i++)
 	{
 		_assert_msg_(DSPLLE,
-			     xregs[i].guest_reg == DSP_REG_NONE ||
+		             xregs[i].guest_reg == DSP_REG_NONE ||
-			     xregs[i].guest_reg == DSP_REG_STATIC,
+		             xregs[i].guest_reg == DSP_REG_STATIC,
-			     "register %x is still used", i);
+		             "register %x is still used", i);
 	}
 
 #ifdef _M_X64
@@ -506,7 +536,9 @@ void DSPJitRegCache::popRegs() {
 	for(auto& xreg : xregs)
 	{
 		if (xreg.pushed)
+		{
 			push_count++;
+		}
 	}
 
 	for(int i = NUMXREGS-1; i >= 0; i--)
@@ -522,16 +554,22 @@ void DSPJitRegCache::popRegs() {
 	//hardcoding alignment to 16 bytes
 #ifdef _M_X64
 	if (push_count & 1)
+	{
 		emitter.ADD(64,R(RSP),Imm32(8));
+	}
 #else
 	if (push_count & 3)
+	{
 		emitter.ADD(32,R(ESP),Imm32(16 - 4 * (push_count & 3)));
+	}
 #endif
 
 	for(unsigned int i = 0; i <= DSP_REG_MAX_MEM_BACKED; i++)
 	{
 		if (regs[i].host_reg != INVALID_REG)
+		{
 			movToHostReg(i,regs[i].host_reg, true);
+		}
 	}
 }
 
@@ -547,7 +585,9 @@ X64Reg DSPJitRegCache::makeABICallSafe(X64Reg reg)
 	X64Reg safe = findSpillFreeXReg();
 	_assert_msg_(DSPLLE, safe != INVALID_REG, "could not find register");
 	if (safe == INVALID_REG)
+	{
 		emitter.INT3();
+	}
 	xregs[RBP].guest_reg = rbp_guest;
 #ifdef _M_X64
 	emitter.MOV(64,R(safe),R(reg));
@@ -560,29 +600,36 @@ X64Reg DSPJitRegCache::makeABICallSafe(X64Reg reg)
 void DSPJitRegCache::movToHostReg(int reg, X64Reg host_reg, bool load)
 {
 	_assert_msg_(DSPLLE, reg >= 0 && reg <= DSP_REG_MAX_MEM_BACKED,
-		     "bad register name %x", reg);
+	             "bad register name %x", reg);
 	_assert_msg_(DSPLLE, regs[reg].parentReg == DSP_REG_NONE,
-		     "register %x is proxy for %x", reg, regs[reg].parentReg);
+	             "register %x is proxy for %x", reg, regs[reg].parentReg);
 	_assert_msg_(DSPLLE, !regs[reg].used,
-		     "moving to host reg in use guest reg %x!", reg);
+	             "moving to host reg in use guest reg %x!", reg);
 	X64Reg old_reg = regs[reg].loc.GetSimpleReg();
 	if (old_reg == host_reg)
+	{
 		return;
+	}
 
 	if (xregs[host_reg].guest_reg != DSP_REG_STATIC)
+	{
 		xregs[host_reg].guest_reg = reg;
+	}
 
 	if (load)
 	{
 		switch(regs[reg].size)
 		{
 		case 2:
-			emitter.MOV(16, R(host_reg), regs[reg].loc); break;
+			emitter.MOV(16, R(host_reg), regs[reg].loc);
+			break;
 		case 4:
-			emitter.MOV(32, R(host_reg), regs[reg].loc); break;
+			emitter.MOV(32, R(host_reg), regs[reg].loc);
+			break;
 #ifdef _M_X64
 		case 8:
-			emitter.MOV(64, R(host_reg), regs[reg].loc); break;
+			emitter.MOV(64, R(host_reg), regs[reg].loc);
+			break;
 #endif
 		default:
 			_assert_msg_(DSPLLE, 0, "unsupported memory size");
@@ -592,30 +639,40 @@ void DSPJitRegCache::movToHostReg(int reg, X64Reg host_reg, bool load)
 
 	regs[reg].loc = R(host_reg);
 	if (old_reg != INVALID_REG &&
-		xregs[old_reg].guest_reg != DSP_REG_STATIC)
+	    xregs[old_reg].guest_reg != DSP_REG_STATIC)
+	{
 		xregs[old_reg].guest_reg = DSP_REG_NONE;
+	}
 }
 
 void DSPJitRegCache::movToHostReg(int reg, bool load)
 {
 	_assert_msg_(DSPLLE, reg >= 0 && reg <= DSP_REG_MAX_MEM_BACKED,
-		     "bad register name %x", reg);
+	             "bad register name %x", reg);
 	_assert_msg_(DSPLLE, regs[reg].parentReg == DSP_REG_NONE,
-		     "register %x is proxy for %x", reg, regs[reg].parentReg);
+	             "register %x is proxy for %x", reg, regs[reg].parentReg);
 	_assert_msg_(DSPLLE, !regs[reg].used,
-		     "moving to host reg in use guest reg %x!", reg);
+	             "moving to host reg in use guest reg %x!", reg);
 
 	if (regs[reg].loc.IsSimpleReg())
+	{
 		return;
+	}
 
 	X64Reg tmp;
 	if (regs[reg].host_reg != INVALID_REG)
+	{
 		tmp = regs[reg].host_reg;
+	}
 	else
+	{
 		tmp = findSpillFreeXReg();
+	}
 
 	if (tmp == INVALID_REG)
+	{
 		return;
+	}
 
 	movToHostReg(reg, tmp, load);
 }
@@ -623,30 +680,27 @@ void DSPJitRegCache::movToHostReg(int reg, bool load)
 void DSPJitRegCache::rotateHostReg(int reg, int shift, bool emit)
 {
 	_assert_msg_(DSPLLE, reg >= 0 && reg <= DSP_REG_MAX_MEM_BACKED,
-		     "bad register name %x", reg);
+	             "bad register name %x", reg);
 	_assert_msg_(DSPLLE, regs[reg].parentReg == DSP_REG_NONE,
-		     "register %x is proxy for %x", reg, regs[reg].parentReg);
+	             "register %x is proxy for %x", reg, regs[reg].parentReg);
 	_assert_msg_(DSPLLE, regs[reg].loc.IsSimpleReg(),
-		     "register %x is not a simple reg", reg);
+	             "register %x is not a simple reg", reg);
 	_assert_msg_(DSPLLE, !regs[reg].used,
-		     "rotating in use guest reg %x!", reg);
+	             "rotating in use guest reg %x!", reg);
 
 	if (shift > regs[reg].shift && emit)
 	{
 		switch(regs[reg].size)
 		{
 		case 2:
-			emitter.ROR(16, regs[reg].loc,
+			emitter.ROR(16, regs[reg].loc, Imm8(shift - regs[reg].shift));
-					Imm8(shift - regs[reg].shift));
 			break;
 		case 4:
-			emitter.ROR(32, regs[reg].loc,
+			emitter.ROR(32, regs[reg].loc, Imm8(shift - regs[reg].shift));
-					Imm8(shift - regs[reg].shift));
 			break;
 #ifdef _M_X64
 		case 8:
-			emitter.ROR(64, regs[reg].loc,
+			emitter.ROR(64, regs[reg].loc, Imm8(shift - regs[reg].shift));
-					Imm8(shift - regs[reg].shift));
 			break;
 #endif
 		}
@@ -656,17 +710,14 @@ void DSPJitRegCache::rotateHostReg(int reg, int shift, bool emit)
 		switch(regs[reg].size)
 		{
 		case 2:
-			emitter.ROL(16, regs[reg].loc,
+			emitter.ROL(16, regs[reg].loc, Imm8(regs[reg].shift - shift));
-					Imm8(regs[reg].shift - shift));
 			break;
 		case 4:
-			emitter.ROL(32, regs[reg].loc,
+			emitter.ROL(32, regs[reg].loc, Imm8(regs[reg].shift - shift));
-					Imm8(regs[reg].shift - shift));
 			break;
 #ifdef _M_X64
 		case 8:
-			emitter.ROL(64, regs[reg].loc,
+			emitter.ROL(64, regs[reg].loc, Imm8(regs[reg].shift - shift));
-					Imm8(regs[reg].shift - shift));
 			break;
 #endif
 		}
@@ -684,11 +735,15 @@ void DSPJitRegCache::movToMemory(int reg)
 		     "moving to memory in use guest reg %x!", reg);
 
 	if (regs[reg].used)
+	{
 		emitter.INT3();
+	}
 
 	if (!regs[reg].loc.IsSimpleReg() &&
 	    !regs[reg].loc.IsImm())
+	{
 		return;
+	}
 
 	//but first, check for any needed rotations
 	if (regs[reg].loc.IsSimpleReg())
@@ -710,12 +765,15 @@ void DSPJitRegCache::movToMemory(int reg)
 		switch(regs[reg].size)
 		{
 		case 2:
-			emitter.MOV(16, tmp, regs[reg].loc); break;
+			emitter.MOV(16, tmp, regs[reg].loc);
+			break;
 		case 4:
-			emitter.MOV(32, tmp, regs[reg].loc); break;
+			emitter.MOV(32, tmp, regs[reg].loc);
+			break;
 #ifdef _M_X64
 		case 8:
-			emitter.MOV(64, tmp, regs[reg].loc); break;
+			emitter.MOV(64, tmp, regs[reg].loc);
+			break;
 #endif
 		default:
 			_assert_msg_(DSPLLE, 0, "unsupported memory size");
@@ -728,7 +786,9 @@ void DSPJitRegCache::movToMemory(int reg)
 	{
 		X64Reg hostreg = regs[reg].loc.GetSimpleReg();
 		if (xregs[hostreg].guest_reg != DSP_REG_STATIC)
+		{
 			xregs[hostreg].guest_reg = DSP_REG_NONE;
+		}
 	}
 
 	regs[reg].last_use_ctr = -1;
@@ -756,17 +816,19 @@ void DSPJitRegCache::getReg(int reg, OpArg &oparg, bool load)
 	}
 
 	_assert_msg_(DSPLLE, !regs[real_reg].used,
-		     "register %x already in use", real_reg);
+	             "register %x already in use", real_reg);
 
 	if (regs[real_reg].used)
+	{
 		emitter.INT3();
+	}
 	// no nead to actually emit code for load or rotate if caller doesn't
 	// use the contents, but see above for a reason to force the load
 	movToHostReg(real_reg, load);
 
 	// TODO: actually handle INVALID_REG
 	_assert_msg_(DSPLLE, regs[real_reg].loc.IsSimpleReg(),
-		     "did not get host reg for %x", reg);
+	             "did not get host reg for %x", reg);
 
 	rotateHostReg(real_reg, shift, load);
 	oparg = regs[real_reg].loc;
@@ -778,16 +840,14 @@ void DSPJitRegCache::getReg(int reg, OpArg &oparg, bool load)
 #ifdef _M_X64
 	case DSP_REG_ACC0_64:
 	case DSP_REG_ACC1_64:
-	{
 		if (load)
 		{
-			//need to do this because interpreter only does 48 bits
+			// need to do this because interpreter only does 48 bits
-			//(and putReg does the same)
+			// (and putReg does the same)
-			emitter.SHL(64, oparg, Imm8(64-40));//sign extend
+			emitter.SHL(64, oparg, Imm8(64-40)); // sign extend
 			emitter.SAR(64, oparg, Imm8(64-40));
 		}
-	}
+		break;
-	break;
 #endif
 	default:
 		break;
@@ -806,24 +866,23 @@ void DSPJitRegCache::putReg(int reg, bool dirty)
 	{
 	case DSP_REG_ACH0:
 	case DSP_REG_ACH1:
-	{
 		if (dirty)
 		{
-			//no need to extend to full 64bit here until interpreter
+			// no need to extend to full 64bit here until interpreter
-			//uses that
+			// uses that
 			if (oparg.IsSimpleReg())
 			{
-				//register is already shifted correctly
+				// register is already shifted correctly
-				//(if at all)
+				// (if at all)
 
 				// sign extend from the bottom 8 bits.
 #ifndef _M_X64
-				//cannot use movsx with SPL, BPL, SIL or DIL
+				// cannot use movsx with SPL, BPL, SIL or DIL
-				//on 32 bit
+				// on 32 bit
 				if (oparg.GetSimpleReg() == RSP ||
-					oparg.GetSimpleReg() == RBP ||
+				    oparg.GetSimpleReg() == RBP ||
-					oparg.GetSimpleReg() == RSI ||
+				    oparg.GetSimpleReg() == RSI ||
-					oparg.GetSimpleReg() == RDI)
+				    oparg.GetSimpleReg() == RDI)
 				{
 					emitter.SHL(16,oparg,Imm8(8));
 					emitter.SAR(16,oparg,Imm8(8));
@@ -831,9 +890,7 @@ void DSPJitRegCache::putReg(int reg, bool dirty)
 				else
 #endif
 				{
-					emitter.MOVSX(16, 8,
+					emitter.MOVSX(16, 8, oparg.GetSimpleReg(), oparg);
-								oparg.GetSimpleReg(),
-								oparg);
 				}
 			}
 			else if (oparg.IsImm())
@@ -842,8 +899,8 @@ void DSPJitRegCache::putReg(int reg, bool dirty)
 			}
 			else
 			{
-				//this works on the memory, so use reg instead
+				// this works on the memory, so use reg instead
-				//of real_reg, since it has the right loc
+				// of real_reg, since it has the right loc
 				X64Reg tmp;
 				getFreeXReg(tmp);
 				// sign extend from the bottom 8 bits.
@@ -852,19 +909,16 @@ void DSPJitRegCache::putReg(int reg, bool dirty)
 				putXReg(tmp);
 			}
 		}
-	}
+		break;
-	break;
 #ifdef _M_X64
 	case DSP_REG_ACC0_64:
 	case DSP_REG_ACC1_64:
-	{
 		if (dirty)
 		{
-			emitter.SHL(64, oparg, Imm8(64-40));//sign extend
+			emitter.SHL(64, oparg, Imm8(64-40)); // sign extend
 			emitter.SAR(64, oparg, Imm8(64-40));
 		}
-	}
+		break;
-	break;
 #endif
 	default:
 		break;
@@ -891,30 +945,46 @@ void DSPJitRegCache::readReg(int sreg, X64Reg host_dreg, DSPJitSignExtend extend
 		switch(extend)
 		{
 #ifdef _M_X64
-		case SIGN: emitter.MOVSX(64, 16, host_dreg, reg); break;
+		case SIGN:
-		case ZERO: emitter.MOVZX(64, 16, host_dreg, reg); break;
+			emitter.MOVSX(64, 16, host_dreg, reg);
+			break;
+		case ZERO:
+			emitter.MOVZX(64, 16, host_dreg, reg);
+			break;
 #else
-		case SIGN: emitter.MOVSX(32, 16, host_dreg, reg); break;
+		case SIGN:
-		case ZERO: emitter.MOVZX(32, 16, host_dreg, reg); break;
+			emitter.MOVSX(32, 16, host_dreg, reg);
+			break;
+		case ZERO:
+			emitter.MOVZX(32, 16, host_dreg, reg);
+			break;
 #endif
-		case NONE: emitter.MOV(16, R(host_dreg), reg); break;
+		case NONE:
+			emitter.MOV(16, R(host_dreg), reg);
+			break;
 		}
 		break;
 	case 4:
 #ifdef _M_X64
 		switch(extend)
 		{
-		case SIGN: emitter.MOVSX(64, 32, host_dreg, reg); break;
+		case SIGN:
-		case ZERO: emitter.MOVZX(64, 32, host_dreg, reg); break;
+			emitter.MOVSX(64, 32, host_dreg, reg);
-		case NONE: emitter.MOV(32, R(host_dreg), reg); break;
+			break;
+		case ZERO:
+			emitter.MOVZX(64, 32, host_dreg, reg);
+			break;
+		case NONE:
+			emitter.MOV(32, R(host_dreg), reg);
+			break;
 		}
 #else
-		emitter.MOV(32, R(host_dreg), reg); break;
+		emitter.MOV(32, R(host_dreg), reg);
 #endif
 		break;
 #ifdef _M_X64
 	case 8:
-		emitter.MOV(64, R(host_dreg), reg); break;
+		emitter.MOV(64, R(host_dreg), reg);
 		break;
 #endif
 	default:
@@ -932,14 +1002,22 @@ void DSPJitRegCache::writeReg(int dreg, OpArg arg)
 	{
 		switch(regs[dreg].size)
 		{
-		case 2: emitter.MOV(16, reg, Imm16((u16) arg.offset)); break;
+		case 2:
-		case 4: emitter.MOV(32, reg, Imm32((u32) arg.offset)); break;
+			emitter.MOV(16, reg, Imm16((u16) arg.offset));
+			break;
+		case 4:
+			emitter.MOV(32, reg, Imm32((u32) arg.offset));
+			break;
 #ifdef _M_X64
 		case 8:
 			if ((u32) arg.offset == arg.offset)
+			{
 				emitter.MOV(64, reg, Imm32((u32) arg.offset));
+			}
 			else
+			{
 				emitter.MOV(64, reg, Imm64(arg.offset));
+			}
 			break;
 #endif
 		default:
@@ -951,10 +1029,16 @@ void DSPJitRegCache::writeReg(int dreg, OpArg arg)
 	{
 		switch(regs[dreg].size)
 		{
-		case 2: emitter.MOV(16, reg, arg); break;
+		case 2:
-		case 4: emitter.MOV(32, reg, arg); break;
+			emitter.MOV(16, reg, arg);
+			break;
+		case 4:
+			emitter.MOV(32, reg, arg);
+			break;
 #ifdef _M_X64
-		case 8: emitter.MOV(64, reg, arg); break;
+		case 8:
+			emitter.MOV(64, reg, arg);
+			break;
 #endif
 		default:
 			_assert_msg_(DSPLLE, 0, "unsupported memory size");
@@ -976,18 +1060,15 @@ static X64Reg alloc_order[] = {
 
 X64Reg DSPJitRegCache::spillXReg()
 {
-	unsigned int i;
+	int max_use_ctr_diff = 0;
-	unsigned int max_use_ctr_diff = 0;
 	X64Reg least_recent_use_reg = INVALID_REG;
-	for(i = 0; i < sizeof(alloc_order)/sizeof(alloc_order[0]); i++)
+	for(size_t i = 0; i < sizeof(alloc_order)/sizeof(alloc_order[0]); i++)
 	{
 		X64Reg reg = alloc_order[i];
 		if (xregs[reg].guest_reg <= DSP_REG_MAX_MEM_BACKED &&
-			!regs[xregs[reg].guest_reg].used)
+		    !regs[xregs[reg].guest_reg].used)
 		{
-			unsigned int use_ctr_diff = use_ctr -
+			int use_ctr_diff = use_ctr - regs[xregs[reg].guest_reg].last_use_ctr;
-				regs[xregs[reg].guest_reg].last_use_ctr;
-
 			if (use_ctr_diff >= max_use_ctr_diff)
 			{
 				max_use_ctr_diff = use_ctr_diff;
@@ -1003,11 +1084,11 @@ X64Reg DSPJitRegCache::spillXReg()
 	}
 
 	//just choose one.
-	for(i = 0; i < sizeof(alloc_order)/sizeof(alloc_order[0]); i++)
+	for(size_t i = 0; i < sizeof(alloc_order)/sizeof(alloc_order[0]); i++)
 	{
 		X64Reg reg = alloc_order[i];
 		if (xregs[reg].guest_reg <= DSP_REG_MAX_MEM_BACKED &&
-			!regs[xregs[reg].guest_reg].used)
+		    !regs[xregs[reg].guest_reg].used)
 		{
 			movToMemory(xregs[reg].guest_reg);
 			return reg;
@@ -1022,16 +1103,16 @@ void DSPJitRegCache::spillXReg(X64Reg reg)
 	if (xregs[reg].guest_reg <= DSP_REG_MAX_MEM_BACKED)
 	{
 		_assert_msg_(DSPLLE, !regs[xregs[reg].guest_reg].used,
-			     "to be spilled host reg %x(guest reg %x) still in use!",
+		             "to be spilled host reg %x(guest reg %x) still in use!",
-			     reg, xregs[reg].guest_reg);
+		             reg, xregs[reg].guest_reg);
 
 		movToMemory(xregs[reg].guest_reg);
 	}
 	else
 	{
 		_assert_msg_(DSPLLE, xregs[reg].guest_reg == DSP_REG_NONE,
-			     "to be spilled host reg %x still in use!",
+		             "to be spilled host reg %x still in use!",
-			     reg);
+		             reg);
 	}
 }
 
@@ -1051,7 +1132,9 @@ X64Reg DSPJitRegCache::findSpillFreeXReg()
 {
 	X64Reg reg = findFreeXReg();
 	if (reg == INVALID_REG)
+	{
 		reg = spillXReg();
+	}
 	return reg;
 }
 
@@ -1061,7 +1144,9 @@ void DSPJitRegCache::getFreeXReg(X64Reg &reg)
 
 	_assert_msg_(DSPLLE, reg != INVALID_REG, "could not find register");
 	if (reg == INVALID_REG)
+	{
 		emitter.INT3();
+	}
 	xregs[reg].guest_reg = DSP_REG_USED;
 }
 
@@ -1074,7 +1159,9 @@ void DSPJitRegCache::getXReg(X64Reg reg)
 	}
 
 	if (xregs[reg].guest_reg != DSP_REG_NONE)
+	{
 		spillXReg(reg);
+	}
 	_assert_msg_(DSPLLE, xregs[reg].guest_reg == DSP_REG_NONE, "register already in use");
 	xregs[reg].guest_reg = DSP_REG_USED;
 }
@@ -1088,7 +1175,7 @@ void DSPJitRegCache::putXReg(X64Reg reg)
 	}
 
 	_assert_msg_(DSPLLE, xregs[reg].guest_reg == DSP_REG_USED,
-		     "putXReg without get(Free)XReg");
+	             "putXReg without get(Free)XReg");
 
 	xregs[reg].guest_reg = DSP_REG_NONE;
 }

Source/Core/Core/FifoPlayer/FifoPlaybackAnalyzer.cpp

@@ -59,8 +59,10 @@ void FifoPlaybackAnalyzer::AnalyzeFrames(FifoDataFile *file, std::vector<Analyze
 		u32 cmdStart = 0;
 		u32 nextMemUpdate = 0;
 
+#if LOG_FIFO_CMDS
 		// Debugging
 		vector<CmdData> prevCmds;
+#endif
 
 		while (cmdStart < frame.fifoDataSize)
 		{
@@ -75,7 +77,7 @@ void FifoPlaybackAnalyzer::AnalyzeFrames(FifoDataFile *file, std::vector<Analyze
 
 			u32 cmdSize = DecodeCommand(&frame.fifoData[cmdStart]);
 
-#if (LOG_FIFO_CMDS)
+#if LOG_FIFO_CMDS
 			CmdData cmdData;
 			cmdData.offset = cmdStart;
 			cmdData.ptr = &frame.fifoData[cmdStart];
@@ -118,7 +120,7 @@ void FifoPlaybackAnalyzer::AddMemoryUpdate(MemoryUpdate memUpdate, AnalyzedFrame
 	for (const auto& range : m_WrittenMemory)
 	{
 		if (range.begin < end &&
-			range.end > begin)
+		    range.end > begin)
 		{
 			s32 preSize = range.begin - begin;
 			s32 postSize = end - range.end;
@@ -210,7 +212,9 @@ u32 FifoPlaybackAnalyzer::DecodeCommand(u8 *data)
 			FifoAnalyzer::LoadBPReg(bp, m_BpMem);
 
 			if (bp.address == BPMEM_TRIGGER_EFB_COPY)
+			{
 				StoreEfbCopyRegion();
+			}
 		}
 		break;
 
@@ -256,9 +260,13 @@ void FifoPlaybackAnalyzer::StoreEfbCopyRegion()
 	{
 		format |= _GX_TF_ZTF;
 		if (copyfmt == 11)
+		{
 			format = GX_TF_Z16;
+		}
 		else if (format < GX_TF_Z8 || format > GX_TF_Z24X8)
+		{
 			format |= _GX_TF_CTF;
+		}
 	}
 	else
 	{

Source/Core/Core/HW/DSP.cpp

@@ -280,8 +280,10 @@ void Init(bool hle)
 void Shutdown()
 {
 	if (!g_ARAM.wii_mode)
+	{
 		FreeMemoryPages(g_ARAM.ptr, g_ARAM.size);
-	g_ARAM.ptr = NULL;
+		g_ARAM.ptr = NULL;
+	}
 
 	dsp_emulator->Shutdown();
 	delete dsp_emulator;
@@ -563,7 +565,7 @@ void Do_ARAM_DMA()
 		{
 			while (g_arDMA.Cnt.count)
 			{
-				// These are logically seperated in code to show that a memory map has been set up
+				// These are logically separated in code to show that a memory map has been set up
 				// See below in the write section for more information
 				if ((g_ARAM_Info.Hex & 0xf) == 3)
 				{

Source/Core/Core/HW/DSPHLE/UCodes/UCode_Zelda_Voice.cpp

@@ -657,7 +657,6 @@ ContinueWithBlock:
 				switch (count) {
 				case 0: _LeftBuffer[i] += (u64)unmixed_audio * ramp >> 29; break;
 				case 1: _RightBuffer[i] += (u64)unmixed_audio * ramp >> 29; break;
-					break;
 				}
 			}
 		}

Source/Core/Core/HW/EXI_DeviceIPL.cpp

@@ -129,11 +129,8 @@ CEXIIPL::~CEXIIPL()
 		m_szBuffer[m_count] = 0x00;
 	}
 
-	if (m_pIPL != NULL)
+	FreeMemoryPages(m_pIPL, ROM_SIZE);
-	{
+	m_pIPL = NULL;
-		FreeMemoryPages(m_pIPL, ROM_SIZE);
-		m_pIPL = NULL;
-	}
 
 	// SRAM
 	File::IOFile file(SConfig::GetInstance().m_LocalCoreStartupParameter.m_strSRAM, "wb");

Source/Core/Core/HW/GCMemcard.cpp

@@ -813,7 +813,6 @@ u32 GCMemcard::ImportGciInternal(FILE* gcih, const char *inputFile, const std::s
 {
 	File::IOFile gci(gcih);
 	unsigned int offset;
-	char tmp[0xD];
 	std::string fileType;
 	SplitPath(inputFile, NULL, NULL, &fileType);
 
@@ -821,7 +820,8 @@ u32 GCMemcard::ImportGciInternal(FILE* gcih, const char *inputFile, const std::s
 		offset = GCI;
 	else
 	{
-		gci.ReadBytes(tmp, 0xD);
+		char tmp[0xD];
+		gci.ReadBytes(tmp, sizeof(tmp));
 		if (!strcasecmp(fileType.c_str(), ".gcs"))
 		{
 			if (!memcmp(tmp, "GCSAVE", 6)) // Header must be uppercase

Source/Core/Core/HW/WiimoteEmu/Attachment/Attachment.cpp

@@ -2,6 +2,7 @@
 // Licensed under GPLv2
 // Refer to the license.txt file included.
 
+#include "Common/Common.h"
 #include "Core/HW/WiimoteEmu/Attachment/Attachment.h"
 
 namespace WiimoteEmu
@@ -11,16 +12,16 @@ namespace WiimoteEmu
 // The id for nothing inserted
 static const u8 nothing_id[] = { 0x00, 0x00, 0x00, 0x00, 0x2e, 0x2e };
 // The id for a partially inserted extension (currently unused)
-//static const u8 partially_id[] = { 0x00, 0x00, 0x00, 0x00, 0xff, 0xff };
+UNUSED static const u8 partially_id[] = { 0x00, 0x00, 0x00, 0x00, 0xff, 0xff };
 
-Attachment::Attachment( const char* const _name, WiimoteEmu::ExtensionReg& _reg )
+Attachment::Attachment(const char* const _name, WiimoteEmu::ExtensionReg& _reg)
-	: name( _name ), reg( _reg )
+	: name(_name), reg(_reg)
 {
 	memset(id, 0, sizeof(id));
 	memset(calibration, 0, sizeof(calibration));
 }
 
-None::None( WiimoteEmu::ExtensionReg& _reg ) : Attachment( "None", _reg )
+None::None(WiimoteEmu::ExtensionReg& _reg) : Attachment("None", _reg)
 {
 	// set up register
 	memcpy(&id, nothing_id, sizeof(nothing_id));
@@ -34,14 +35,14 @@ std::string Attachment::GetName() const
 void Attachment::Reset()
 {
 	// set up register
-	memset( &reg, 0, WIIMOTE_REG_EXT_SIZE );
+	memset(&reg, 0, WIIMOTE_REG_EXT_SIZE);
-	memcpy( &reg.constant_id, id, sizeof(id) );
+	memcpy(&reg.constant_id, id, sizeof(id));
-	memcpy( &reg.calibration, calibration, sizeof(calibration) );
+	memcpy(&reg.calibration, calibration, sizeof(calibration));
 }
 
 }
 
-void ControllerEmu::Extension::GetState( u8* const data, const bool focus )
+void ControllerEmu::Extension::GetState(u8* const data, const bool focus)
 {
-	((WiimoteEmu::Attachment*)attachments[active_extension].get())->GetState( data, focus );
+	((WiimoteEmu::Attachment*)attachments[active_extension].get())->GetState(data, focus);
 }

Source/Core/Core/HW/WiimoteEmu/Speaker.cpp

@@ -85,7 +85,6 @@ void Wiimote::SpeakerData(wm_speaker_data* sd)
 	}
 
 #ifdef WIIMOTE_SPEAKER_DUMP
-	std::stringstream name;
 	static int num = 0;
 
 	if (num == 0)

Source/Core/Core/HW/WiimoteEmu/WiimoteEmu.cpp

@@ -23,8 +23,9 @@
 #include "Core/HW/WiimoteEmu/Attachment/Turntable.h"
 #include "Core/HW/WiimoteReal/WiimoteReal.h"
 
-
+#ifdef _WIN32
 inline double round(double x) { return (x-floor(x))>0.5 ? ceil(x) : floor(x); } //because damn MSVSC doesen't comply to C99
+#endif
 
 namespace
 {
@@ -649,13 +650,10 @@ void Wiimote::Update()
 	u8 data[MAX_PAYLOAD];
 	memset(data, 0, sizeof(data));
 
-	// figure out what data we need
-	s8 rptf_size = MAX_PAYLOAD;
-
 	Movie::SetPolledDevice();
 
 	const ReportFeatures& rptf = reporting_mode_features[m_reporting_mode - WM_REPORT_CORE];
-	rptf_size = rptf.size;
+	s8 rptf_size = rptf.size;
 	if (Movie::IsPlayingInput() && Movie::PlayWiimote(m_index, data, rptf, m_reg_ir.mode))
 	{
 		if (rptf.core)

Source/Core/Core/HW/WiimoteReal/IOWin.cpp

@@ -96,7 +96,7 @@ inline void init_lib()
 		HidD_SetOutputReport = (PHidD_SetOutputReport)GetProcAddress(hid_lib, "HidD_SetOutputReport");
 		HidD_GetProductString = (PHidD_GetProductString)GetProcAddress(hid_lib, "HidD_GetProductString");
 		if (!HidD_GetHidGuid || !HidD_GetAttributes ||
-			!HidD_SetOutputReport || !HidD_GetProductString)
+		    !HidD_SetOutputReport || !HidD_GetProductString)
 		{
 			PanicAlertT("Failed to load hid.dll! Connecting real Wiimotes won't work and Dolphin might crash unexpectedly!");
 			return;
@@ -122,11 +122,11 @@ inline void init_lib()
 		Bth_BluetoothEnumerateInstalledServices = (PBth_BluetoothEnumerateInstalledServices)GetProcAddress(bthprops_lib, "BluetoothEnumerateInstalledServices");
 
 		if (!Bth_BluetoothFindDeviceClose || !Bth_BluetoothFindFirstDevice ||
-			!Bth_BluetoothFindFirstRadio || !Bth_BluetoothFindNextDevice ||
+		    !Bth_BluetoothFindFirstRadio || !Bth_BluetoothFindNextDevice ||
-			!Bth_BluetoothFindNextRadio || !Bth_BluetoothFindRadioClose ||
+		    !Bth_BluetoothFindNextRadio || !Bth_BluetoothFindRadioClose ||
-			!Bth_BluetoothGetRadioInfo || !Bth_BluetoothRemoveDevice ||
+		    !Bth_BluetoothGetRadioInfo || !Bth_BluetoothRemoveDevice ||
-			!Bth_BluetoothSetServiceState || !Bth_BluetoothAuthenticateDevice ||
+		    !Bth_BluetoothSetServiceState || !Bth_BluetoothAuthenticateDevice ||
-			!Bth_BluetoothEnumerateInstalledServices)
+		    !Bth_BluetoothEnumerateInstalledServices)
 		{
 			PanicAlertT("Failed to load bthprops.cpl! Connecting real Wiimotes won't work and Dolphin might crash unexpectedly!");
 			return;
@@ -316,10 +316,10 @@ void WiimoteScanner::CheckDeviceType(std::basic_string<TCHAR> &devicepath, bool
 #endif
 
 	HANDLE dev_handle = CreateFile(devicepath.c_str(),
-								GENERIC_READ | GENERIC_WRITE,
+	                               GENERIC_READ | GENERIC_WRITE,
-								FILE_SHARE_READ | FILE_SHARE_WRITE,
+	                               FILE_SHARE_READ | FILE_SHARE_WRITE,
-								NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED,
+	                               NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED,
-								NULL);
+	                               NULL);
 	if (dev_handle == INVALID_HANDLE_VALUE)
 		return;
 	// enable to only check for official nintendo wiimotes/bb's
@@ -331,7 +331,6 @@ void WiimoteScanner::CheckDeviceType(std::basic_string<TCHAR> &devicepath, bool
 		(attrib.VendorID == 0x057e) &&
 		(attrib.ProductID == 0x0306)))
 	{
-		int rc = 0;
 		// max_cycles insures we are never stuck here due to bad coding...
 		int max_cycles = 20;
 		u8 buf[MAX_PAYLOAD] = {0};
@@ -343,19 +342,19 @@ void WiimoteScanner::CheckDeviceType(std::basic_string<TCHAR> &devicepath, bool
 		u8 const disable_enc_pt1_report[MAX_PAYLOAD] = {WM_SET_REPORT | WM_BT_OUTPUT, WM_WRITE_DATA, 0x04, 0xa4, 0x00, 0xf0, 0x01, 0x55};
 		u8 const disable_enc_pt2_report[MAX_PAYLOAD] = {WM_SET_REPORT | WM_BT_OUTPUT, WM_WRITE_DATA, 0x04, 0xa4, 0x00, 0xfb, 0x01, 0x00};
 
-		rc = CheckDeviceType_Write(dev_handle,
+		CheckDeviceType_Write(dev_handle,
-									disable_enc_pt1_report,
+		                      disable_enc_pt1_report,
-									sizeof(disable_enc_pt1_report),
+		                      sizeof(disable_enc_pt1_report),
-									1);
+		                      1);
-		rc = CheckDeviceType_Write(dev_handle,
+		CheckDeviceType_Write(dev_handle,
-									disable_enc_pt2_report,
+		                      disable_enc_pt2_report,
-									sizeof(disable_enc_pt2_report),
+		                      sizeof(disable_enc_pt2_report),
-									1);
+		                      1);
 
-		rc = CheckDeviceType_Write(dev_handle,
+		int rc = CheckDeviceType_Write(dev_handle,
-									req_status_report,
+		                               req_status_report,
-									sizeof(req_status_report),
+		                               sizeof(req_status_report),
-									1);
+		                               1);
 
 		while (rc > 0 && --max_cycles > 0)
 		{
@@ -411,15 +410,15 @@ void WiimoteScanner::CheckDeviceType(std::basic_string<TCHAR> &devicepath, bool
 						// 0x020420A40000ULL means balance board.
 						u64 ext_type = (*(u64*)&wrdr->data[0]);
 						// DEBUG_LOG(WIIMOTE,
-						//		  "CheckDeviceType: GOT EXT TYPE %llX",
+						//           "CheckDeviceType: GOT EXT TYPE %llX",
-						//		  ext_type);
+						//           ext_type);
 						is_bb = (ext_type == 0x020420A40000ULL);
 					}
 					else
 					{
 						ERROR_LOG(WIIMOTE,
-								  "CheckDeviceType: GOT UNREQUESTED ADDRESS %X",
+						          "CheckDeviceType: GOT UNREQUESTED ADDRESS %X",
-								  Common::swap16(wrdr->address));
+						          Common::swap16(wrdr->address));
 					}
 					// force end
 					rc = -1;
@@ -681,7 +680,6 @@ int _IOWrite(HANDLE &dev_handle, OVERLAPPED &hid_overlap_write, enum win_bt_stac
 			}
 
 			return result;
-			break;
 		}
 		case MSBT_STACK_BLUESOLEIL:
 		{
@@ -764,7 +762,7 @@ void ProcessWiimotes(bool new_scan, T& callback)
 			{
 				// btdi.szName is sometimes missing it's content - it's a bt feature..
 				DEBUG_LOG(WIIMOTE, "Authenticated %i connected %i remembered %i ",
-						btdi.fAuthenticated, btdi.fConnected, btdi.fRemembered);
+				          btdi.fAuthenticated, btdi.fConnected, btdi.fRemembered);
 
 				if (IsValidBluetoothName(UTF16ToUTF8(btdi.szName)))
 				{
@@ -807,16 +805,18 @@ bool AttachWiimote(HANDLE hRadio, const BLUETOOTH_RADIO_INFO& radio_info, BLUETO
 		auto const& wm_addr = btdi.Address.rgBytes;
 
 		NOTICE_LOG(WIIMOTE, "Found Wiimote (%02x:%02x:%02x:%02x:%02x:%02x). Enabling HID service.",
-			wm_addr[0], wm_addr[1], wm_addr[2], wm_addr[3], wm_addr[4], wm_addr[5]);
+		           wm_addr[0], wm_addr[1], wm_addr[2], wm_addr[3], wm_addr[4], wm_addr[5]);
 
 #if defined(AUTHENTICATE_WIIMOTES)
 		// Authenticate
 		auto const& radio_addr = radio_info.address.rgBytes;
 		const DWORD auth_result = Bth_BluetoothAuthenticateDevice(NULL, hRadio, &btdi,
-			std::vector<WCHAR>(radio_addr, radio_addr + 6).data(), 6);
+		                                                          std::vector<WCHAR>(radio_addr, radio_addr + 6).data(), 6);
 
 		if (ERROR_SUCCESS != auth_result)
+		{
 			ERROR_LOG(WIIMOTE, "AttachWiimote: BluetoothAuthenticateDevice returned %08x", auth_result);
+		}
 
 		DWORD pcServices = 16;
 		GUID guids[16];
@@ -824,18 +824,24 @@ bool AttachWiimote(HANDLE hRadio, const BLUETOOTH_RADIO_INFO& radio_info, BLUETO
 		const DWORD srv_result = Bth_BluetoothEnumerateInstalledServices(hRadio, &btdi, &pcServices, guids);
 
 		if (ERROR_SUCCESS != srv_result)
+		{
 			ERROR_LOG(WIIMOTE, "AttachWiimote: BluetoothEnumerateInstalledServices returned %08x", srv_result);
+		}
 #endif
 		// Activate service
 		const DWORD hr = Bth_BluetoothSetServiceState(hRadio, &btdi,
-			&HumanInterfaceDeviceServiceClass_UUID, BLUETOOTH_SERVICE_ENABLE);
+		                                              &HumanInterfaceDeviceServiceClass_UUID, BLUETOOTH_SERVICE_ENABLE);
 
 		g_connect_times[btdi.Address.ullLong] = std::time(nullptr);
 
 		if (FAILED(hr))
+		{
 			ERROR_LOG(WIIMOTE, "AttachWiimote: BluetoothSetServiceState returned %08x", hr);
+		}
 		else
+		{
 			return true;
+		}
 	}
 
 	return false;
@@ -851,8 +857,8 @@ bool ForgetWiimote(BLUETOOTH_DEVICE_INFO_STRUCT& btdi)
 		auto const avoid_forget_seconds = 5.0;
 
 		auto pair_time = g_connect_times.find(btdi.Address.ullLong);
-		if (pair_time == g_connect_times.end()
+		if (pair_time == g_connect_times.end() ||
-			|| std::difftime(time(nullptr), pair_time->second) >= avoid_forget_seconds)
+		    std::difftime(time(nullptr), pair_time->second) >= avoid_forget_seconds)
 		{
 			// Make Windows forget about device so it will re-find it if visible.
 			// This is also required to detect a disconnect for some reason..

Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_DI.cpp

@@ -468,14 +468,12 @@ int CWII_IPC_HLE_Device_di::GetCmdDelay(u32 _CommandAddress)
 		// More than ~1150K "bytes / sec" hangs NSMBWii on boot.
 		// Less than ~800K "bytes / sec" hangs DKCR randomly (ok, probably not true)
 		return SystemTimers::GetTicksPerSecond() / 975000 * Size;
-		break;
 	}
 
 	case DVDLowClearCoverInterrupt:
 		// Less than ~1/155th of a second hangs Oregon Trail at "loading wheel".
 		// More than ~1/140th of a second hangs Resident Evil Archives: Resident Evil Zero.
 		return SystemTimers::GetTicksPerSecond() / 146;
-		break;
 
 	// case DVDLowAudioBufferConfig:
 	// case DVDLowInquiry:
@@ -489,6 +487,5 @@ int CWII_IPC_HLE_Device_di::GetCmdDelay(u32 _CommandAddress)
 		// random numbers here!
 		// More than ~1/2000th of a second hangs DKCR with DSP HLE, maybe.
 		return SystemTimers::GetTicksPerSecond() / 15000;
-		break;
 	}
 }

Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_hid.cpp

@@ -146,7 +146,6 @@ bool CWII_IPC_HLE_Device_hid::IOCtl(u32 _CommandAddress)
 			BufferIn, BufferInSize, BufferOut, BufferOutSize);
 		deviceCommandAddress = _CommandAddress;
 		return false;
-		break;
 	}
 	case IOCTL_HID_OPEN:
 	{
@@ -210,7 +209,6 @@ bool CWII_IPC_HLE_Device_hid::IOCtl(u32 _CommandAddress)
 
 		// It's the async way!
 		return false;
-		break;
 	}
 	case IOCTL_HID_INTERRUPT_OUT:
 	case IOCTL_HID_INTERRUPT_IN:
@@ -242,7 +240,6 @@ bool CWII_IPC_HLE_Device_hid::IOCtl(u32 _CommandAddress)
 
 		// It's the async way!
 		return false;
-		break;
 	}
 	case IOCTL_HID_SHUTDOWN:
 	{

Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_net.cpp

@@ -689,7 +689,6 @@ bool CWII_IPC_HLE_Device_net_ip_top::IOCtl(u32 _CommandAddress)
 		WiiSockMan &sm = WiiSockMan::getInstance();
 		sm.doSock(fd, _CommandAddress, (NET_IOCTL)Command);
 		return false;
-		break;
 	}
 	/////////////////////////////////////////////////////////////
 	//                  TODO: Tidy all below                   //

Source/Core/Core/NetPlayServer.cpp

@@ -610,10 +610,8 @@ void NetPlayServer::unmapPortThread()
 // discovers the IGD
 bool NetPlayServer::initUPnP()
 {
-	UPNPDev *devlist;
 	std::vector<UPNPDev *> igds;
 	int descXMLsize = 0, upnperror = 0;
-	char *descXML;
 
 	// Don't init if already inited
 	if (m_upnp_inited)
@@ -627,7 +625,7 @@ bool NetPlayServer::initUPnP()
 	memset(&m_upnp_data, 0, sizeof(IGDdatas));
 
 	// Find all UPnP devices
-	devlist = upnpDiscover(2000, NULL, NULL, 0, 0, &upnperror);
+	UPNPDev *devlist = upnpDiscover(2000, NULL, NULL, 0, 0, &upnperror);
 	if (!devlist)
 	{
 		WARN_LOG(NETPLAY, "An error occured trying to discover UPnP devices.");
@@ -647,7 +645,7 @@ bool NetPlayServer::initUPnP()
 
 	for (const UPNPDev* dev : igds)
 	{
-		descXML = (char *) miniwget(dev->descURL, &descXMLsize, 0);
+		char* descXML = (char*) miniwget(dev->descURL, &descXMLsize, 0);
 		if (descXML)
 		{
 			parserootdesc(descXML, descXMLsize, &m_upnp_data);

Source/Core/Core/PowerPC/Jit64/Jit.cpp

@@ -366,7 +366,7 @@ void Jit64::Trace()
 	{
 		char reg[50];
 		sprintf(reg, "r%02d: %08x ", i, PowerPC::ppcState.gpr[i]);
-		strncat(regs, reg, 500);
+		strncat(regs, reg, sizeof(regs) - 1);
 	}
 #endif
 
@@ -375,7 +375,7 @@ void Jit64::Trace()
 	{
 		char reg[50];
 		sprintf(reg, "f%02d: %016x ", i, riPS0(i));
-		strncat(fregs, reg, 750);
+		strncat(fregs, reg, sizeof(fregs) - 1);
 	}
 #endif
 

Source/Core/Core/PowerPC/Jit64/Jit_Integer.cpp

@@ -2111,7 +2111,7 @@ void Jit64::srawix(UGeckoInstruction inst)
 	}
 	else
 	{
-		Default(inst); return;
+		Default(inst); return; // FIXME
 		gpr.Lock(a, s);
 		JitClearCA();
 		gpr.BindToRegister(a, a == s, true);

Source/Core/Core/PowerPC/Jit64IL/JitIL.cpp

@@ -463,7 +463,7 @@ void JitIL::Trace()
 	{
 		char reg[50];
 		sprintf(reg, "r%02d: %08x ", i, PowerPC::ppcState.gpr[i]);
-		strncat(regs, reg, 500);
+		strncat(regs, reg, sizeof(regs) - 1);
 	}
 #endif
 
@@ -472,7 +472,7 @@ void JitIL::Trace()
 	{
 		char reg[50];
 		sprintf(reg, "f%02d: %016x ", i, riPS0(i));
-		strncat(fregs, reg, 750);
+		strncat(fregs, reg, sizeof(fregs) - 1);
 	}
 #endif
 

Source/Core/Core/PowerPC/JitArm32/Jit.cpp

@@ -228,7 +228,7 @@ void JitArm::Trace()
 	{
 		char reg[50];
 		sprintf(reg, "r%02d: %08x ", i, PowerPC::ppcState.gpr[i]);
-		strncat(regs, reg, 500);
+		strncat(regs, reg, sizeof(regs) - 1);
 	}
 #endif
 
@@ -237,7 +237,7 @@ void JitArm::Trace()
 	{
 		char reg[50];
 		sprintf(reg, "f%02d: %016x ", i, riPS0(i));
-		strncat(fregs, reg, 750);
+		strncat(fregs, reg, sizeof(fregs) - 1);
 	}
 #endif
 

Source/Core/Core/PowerPC/JitArm32/JitArm_Integer.cpp

@@ -109,7 +109,7 @@ void JitArm::subfic(UGeckoInstruction inst)
 {
 	INSTRUCTION_START
 	JITDISABLE(bJITIntegerOff)
-	Default(inst); return;
+	Default(inst); return; // FIXME
 	int a = inst.RA, d = inst.RD;
 
 	int imm = inst.SIMM_16;
@@ -615,7 +615,7 @@ void JitArm::addex(UGeckoInstruction inst)
 	INSTRUCTION_START
 	JITDISABLE(bJITIntegerOff)
 	u32 a = inst.RA, b = inst.RB, d = inst.RD;
-	Default(inst); return;
+	Default(inst); return; // FIXME
 	ARMReg RA = gpr.R(a);
 	ARMReg RB = gpr.R(b);
 	ARMReg RD = gpr.R(d);

Source/Core/Core/PowerPC/JitArmIL/JitIL_Branch.cpp

@@ -10,7 +10,7 @@
 #include "Core/PowerPC/PPCTables.h"
 #include "Core/PowerPC/JitArmIL/JitIL.h"
 
-
+// FIXME
 #define NORMALBRANCH_START Default(inst); ibuild.EmitInterpreterBranch(); return;
 //#define NORMALBRANCH_START
 

Source/Core/Core/PowerPC/JitILCommon/IR.cpp

@@ -1296,7 +1296,7 @@ void IRBuilder::WriteToFile(u64 codeHash) {
 			alwaysUseds.find(opcode) != alwaysUseds.end();
 
 		// Line number
-		fprintf(file, "%4d", i);
+		fprintf(file, "%4u", i);
 
 		if (!thisUsed) {
 			fprintf(file, "%*c", 32, ' ');

Source/Core/Core/PowerPC/JitInterface.cpp

@@ -77,7 +77,6 @@ namespace JitInterface
 				PanicAlert("Unrecognizable cpu_core: %d", core);
 				jit = NULL;
 				return NULL;
-				break;
 			}
 		}
 		jit = static_cast<JitBase*>(ptr);

Source/Core/Core/PowerPC/PPCSymbolDB.cpp

@@ -211,7 +211,7 @@ bool PPCSymbolDB::LoadMap(const char *filename)
 			continue;
 
 		char temp[256];
-		sscanf(line, "%s", temp);
+		sscanf(line, "%255s", temp);
 
 		if (strcmp(temp, "UNUSED")==0) continue;
 		if (strcmp(temp, ".text")==0)  {started = true; continue;};
@@ -234,7 +234,7 @@ bool PPCSymbolDB::LoadMap(const char *filename)
 
 		u32 address, vaddress, size, unknown;
 		char name[512];
-		sscanf(line, "%08x %08x %08x %i %s", &address, &size, &vaddress, &unknown, name);
+		sscanf(line, "%08x %08x %08x %i %511s", &address, &size, &vaddress, &unknown, name);
 
 		const char *namepos = strstr(line, name);
 		if (namepos != 0) //would be odd if not :P

Source/Core/Core/State.cpp

@@ -184,9 +184,10 @@ std::map<double, int> GetSavedStates()
 	std::map<double, int> m;
 	for (int i = 1; i <= (int)NUM_STATES; i++)
 	{
-		if (File::Exists(MakeStateFilename(i)))
+		std::string filename = MakeStateFilename(i);
+		if (File::Exists(filename))
 		{
-			if (ReadHeader(MakeStateFilename(i), header))
+			if (ReadHeader(filename, header))
 			{
 				double d = Common::Timer::GetDoubleTime() - header.time;
 				// increase time until unique value is obtained
@@ -340,7 +341,7 @@ void SaveAs(const std::string& filename, bool wait)
 	Core::PauseAndLock(false, wasUnpaused);
 }
 
-bool ReadHeader(const std::string filename, StateHeader& header)
+bool ReadHeader(const std::string& filename, StateHeader& header)
 {
 	Flush();
 	File::IOFile f(filename, "rb");

Source/Core/Core/State.h

@@ -29,7 +29,7 @@ void Shutdown();
 
 void EnableCompression(bool compression);
 
-bool ReadHeader(const std::string filename, StateHeader& header);
+bool ReadHeader(const std::string& filename, StateHeader& header);
 
 // These don't happen instantly - they get scheduled as events.
 // ...But only if we're not in the main cpu thread.

Source/Core/Core/x64MemTools.cpp

@@ -89,9 +89,7 @@ LONG NTAPI Handler(PEXCEPTION_POINTERS pPtrs)
 				return (DWORD)EXCEPTION_CONTINUE_SEARCH;
 			}
 
-			//Where in the x86 code are we?
+			// virtual address of the inaccessible data
-			PVOID codeAddr = pPtrs->ExceptionRecord->ExceptionAddress;
-			unsigned char *codePtr = (unsigned char*)codeAddr;
 			u64 badAddress = (u64)pPtrs->ExceptionRecord->ExceptionInformation[1];
 			CONTEXT *ctx = pPtrs->ContextRecord;
 
@@ -104,7 +102,6 @@ LONG NTAPI Handler(PEXCEPTION_POINTERS pPtrs)
 				// Let's not prevent debugging.
 				return (DWORD)EXCEPTION_CONTINUE_SEARCH;
 			}
-
 		}
 
 	case EXCEPTION_STACK_OVERFLOW:

Source/Core/DiscIO/NANDContentLoader.cpp

@@ -374,9 +374,9 @@ void CNANDContentLoader::RemoveTitle() const
 		// remove tmd?
 		for (u32 i = 0; i < m_numEntries; i++)
 		{
-			char szFilename[1024];
 			if (!(m_Content[i].m_Type & 0x8000)) // skip shared apps
 			{
+				char szFilename[1024];
 				sprintf(szFilename, "%s%08x.app", Common::GetTitleContentPath(m_TitleID).c_str(), m_Content[i].m_ContentID);
 				INFO_LOG(DISCIO, "Delete %s", szFilename);
 				File::Delete(szFilename);

Source/Core/DolphinWX/Android/ButtonManager.cpp

@@ -114,8 +114,7 @@ namespace ButtonManager
 	}
 	bool GetButtonPressed(int padID, ButtonType button)
 	{
-		bool pressed = false;
+		bool pressed = m_buttons[std::make_pair(padID, button)]->Pressed();
-		pressed = m_buttons[std::make_pair(padID, button)]->Pressed();
 
 		for (const auto& ctrl : m_controllers)
 			pressed |= ctrl.second->ButtonValue(padID, button);

Source/Core/DolphinWX/Debugger/MemoryView.cpp

@@ -228,10 +228,6 @@ void CMemoryView::OnPaint(wxPaintEvent& event)
 	dc.GetTextExtent(_T("W"),&w,&h);
 	int fontSize = w;
 	int textPlacement = 17 + 9 * fontSize;
-	struct branch
-	{
-		int src, dst, srcAddr;
-	};
 
 	// TODO: Add any drawing code here...
 	int width   = rc.width;

Source/Core/DolphinWX/ISOProperties.cpp

@@ -916,7 +916,6 @@ void CISOProperties::OnExtractDir(wxCommandEvent& event)
 
 void CISOProperties::OnExtractDataFromHeader(wxCommandEvent& event)
 {
-	std::vector<const DiscIO::SFileInfo *> fst;
 	DiscIO::IFileSystem *FS = NULL;
 	wxString Path = wxDirSelector(_("Choose the folder to extract to"));
 

Source/Core/DolphinWX/MemcardManager.cpp

@@ -64,8 +64,8 @@ wxBitmap wxBitmapFromMemoryRGBA(const unsigned char* data, u32 width, u32 height
 
 	u8 *pdata = new u8[bytes];
 
-	memset(pdata,0,bytes);
 	memcpy(pdata,hdr,sizeof(hdr));
+	memset(pdata+sizeof(hdr),0,bytes-sizeof(hdr));
 
 	u8 *pixelData = pdata + sizeof(hdr);
 

Source/Core/DolphinWX/MemoryCards/WiiSaveCrypted.cpp

@@ -368,7 +368,7 @@ void CWiiSaveCrypted::ExportWiiSaveFiles()
 	for(u32 i = 0; i < _numberOfFiles; i++)
 	{
 		FileHDR tmpFileHDR;
-		std::string __name, __ext;
+		std::string __name;
 		memset(&tmpFileHDR, 0, FILE_HDR_SZ);
 
 		u32 _fileSize =  0;

Source/Core/DolphinWX/NetWindow.cpp

@@ -657,11 +657,6 @@ PadMapDiag::PadMapDiag(wxWindow* const parent, PadMapping map[], PadMapping wiim
 	for (auto& player : m_player_list)
 		player_names.Add(player->name);
 
-	wxString wiimote_names[5];
-	wiimote_names[0] = _("None");
-	for (unsigned int i=1; i < 5; ++i)
-		wiimote_names[i] = wxString(_("Wiimote ")) + (wxChar)(wxT('0')+i);
-
 	for (unsigned int i=0; i<4; ++i)
 	{
 		wxBoxSizer* const v_szr = new wxBoxSizer(wxVERTICAL);

Source/Core/InputCommon/ControllerInterface/DInput/DInputKeyboardMouse.cpp

@@ -138,7 +138,6 @@ KeyboardMouse::KeyboardMouse(const LPDIRECTINPUTDEVICE8 kb_device, const LPDIREC
 
 void GetMousePos(float* const x, float* const y)
 {
-	unsigned int win_width = 2, win_height = 2;
 	POINT point = { 1, 1 };
 	GetCursorPos(&point);
 	// Get the cursor position relative to the upper left corner of the rendering window
@@ -148,8 +147,8 @@ void GetMousePos(float* const x, float* const y)
 	RECT rect;
 	GetClientRect(hwnd, &rect);
 	// Width and height is the size of the rendering window
-	win_width = rect.right - rect.left;
+	unsigned int win_width = rect.right - rect.left;
-	win_height = rect.bottom - rect.top;
+	unsigned int win_height = rect.bottom - rect.top;
 
 	// Return the mouse position as a range from -1 to 1
 	*x = (float)point.x / (float)win_width * 2 - 1;

Source/Core/VideoBackends/D3D/main.cpp

@@ -154,8 +154,6 @@ bool VideoBackend::Initialize(void *&window_handle)
 
 	frameCount = 0;
 
-	const SCoreStartupParameter& core_params = SConfig::GetInstance().m_LocalCoreStartupParameter;
-
 	g_Config.Load((File::GetUserPath(D_CONFIG_IDX) + "gfx_dx11.ini").c_str());
 	g_Config.GameIniLoad();
 	g_Config.UpdateProjectionHack();

Source/Core/VideoBackends/OGL/StreamBuffer.cpp

@@ -272,6 +272,7 @@ public:
 		glBindBuffer(m_buffertype, 0);
 		glFinish(); // ogl pipeline must be flushed, else this buffer can be in use
 		FreeAlignedMemory(m_pointer);
+		m_pointer = NULL;
 	}
 
 	std::pair<u8*, size_t> Map(size_t size, u32 stride) {

Source/Core/VideoBackends/OGL/TextureCache.cpp

@@ -55,7 +55,7 @@ static u32 s_DepthCbufid;
 static u32 s_Textures[8];
 static u32 s_ActiveTexture;
 
-bool SaveTexture(const std::string filename, u32 textarget, u32 tex, int virtual_width, int virtual_height, unsigned int level)
+bool SaveTexture(const std::string& filename, u32 textarget, u32 tex, int virtual_width, int virtual_height, unsigned int level)
 {
 	if (GLInterface->GetMode() != GLInterfaceMode::MODE_OPENGL)
 		return false;
@@ -121,7 +121,7 @@ void TextureCache::TCacheEntry::Bind(unsigned int stage)
 	}
 }
 
-bool TextureCache::TCacheEntry::Save(const std::string filename, unsigned int level)
+bool TextureCache::TCacheEntry::Save(const std::string& filename, unsigned int level)
 {
 	return SaveTexture(filename, GL_TEXTURE_2D, texture, virtual_width, virtual_height, level);
 }

Source/Core/VideoBackends/OGL/TextureCache.h

@@ -48,7 +48,7 @@ private:
 			const float *colmat) override;
 
 		void Bind(unsigned int stage) override;
-		bool Save(const std::string filename, unsigned int level);
+		bool Save(const std::string& filename, unsigned int level);
 	};
 
 	~TextureCache();
@@ -59,6 +59,6 @@ private:
 	TCacheEntryBase* CreateRenderTargetTexture(unsigned int scaled_tex_w, unsigned int scaled_tex_h) override;
 };
 
-bool SaveTexture(const std::string filename, u32 textarget, u32 tex, int virtual_width, int virtual_height, unsigned int level);
+bool SaveTexture(const std::string& filename, u32 textarget, u32 tex, int virtual_width, int virtual_height, unsigned int level);
 
 }

Source/Core/VideoBackends/Software/DebugUtil.cpp

@@ -44,7 +44,7 @@ void Init()
 	}
 }
 
-void SaveTexture(const std::string filename, u32 texmap, s32 mip)
+void SaveTexture(const std::string& filename, u32 texmap, s32 mip)
 {
 	FourTexUnits& texUnit = bpmem.tex[(texmap >> 2) & 1];
 	u8 subTexmap = texmap & 3;
@@ -123,7 +123,7 @@ void DumpActiveTextures()
 	}
 }
 
-void DumpEfb(const std::string filename)
+void DumpEfb(const std::string& filename)
 {
 	u8 *data = new u8[EFB_WIDTH * EFB_HEIGHT * 4];
 	u8 *writePtr = data;
@@ -146,7 +146,7 @@ void DumpEfb(const std::string filename)
 	delete[] data;
 }
 
-void DumpDepth(const std::string filename)
+void DumpDepth(const std::string& filename)
 {
 	u8 *data = new u8[EFB_WIDTH * EFB_HEIGHT * 4];
 	u8 *writePtr = data;

Source/Core/VideoCommon/FPSCounter.cpp

@@ -32,7 +32,7 @@ static void LogFPSToFile(unsigned long val)
 		s_bench_file.Open(File::GetUserPath(D_LOGS_IDX) + "fps.txt", "w");
 
 	char buffer[256];
-	snprintf(buffer, 256, "%ld\n", val);
+	snprintf(buffer, 256, "%lu\n", val);
 	s_bench_file.WriteArray(buffer, strlen(buffer));
 }
 

Source/Core/VideoCommon/Fifo.cpp

@@ -70,6 +70,7 @@ void Fifo_Shutdown()
 {
 	if (GpuRunningState) PanicAlert("Fifo shutting down while active");
 	FreeMemoryPages(videoBuffer, FIFO_SIZE);
+	videoBuffer = NULL;
 }
 
 u8* GetVideoBufferStartPtr()

Source/Core/VideoCommon/ImageWrite.cpp

@@ -26,7 +26,7 @@ Inputs:
 data      : This is an array of RGBA with 8 bits per channel. 4 bytes for each pixel.
 row_stride: Determines the amount of bytes per row of pixels.
 */
-bool TextureToPng(u8* data, int row_stride, const std::string filename, int width, int height, bool saveAlpha)
+bool TextureToPng(u8* data, int row_stride, const std::string& filename, int width, int height, bool saveAlpha)
 {
 	bool success = false;
 

Source/Core/VideoCommon/ImageWrite.h

@@ -7,4 +7,4 @@
 #include "Common/Common.h"
 
 bool SaveData(const char* filename, const char* pdata);
-bool TextureToPng(u8* data, int row_stride, const std::string filename, int width, int height, bool saveAlpha = true);
+bool TextureToPng(u8* data, int row_stride, const std::string& filename, int width, int height, bool saveAlpha = true);

Source/Core/VideoCommon/TextureCacheBase.cpp

@@ -73,11 +73,8 @@ void TextureCache::Invalidate()
 TextureCache::~TextureCache()
 {
 	Invalidate();
-	if (temp)
+	FreeAlignedMemory(temp);
-	{
+	temp = NULL;
-		FreeAlignedMemory(temp);
-		temp = NULL;
-	}
 }
 
 void TextureCache::OnConfigChanged(VideoConfig& config)
@@ -238,11 +235,11 @@ bool TextureCache::CheckForCustomTextureLODs(u64 tex_hash, int texformat, unsign
 
 	for (unsigned int level = 1; level < levels; ++level)
 	{
-		sprintf(texPathTemp, "%s_mip%i", texBasePathTemp, level);
+		sprintf(texPathTemp, "%s_mip%u", texBasePathTemp, level);
 		if (!HiresTextures::HiresTexExists(texPathTemp))
 		{
 			if (level > 1)
-				WARN_LOG(VIDEO, "Couldn't find custom texture LOD with index %i (filename: %s), disabling custom LODs for this texture", level, texPathTemp);
+				WARN_LOG(VIDEO, "Couldn't find custom texture LOD with index %u (filename: %s), disabling custom LODs for this texture", level, texPathTemp);
 
 			return false;
 		}
@@ -260,7 +257,7 @@ PC_TexFormat TextureCache::LoadCustomTexture(u64 tex_hash, int texformat, unsign
 	if (level == 0)
 		sprintf(texPathTemp, "%s_%08x_%i", SConfig::GetInstance().m_LocalCoreStartupParameter.m_strUniqueID.c_str(), tex_hash_u32, texformat);
 	else
-		sprintf(texPathTemp, "%s_%08x_%i_mip%i", SConfig::GetInstance().m_LocalCoreStartupParameter.m_strUniqueID.c_str(), tex_hash_u32, texformat, level);
+		sprintf(texPathTemp, "%s_%08x_%i_mip%u", SConfig::GetInstance().m_LocalCoreStartupParameter.m_strUniqueID.c_str(), tex_hash_u32, texformat, level);
 
 	unsigned int required_size = 0;
 	PC_TexFormat ret = HiresTextures::GetHiresTex(texPathTemp, &newWidth, &newHeight, &required_size, texformat, temp_size, temp);

Source/Core/VideoCommon/TextureCacheBase.h

@@ -72,7 +72,7 @@ public:
 		virtual ~TCacheEntryBase();
 
 		virtual void Bind(unsigned int stage) = 0;
-		virtual bool Save(const std::string filename, unsigned int level) = 0;
+		virtual bool Save(const std::string& filename, unsigned int level) = 0;
 
 		virtual void Load(unsigned int width, unsigned int height,
 			unsigned int expanded_width, unsigned int level) = 0;

Source/Core/VideoCommon/TextureConversionShader.cpp

@@ -141,13 +141,13 @@ void WriteToBitDepth(char*& p, u8 depth, const char* src, const char* dest)
 	WRITE(p, "  %s = floor(%s * 255.0 / exp2(8.0 - %d.0));\n", dest, src, depth);
 }
 
-void WriteEncoderEnd(char* p, API_TYPE ApiType)
+void WriteEncoderEnd(char*& p, API_TYPE ApiType)
 {
 	WRITE(p, "}\n");
 	IntensityConstantAdded = false;
 }
 
-void WriteI8Encoder(char* p, API_TYPE ApiType)
+void WriteI8Encoder(char*& p, API_TYPE ApiType)
 {
 	WriteSwizzler(p, GX_TF_I8, ApiType);
 	WRITE(p, "  float3 texSample;\n");
@@ -169,7 +169,7 @@ void WriteI8Encoder(char* p, API_TYPE ApiType)
 	WriteEncoderEnd(p, ApiType);
 }
 
-void WriteI4Encoder(char* p, API_TYPE ApiType)
+void WriteI4Encoder(char*& p, API_TYPE ApiType)
 {
 	WriteSwizzler(p, GX_TF_I4, ApiType);
 	WRITE(p, "  float3 texSample;\n");
@@ -210,7 +210,7 @@ void WriteI4Encoder(char* p, API_TYPE ApiType)
 	WriteEncoderEnd(p, ApiType);
 }
 
-void WriteIA8Encoder(char* p,API_TYPE ApiType)
+void WriteIA8Encoder(char*& p,API_TYPE ApiType)
 {
 	WriteSwizzler(p, GX_TF_IA8, ApiType);
 	WRITE(p, "  float4 texSample;\n");
@@ -228,7 +228,7 @@ void WriteIA8Encoder(char* p,API_TYPE ApiType)
 	WriteEncoderEnd(p, ApiType);
 }
 
-void WriteIA4Encoder(char* p,API_TYPE ApiType)
+void WriteIA4Encoder(char*& p,API_TYPE ApiType)
 {
 	WriteSwizzler(p, GX_TF_IA4, ApiType);
 	WRITE(p, "  float4 texSample;\n");
@@ -260,7 +260,7 @@ void WriteIA4Encoder(char* p,API_TYPE ApiType)
 	WriteEncoderEnd(p, ApiType);
 }
 
-void WriteRGB565Encoder(char* p,API_TYPE ApiType)
+void WriteRGB565Encoder(char*& p,API_TYPE ApiType)
 {
 	WriteSwizzler(p, GX_TF_RGB565, ApiType);
 
@@ -283,7 +283,7 @@ void WriteRGB565Encoder(char* p,API_TYPE ApiType)
 	WriteEncoderEnd(p, ApiType);
 }
 
-void WriteRGB5A3Encoder(char* p,API_TYPE ApiType)
+void WriteRGB5A3Encoder(char*& p,API_TYPE ApiType)
 {
 	WriteSwizzler(p, GX_TF_RGB5A3, ApiType);
 
@@ -349,7 +349,7 @@ void WriteRGB5A3Encoder(char* p,API_TYPE ApiType)
 	WriteEncoderEnd(p, ApiType);
 }
 
-void WriteRGBA4443Encoder(char* p,API_TYPE ApiType)
+void WriteRGBA4443Encoder(char*& p,API_TYPE ApiType)
 {
 	WriteSwizzler(p, GX_TF_RGB5A3, ApiType);
 
@@ -373,7 +373,7 @@ void WriteRGBA4443Encoder(char* p,API_TYPE ApiType)
 	WriteEncoderEnd(p, ApiType);
 }
 
-void WriteRGBA8Encoder(char* p,API_TYPE ApiType)
+void WriteRGBA8Encoder(char*& p,API_TYPE ApiType)
 {
 	WriteSwizzler(p, GX_TF_RGBA8, ApiType);
 
@@ -398,7 +398,7 @@ void WriteRGBA8Encoder(char* p,API_TYPE ApiType)
 	WriteEncoderEnd(p, ApiType);
 }
 
-void WriteC4Encoder(char* p, const char* comp,API_TYPE ApiType)
+void WriteC4Encoder(char*& p, const char* comp,API_TYPE ApiType)
 {
 	WriteSwizzler(p, GX_CTF_R4, ApiType);
 	WRITE(p, "  float4 color0;\n");
@@ -420,7 +420,7 @@ void WriteC4Encoder(char* p, const char* comp,API_TYPE ApiType)
 	WriteEncoderEnd(p, ApiType);
 }
 
-void WriteC8Encoder(char* p, const char* comp,API_TYPE ApiType)
+void WriteC8Encoder(char*& p, const char* comp,API_TYPE ApiType)
 {
 	WriteSwizzler(p, GX_CTF_R8, ApiType);
 
@@ -432,7 +432,7 @@ void WriteC8Encoder(char* p, const char* comp,API_TYPE ApiType)
 	WriteEncoderEnd(p, ApiType);
 }
 
-void WriteCC4Encoder(char* p, const char* comp,API_TYPE ApiType)
+void WriteCC4Encoder(char*& p, const char* comp,API_TYPE ApiType)
 {
 	WriteSwizzler(p, GX_CTF_RA4, ApiType);
 	WRITE(p, "  float2 texSample;\n");
@@ -462,7 +462,7 @@ void WriteCC4Encoder(char* p, const char* comp,API_TYPE ApiType)
 	WriteEncoderEnd(p, ApiType);
 }
 
-void WriteCC8Encoder(char* p, const char* comp, API_TYPE ApiType)
+void WriteCC8Encoder(char*& p, const char* comp, API_TYPE ApiType)
 {
 	WriteSwizzler(p, GX_CTF_RA8, ApiType);
 
@@ -472,7 +472,7 @@ void WriteCC8Encoder(char* p, const char* comp, API_TYPE ApiType)
 	WriteEncoderEnd(p, ApiType);
 }
 
-void WriteZ8Encoder(char* p, const char* multiplier,API_TYPE ApiType)
+void WriteZ8Encoder(char*& p, const char* multiplier,API_TYPE ApiType)
 {
 	WriteSwizzler(p, GX_CTF_Z8M, ApiType);
 
@@ -493,7 +493,7 @@ void WriteZ8Encoder(char* p, const char* multiplier,API_TYPE ApiType)
 	WriteEncoderEnd(p, ApiType);
 }
 
-void WriteZ16Encoder(char* p,API_TYPE ApiType)
+void WriteZ16Encoder(char*& p,API_TYPE ApiType)
 {
 	WriteSwizzler(p, GX_TF_Z16, ApiType);
 
@@ -525,7 +525,7 @@ void WriteZ16Encoder(char* p,API_TYPE ApiType)
 	WriteEncoderEnd(p, ApiType);
 }
 
-void WriteZ16LEncoder(char* p,API_TYPE ApiType)
+void WriteZ16LEncoder(char*& p,API_TYPE ApiType)
 {
 	WriteSwizzler(p, GX_CTF_Z16L, ApiType);
 
@@ -561,7 +561,7 @@ void WriteZ16LEncoder(char* p,API_TYPE ApiType)
 	WriteEncoderEnd(p, ApiType);
 }
 
-void WriteZ24Encoder(char* p, API_TYPE ApiType)
+void WriteZ24Encoder(char*& p, API_TYPE ApiType)
 {
 	WriteSwizzler(p, GX_TF_Z24X8, ApiType);