blob: dbbe32aa50f9b1e465fa95ccebe6151b898ea325 [file] [log] [blame] [edit]
// 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