111 lines
2.3 KiB
C++
111 lines
2.3 KiB
C++
// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#ifndef rr_ExecutableMemory_hpp
|
|
#define rr_ExecutableMemory_hpp
|
|
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <cstring>
|
|
|
|
namespace rr {
|
|
|
|
size_t memoryPageSize();
|
|
|
|
enum MemoryPermission
|
|
{
|
|
PERMISSION_READ = 1,
|
|
PERMISSION_WRITE = 2,
|
|
PERMISSION_EXECUTE = 4,
|
|
};
|
|
|
|
// Allocates memory with the specified permissions. If |need_exec| is true then
|
|
// the allocate memory can be made marked executable using protectMemoryPages().
|
|
void *allocateMemoryPages(size_t bytes, int permissions, bool need_exec);
|
|
|
|
// Sets permissions for memory allocated with allocateMemoryPages().
|
|
void protectMemoryPages(void *memory, size_t bytes, int permissions);
|
|
|
|
// Releases memory allocated with allocateMemoryPages().
|
|
void deallocateMemoryPages(void *memory, size_t bytes);
|
|
|
|
template<typename P>
|
|
P unaligned_read(P *address)
|
|
{
|
|
P value;
|
|
memcpy(&value, address, sizeof(P));
|
|
return value;
|
|
}
|
|
|
|
template<typename P, typename V>
|
|
void unaligned_write(P *address, V value)
|
|
{
|
|
static_assert(sizeof(V) == sizeof(P), "value size must match pointee size");
|
|
memcpy(address, &value, sizeof(P));
|
|
}
|
|
|
|
template<typename P>
|
|
class unaligned_ref
|
|
{
|
|
public:
|
|
explicit unaligned_ref(void *ptr)
|
|
: ptr((P *)ptr)
|
|
{}
|
|
|
|
template<typename V>
|
|
P operator=(V value)
|
|
{
|
|
unaligned_write(ptr, value);
|
|
return value;
|
|
}
|
|
|
|
operator P()
|
|
{
|
|
return unaligned_read((P *)ptr);
|
|
}
|
|
|
|
private:
|
|
P *ptr;
|
|
};
|
|
|
|
template<typename P>
|
|
class unaligned_ptr
|
|
{
|
|
template<typename S>
|
|
friend class unaligned_ptr;
|
|
|
|
public:
|
|
unaligned_ptr(P *ptr)
|
|
: ptr(ptr)
|
|
{}
|
|
|
|
unaligned_ref<P> operator*()
|
|
{
|
|
return unaligned_ref<P>(ptr);
|
|
}
|
|
|
|
template<typename S>
|
|
operator S()
|
|
{
|
|
return S(ptr);
|
|
}
|
|
|
|
private:
|
|
void *ptr;
|
|
};
|
|
|
|
} // namespace rr
|
|
|
|
#endif // rr_ExecutableMemory_hpp
|