Skip to content

S
swiftshader
Commit a29d653e by Nicolas Capens
Options

Deprecate support for constant pointers.

The use of constant pointers produces code that cannot be relocated. They also cause issues in Subzero when offsetting them due to not having constant folding support. We only used them for Direct3D cursor rendering, which can just pass in the data as an argument instead. Bug swiftshader:14 Change-Id: Id7f16c3fcaeed3fe64b569af6a49c32f6baec483 Reviewed-on: https://swiftshader-review.googlesource.com/8257Reviewed-by: 's avatarNicolas Capens <capn@google.com> Reviewed-by: 's avatarAlexis Hétu <sugoi@google.com> Tested-by: 's avatarNicolas Capens <capn@google.com>
parent 47eca450
Showing with 41 additions and 91 deletions
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,14 +1153,7 @@ 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);
}
return createNullValue(T(sizeof(void*) == 8 ? Ice::IceType_i64 : Ice::IceType_i32));
}
Value *Nucleus::createConstantVector(const int64_t *constants, Type *type)
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment