SectionMemoryManager.cpp Source File (original) (raw)

15#include "llvm/Config/config.h"

18namespace llvm {

21 unsigned Alignment,

22 unsigned SectionID,

24 bool IsReadOnly) {

25 if (IsReadOnly)

27 Size, Alignment);

29 Alignment);

30}

33 unsigned Alignment,

34 unsigned SectionID,

37 Alignment);

38}

40uint8_t *SectionMemoryManager::allocateSection(

42 unsigned Alignment) {

43 if (!Alignment)

44 Alignment = 16;

46 assert(!(Alignment & (Alignment - 1)) && "Alignment must be a power of two.");

48 uintptr_t RequiredSize = Alignment * ((Size + Alignment - 1) / Alignment + 1);

49 uintptr_t Addr = 0;

51 MemoryGroup &MemGroup = [&]() -> MemoryGroup & {

52 switch (Purpose) {

54 return CodeMem;

56 return RODataMem;

58 return RWDataMem;

59 }

60 llvm_unreachable("Unknown SectionMemoryManager::AllocationPurpose");

61 }();

65 for (FreeMemBlock &FreeMB : MemGroup.FreeMem) {

66 if (FreeMB.Free.allocatedSize() >= RequiredSize) {

67 Addr = (uintptr_t)FreeMB.Free.base();

68 uintptr_t EndOfBlock = Addr + FreeMB.Free.allocatedSize();

70 Addr = (Addr + Alignment - 1) & ~(uintptr_t)(Alignment - 1);

72 if (FreeMB.PendingPrefixIndex == (unsigned)-1) {

74 MemGroup.PendingMem.push_back(sys::MemoryBlock((void *)Addr, Size));

78 FreeMB.PendingPrefixIndex = MemGroup.PendingMem.size() - 1;

79 } else {

80 sys::MemoryBlock &PendingMB =

81 MemGroup.PendingMem[FreeMB.PendingPrefixIndex];

82 PendingMB = sys::MemoryBlock(PendingMB.base(),

83 Addr + Size - (uintptr_t)PendingMB.base());

84 }

87 FreeMB.Free =

88 sys::MemoryBlock((void *)(Addr + Size), EndOfBlock - Addr - Size);

89 return (uint8_t *)Addr;

90 }

91 }

100

101

102 std::error_code ec;

103 sys::MemoryBlock MB = MMapper->allocateMappedMemory(

104 Purpose, RequiredSize, &MemGroup.Near,

106 if (ec) {

107

108 return nullptr;

109 }

110

111

112 MemGroup.Near = MB;

113

114

115

116 if (CodeMem.Near.base() == nullptr)

117 CodeMem.Near = MB;

118 if (RODataMem.Near.base() == nullptr)

119 RODataMem.Near = MB;

120 if (RWDataMem.Near.base() == nullptr)

121 RWDataMem.Near = MB;

122

123

124 MemGroup.AllocatedMem.push_back(MB);

125 Addr = (uintptr_t)MB.base();

126 uintptr_t EndOfBlock = Addr + MB.allocatedSize();

127

128

129 Addr = (Addr + Alignment - 1) & ~(uintptr_t)(Alignment - 1);

130

131

132 MemGroup.PendingMem.push_back(sys::MemoryBlock((void *)Addr, Size));

133

134

135

136 unsigned FreeSize = EndOfBlock - Addr - Size;

137 if (FreeSize > 16) {

138 FreeMemBlock FreeMB;

139 FreeMB.Free = sys::MemoryBlock((void *)(Addr + Size), FreeSize);

140 FreeMB.PendingPrefixIndex = (unsigned)-1;

141 MemGroup.FreeMem.push_back(FreeMB);

142 }

143

144

145 return (uint8_t *)Addr;

146}

147

149

150 std::error_code ec;

151

152

153 ec = applyMemoryGroupPermissions(CodeMem,

155 if (ec) {

156 if (ErrMsg) {

157 *ErrMsg = ec.message();

158 }

159 return true;

160 }

161

162

164 if (ec) {

165 if (ErrMsg) {

166 *ErrMsg = ec.message();

167 }

168 return true;

169 }

170

171

172

173

174

175

177

178 return false;

179}

180

183

184 size_t StartOverlap =

186

187 size_t TrimmedSize = M.allocatedSize();

188 TrimmedSize -= StartOverlap;

189 TrimmedSize -= TrimmedSize % PageSize;

190

191 sys::MemoryBlock Trimmed((void *)((uintptr_t)M.base() + StartOverlap),

192 TrimmedSize);

193

198

199 return Trimmed;

200}

201

202std::error_code

