Deprecate support for constant pointers.

src/Main/FrameBuffer.cpp

@@ -34,15 +34,7 @@ namespace sw
 {
 	extern bool forceWindowed;
 
-	void *FrameBuffer::cursor;
-	int FrameBuffer::cursorWidth = 0;
-	int FrameBuffer::cursorHeight = 0;
-	int FrameBuffer::cursorHotspotX;
-	int FrameBuffer::cursorHotspotY;
-	int FrameBuffer::cursorPositionX;
-	int FrameBuffer::cursorPositionY;
-	int FrameBuffer::cursorX;
-	int FrameBuffer::cursorY;
+	FrameBuffer::Cursor FrameBuffer::cursor = {0};
 	bool FrameBuffer::topLeftOrigin = false;
 
 	FrameBuffer::FrameBuffer(int width, int height, bool fullscreen, bool topLeftOrigin)
@@ -114,29 +106,29 @@ namespace sw
 	{
 		if(cursorImage)
 		{
-			cursor = cursorImage->lockExternal(0, 0, 0, sw::LOCK_READONLY, sw::PUBLIC);
+			cursor.image = cursorImage->lockExternal(0, 0, 0, sw::LOCK_READONLY, sw::PUBLIC);
 			cursorImage->unlockExternal();
 
-			cursorWidth = cursorImage->getWidth();
-			cursorHeight = cursorImage->getHeight();
+			cursor.width = cursorImage->getWidth();
+			cursor.height = cursorImage->getHeight();
 		}
 		else
 		{
-			cursorWidth = 0;
-			cursorHeight = 0;
+			cursor.width = 0;
+			cursor.height = 0;
 		}
 	}
 
 	void FrameBuffer::setCursorOrigin(int x0, int y0)
 	{
-		cursorHotspotX = x0;
-		cursorHotspotY = y0;
+		cursor.hotspotX = x0;
+		cursor.hotspotY = y0;
 	}
 
 	void FrameBuffer::setCursorPosition(int x, int y)
 	{
-		cursorPositionX = x;
-		cursorPositionY = y;
+		cursor.positionX = x;
+		cursor.positionY = y;
 	}
 
 	void FrameBuffer::copy(void *source, Format format, size_t stride)
@@ -162,8 +154,8 @@ namespace sw
 			target = (byte*)source + (height - 1) * stride;
 		}
 
-		cursorX = cursorPositionX - cursorHotspotX;
-		cursorY = cursorPositionY - cursorHotspotY;
+		cursor.x = cursor.positionX - cursor.hotspotX;
+		cursor.y = cursor.positionY - cursor.hotspotY;
 
 		if(ASYNCHRONOUS_BLIT)
 		{
@@ -188,8 +180,8 @@ namespace sw
 		update.destFormat = destFormat;
 		update.sourceFormat = sourceFormat;
 		update.stride = stride;
-		update.cursorWidth = cursorWidth;
-		update.cursorHeight = cursorHeight;
+		update.cursorWidth = cursor.width;
+		update.cursorHeight = cursor.height;
 
 		if(memcmp(&blitState, &update, sizeof(BlitState)) != 0)
 		{
@@ -197,10 +189,10 @@ namespace sw
 			delete blitRoutine;
 
 			blitRoutine = copyRoutine(blitState);
-			blitFunction = (void(*)(void*, void*))blitRoutine->getEntry();
+			blitFunction = (void(*)(void*, void*, Cursor*))blitRoutine->getEntry();
 		}
 
-		blitFunction(locked, target);
+		blitFunction(locked, target, &cursor);
 	}
 
 	Routine *FrameBuffer::copyRoutine(const BlitState &state)
@@ -213,10 +205,11 @@ namespace sw
 		const int sBytes = Surface::bytes(state.sourceFormat);
 		const int sStride = topLeftOrigin ? (sBytes * width2) : -(sBytes * width2);
 
-		Function<Void(Pointer<Byte>, Pointer<Byte>)> function;
+		Function<Void(Pointer<Byte>, Pointer<Byte>, Pointer<Byte>)> function;
 		{
 			Pointer<Byte> dst(function.Arg<0>());
 			Pointer<Byte> src(function.Arg<1>());
+			Pointer<Byte> cursor(function.Arg<2>());
 
 			For(Int y = 0, y < height, y++)
 			{
@@ -539,10 +532,10 @@ namespace sw
 				}
 			}
 
-			Int x0 = *Pointer<Int>(&cursorX);
-			Int y0 = *Pointer<Int>(&cursorY);
+			Int x0 = *Pointer<Int>(cursor + OFFSET(Cursor,x));
+			Int y0 = *Pointer<Int>(cursor + OFFSET(Cursor,y));
 
