LLVM  4.0.0
SectionMemoryManager.h
Go to the documentation of this file.
1 //===- SectionMemoryManager.h - Memory manager for MCJIT/RtDyld -*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file contains the declaration of a section-based memory manager used by
11 // the MCJIT execution engine and RuntimeDyld.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_EXECUTIONENGINE_SECTIONMEMORYMANAGER_H
16 #define LLVM_EXECUTIONENGINE_SECTIONMEMORYMANAGER_H
17 
18 #include "llvm/ADT/SmallVector.h"
19 #include "llvm/ADT/StringRef.h"
21 #include "llvm/Support/Memory.h"
22 #include <cstdint>
23 #include <string>
24 #include <system_error>
25 
26 namespace llvm {
27 
28 /// This is a simple memory manager which implements the methods called by
29 /// the RuntimeDyld class to allocate memory for section-based loading of
30 /// objects, usually those generated by the MCJIT execution engine.
31 ///
32 /// This memory manager allocates all section memory as read-write. The
33 /// RuntimeDyld will copy JITed section memory into these allocated blocks
34 /// and perform any necessary linking and relocations.
35 ///
36 /// Any client using this memory manager MUST ensure that section-specific
37 /// page permissions have been applied before attempting to execute functions
38 /// in the JITed object. Permissions can be applied either by calling
39 /// MCJIT::finalizeObject or by calling SectionMemoryManager::finalizeMemory
40 /// directly. Clients of MCJIT should call MCJIT::finalizeObject.
42 public:
43  SectionMemoryManager() = default;
45  void operator=(const SectionMemoryManager&) = delete;
46  ~SectionMemoryManager() override;
47 
48  /// \brief Allocates a memory block of (at least) the given size suitable for
49  /// executable code.
50  ///
51  /// The value of \p Alignment must be a power of two. If \p Alignment is zero
52  /// a default alignment of 16 will be used.
53  uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
54  unsigned SectionID,
55  StringRef SectionName) override;
56 
57  /// \brief Allocates a memory block of (at least) the given size suitable for
58  /// executable code.
59  ///
60  /// The value of \p Alignment must be a power of two. If \p Alignment is zero
61  /// a default alignment of 16 will be used.
62  uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
63  unsigned SectionID, StringRef SectionName,
64  bool isReadOnly) override;
65 
66  /// \brief Update section-specific memory permissions and other attributes.
67  ///
68  /// This method is called when object loading is complete and section page
69  /// permissions can be applied. It is up to the memory manager implementation
70  /// to decide whether or not to act on this method. The memory manager will
71  /// typically allocate all sections as read-write and then apply specific
72  /// permissions when this method is called. Code sections cannot be executed
73  /// until this function has been called. In addition, any cache coherency
74  /// operations needed to reliably use the memory are also performed.
75  ///
76  /// \returns true if an error occurred, false otherwise.
77  bool finalizeMemory(std::string *ErrMsg = nullptr) override;
78 
79  /// \brief Invalidate instruction cache for code sections.
80  ///
81  /// Some platforms with separate data cache and instruction cache require
82  /// explicit cache flush, otherwise JIT code manipulations (like resolved
83  /// relocations) will get to the data cache but not to the instruction cache.
84  ///
85  /// This method is called from finalizeMemory.
86  virtual void invalidateInstructionCache();
87 
88 private:
89  struct FreeMemBlock {
90  // The actual block of free memory
91  sys::MemoryBlock Free;
92  // If there is a pending allocation from the same reservation right before
93  // this block, store it's index in PendingMem, to be able to update the
94  // pending region if part of this block is allocated, rather than having to
95  // create a new one
96  unsigned PendingPrefixIndex;
97  };
98 
99  struct MemoryGroup {
100  // PendingMem contains all blocks of memory (subblocks of AllocatedMem)
101  // which have not yet had their permissions applied, but have been given
102  // out to the user. FreeMem contains all block of memory, which have
103  // neither had their permissions applied, nor been given out to the user.
106 
107  // All memory blocks that have been requested from the system
109 
110  sys::MemoryBlock Near;
111  };
112 
113  uint8_t *allocateSection(MemoryGroup &MemGroup, uintptr_t Size,
114  unsigned Alignment);
115 
116  std::error_code applyMemoryGroupPermissions(MemoryGroup &MemGroup,
117  unsigned Permissions);
118 
119  MemoryGroup CodeMem;
120  MemoryGroup RWDataMem;
121  MemoryGroup RODataMem;
122 };
123 
124 } // end namespace llvm
125 
126 #endif // LLVM_EXECUTION_ENGINE_SECTION_MEMORY_MANAGER_H
virtual void invalidateInstructionCache()
Invalidate instruction cache for code sections.
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.
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.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:843
static bool isReadOnly(const GlobalValue *GV)
This class encapsulates the notion of a memory block which has an address and a size.
Definition: Memory.h:29
void operator=(const SectionMemoryManager &)=delete
bool finalizeMemory(std::string *ErrMsg=nullptr) override
Update section-specific memory permissions and other attributes.
const char SectionName[]
Definition: AMDGPUPTNote.h:24
This is a simple memory manager which implements the methods called by the RuntimeDyld class to alloc...
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47