203SectionMemoryManager::applyMemoryGroupPermissions(MemoryGroup &MemGroup,

204 unsigned Permissions) {

205 for (sys::MemoryBlock &MB : MemGroup.PendingMem)

207 return EC;

208

209 MemGroup.PendingMem.clear();

210

211

212

213 for (FreeMemBlock &FreeMB : MemGroup.FreeMem) {

215

216 FreeMB.PendingPrefixIndex = (unsigned)-1;

217 }

218

219

220 erase_if(MemGroup.FreeMem, [](FreeMemBlock &FreeMB) {

221 return FreeMB.Free.allocatedSize() == 0;

222 });

223

224 return std::error_code();

225}

226

230 Block.allocatedSize());

231}

232

234 for (MemoryGroup *Group : {&CodeMem, &RWDataMem, &RODataMem}) {

236 MMapper->releaseMappedMemory(Block);

237 }

238}

239

241

242void SectionMemoryManager::anchor() {}

243

244namespace {

245

246

247class DefaultMMapper final : public SectionMemoryManager::MemoryMapper {

248public:

249 sys::MemoryBlock

251 size_t NumBytes, const sys::MemoryBlock *const NearBlock,

252 unsigned Flags, std::error_code &EC) override {

254 }

255

256 std::error_code protectMappedMemory(const sys::MemoryBlock &Block,

257 unsigned Flags) override {

259 }

260

261 std::error_code releaseMappedMemory(sys::MemoryBlock &M) override {

263 }

264};

265}

266

268 : MMapper(UnownedMM), OwnedMMapper(nullptr) {

269 if (!MMapper) {

270 OwnedMMapper = std::make_unique();

271 MMapper = OwnedMMapper.get();

272 }

273}

274

275}

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

static cl::opt< int > PageSize("imp-null-check-page-size", cl::desc("The page size of the target in bytes"), cl::init(4096), cl::Hidden)

Provides a library for accessing information about this process and other processes on the operating ...

Implementations of this interface are used by SectionMemoryManager to request pages from the operatin...

virtual std::error_code protectMappedMemory(const sys::MemoryBlock &Block, unsigned Flags)=0

This method sets the protection flags for a block of memory to the state specified by Flags.

AllocationPurpose

This enum describes the various reasons to allocate pages from allocateMappedMemory.

SectionMemoryManager(MemoryMapper *MM=nullptr)

Creates a SectionMemoryManager instance with MM as the associated memory mapper.

Definition SectionMemoryManager.cpp:267

virtual void invalidateInstructionCache()

Invalidate instruction cache for code sections.

Definition SectionMemoryManager.cpp:227

~SectionMemoryManager() override

Definition SectionMemoryManager.cpp:233

uint8_t * allocateDataSection(uintptr_t Size, unsigned Alignment, unsigned SectionID, StringRef SectionName, bool isReadOnly) override

Allocates a memory block of (at least) the given size suitable for executable code.

Definition SectionMemoryManager.cpp:20

uint8_t * allocateCodeSection(uintptr_t Size, unsigned Alignment, unsigned SectionID, StringRef SectionName) override

Allocates a memory block of (at least) the given size suitable for executable code.

Definition SectionMemoryManager.cpp:32

bool finalizeMemory(std::string *ErrMsg=nullptr) override

Update section-specific memory permissions and other attributes.

Definition SectionMemoryManager.cpp:148

StringRef - Represent a constant reference to a string, i.e.

This class encapsulates the notion of a memory block which has an address and a size.

size_t allocatedSize() const

The size as it was allocated.

static LLVM_ABI std::error_code protectMappedMemory(const MemoryBlock &Block, unsigned Flags)

This method sets the protection flags for a block of memory to the state specified by /p Flags.

static LLVM_ABI std::error_code releaseMappedMemory(MemoryBlock &Block)

This method releases a block of memory that was allocated with the allocateMappedMemory method.

static LLVM_ABI void InvalidateInstructionCache(const void *Addr, size_t Len)

InvalidateInstructionCache - Before the JIT can run a block of code that has been emitted it must inv...

static LLVM_ABI MemoryBlock allocateMappedMemory(size_t NumBytes, const MemoryBlock *const NearBlock, unsigned Flags, std::error_code &EC)

This method allocates a block of memory that is suitable for loading dynamically generated code (e....

static unsigned getPageSizeEstimate()

Get the process's estimated page size.

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

This is an optimization pass for GlobalISel generic memory operations.

static sys::MemoryBlock trimBlockToPageSize(sys::MemoryBlock M)

Definition SectionMemoryManager.cpp:181

void erase_if(Container &C, UnaryPredicate P)

Provide a container algorithm similar to C++ Library Fundamentals v2's erase_if which is equivalent t...