-			For(Int y1 = 0, y1 < cursorHeight, y1++)
+			For(Int y1 = 0, y1 < state.cursorHeight, y1++)
 			{
 				Int y = y0 + y1;
 
@@ -550,9 +543,9 @@ namespace sw
 				{
 					Pointer<Byte> d = dst + y * dStride + x0 * dBytes;
 					Pointer<Byte> s = src + y * sStride + x0 * sBytes;
-					Pointer<Byte> c = *Pointer<Pointer<Byte> >(&cursor) + y1 * cursorWidth * 4;
+					Pointer<Byte> c = *Pointer<Pointer<Byte>>(cursor + OFFSET(Cursor,image)) + y1 * state.cursorWidth * 4;
 
-					For(Int x1 = 0, x1 < cursorWidth, x1++)
+					For(Int x1 = 0, x1 < state.cursorWidth, x1++)
 					{
 						Int x = x0 + x1;
 

src/Main/FrameBuffer.hpp

@@ -75,22 +75,27 @@ namespace sw
 
 		void *target;   // Render target buffer
 
-		void (*blitFunction)(void *dst, void *src);
+		struct Cursor
+		{
+			void *image;
+			int x;
+			int y;
+			int width;
+			int height;
+			int hotspotX;
+			int hotspotY;
+			int positionX;
+			int positionY;
+		};
+
+		static Cursor cursor;
+
+		void (*blitFunction)(void *dst, void *src, Cursor *cursor);
 		Routine *blitRoutine;
 		BlitState blitState;
 
 		static void blend(const BlitState &state, const Pointer<Byte> &d, const Pointer<Byte> &s, const Pointer<Byte> &c);
 
-		static void *cursor;
-		static int cursorWidth;
-		static int cursorHeight;
-		static int cursorHotspotX;
-		static int cursorHotspotY;
-		static int cursorPositionX;
-		static int cursorPositionY;
-		static int cursorX;
-		static int cursorY;
-
 		Thread *blitThread;
 		Event syncEvent;
 		Event blitEvent;

src/Reactor/LLVMReactor.cpp

@@ -705,26 +705,7 @@ namespace sw
 			mask[3] ? 7 : 3,
 		};
 
-		Value *shuffle = Nucleus::createShuffleVector(lhs, rhs, swizzle);
-
-		return shuffle;
-	}
-
-	Value *Nucleus::createConstantPointer(const void *address, Type *Ty, unsigned int align)
-	{
-		const GlobalValue *existingGlobal = ::executionEngine->getGlobalValueAtAddress(const_cast<void*>(address));   // FIXME: Const
-
-		if(existingGlobal)
-		{
-			return (Value*)existingGlobal;
-		}
-
-		llvm::GlobalValue *global = new llvm::GlobalVariable(*::module, Ty, true, llvm::GlobalValue::ExternalLinkage, 0, "");
-		global->setAlignment(align);
-
-		::executionEngine->addGlobalMapping(global, const_cast<void*>(address));
-
-		return V(global);
+		return Nucleus::createShuffleVector(lhs, rhs, swizzle);
 	}
 
 	Type *Nucleus::getPointerType(Type *ElementType)

src/Reactor/Nucleus.hpp

@@ -163,7 +163,6 @@ namespace sw
 		static Value *createNullPointer(Type *type);
 		static Value *createConstantVector(const int64_t *constants, Type *type);
 		static Value *createConstantVector(const double *constants, Type *type);
-		static Value *createConstantPointer(const void *external, Type *type, unsigned int align = 0);
 
 		static Type *getPointerType(Type *elementType);
 

src/Reactor/Reactor.hpp

@@ -2094,7 +2094,6 @@ namespace sw
 		}
 
 		Pointer(Argument<Pointer<T>> argument);
-		explicit Pointer(const void *external);
 
 		Pointer();
 		Pointer(RValue<Pointer<T>> rhs);
@@ -2475,14 +2474,6 @@ namespace sw
 	}
 
 	template<class T>
-	Pointer<T>::Pointer(const void *external) : alignment((intptr_t)external & 0x0000000F ? 1 : 16)
-	{
-		Value *globalPointer = Nucleus::createConstantPointer(external, T::getType(), alignment);
-
-		LValue<Pointer<T>>::storeValue(globalPointer);
-	}
-
-	template<class T>
 	Pointer<T>::Pointer() : alignment(1)
 	{
 		LValue<Pointer<T>>::storeValue(Nucleus::createNullPointer(T::getType()));

src/Reactor/SubzeroReactor.cpp

@@ -1081,18 +1081,6 @@ namespace sw
 		return result;
 	}
 
-	Value *Nucleus::createConstantPointer(const void *address, Type *Ty, unsigned int align)
-	{
-		if(sizeof(void*) == 8)
-		{
-			return createAssign(::context->getConstantInt64(reinterpret_cast<intptr_t>(address)));
-		}
-		else
-		{
-			return createAssign(::context->getConstantInt32(reinterpret_cast<intptr_t>(address)));
-		}
-	}
-
 	Type *Nucleus::getPointerType(Type *ElementType)
 	{
 		if(sizeof(void*) == 8)
@@ -1165,15 +1153,8 @@ namespace sw
 
 	Value *Nucleus::createNullPointer(Type *Ty)
 	{
-		if(true)
-		{
 		return createNullValue(T(sizeof(void*) == 8 ? Ice::IceType_i64 : Ice::IceType_i32));
 	}
-		else
-		{
-			return createConstantPointer(nullptr, Ty);
-		}
-	}
 
 	Value *Nucleus::createConstantVector(const int64_t *constants, Type *type)
 	{