| //===- Memory.h -------------------------------------------------*- C++ -*-===// | |
| // | |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |
| // See https://llvm.org/LICENSE.txt for license information. | |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |
| // | |
| //===----------------------------------------------------------------------===// | |
| // | |
| // This file defines arena allocators. | |
| // | |
| // Almost all large objects, such as files, sections or symbols, are | |
| // used for the entire lifetime of the linker once they are created. | |
| // This usage characteristic makes arena allocator an attractive choice | |
| // where the entire linker is one arena. With an arena, newly created | |
| // objects belong to the arena and freed all at once when everything is done. | |
| // Arena allocators are efficient and easy to understand. | |
| // Most objects are allocated using the arena allocators defined by this file. | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #ifndef LLD_COMMON_MEMORY_H | |
| #define LLD_COMMON_MEMORY_H | |
| #include "llvm/Support/Allocator.h" | |
| namespace lld { | |
| // A base class only used by the CommonLinkerContext to keep track of the | |
| // SpecificAlloc<> instances. | |
| struct SpecificAllocBase { | |
| virtual ~SpecificAllocBase() = default; | |
| static SpecificAllocBase *getOrCreate(void *tag, size_t size, size_t align, | |
| SpecificAllocBase *(&creator)(void *)); | |
| }; | |
| // An arena of specific types T, created on-demand. | |
| template <class T> struct SpecificAlloc : public SpecificAllocBase { | |
| static SpecificAllocBase *create(void *storage) { | |
| return new (storage) SpecificAlloc<T>(); | |
| } | |
| llvm::SpecificBumpPtrAllocator<T> alloc; | |
| static int tag; | |
| }; | |
| // The address of this static member is only used as a key in | |
| // CommonLinkerContext::instances. Its value does not matter. | |
| template <class T> int SpecificAlloc<T>::tag = 0; | |
| // Creates the arena on-demand on the first call; or returns it, if it was | |
| // already created. | |
| template <typename T> | |
| inline llvm::SpecificBumpPtrAllocator<T> &getSpecificAllocSingleton() { | |
| SpecificAllocBase *instance = SpecificAllocBase::getOrCreate( | |
| &SpecificAlloc<T>::tag, sizeof(SpecificAlloc<T>), | |
| alignof(SpecificAlloc<T>), SpecificAlloc<T>::create); | |
| return ((SpecificAlloc<T> *)instance)->alloc; | |
| } | |
| // Creates new instances of T off a (almost) contiguous arena/object pool. The | |
| // instances are destroyed whenever lldMain() goes out of scope. | |
| template <typename T, typename... U> T *make(U &&... args) { | |
| return new (getSpecificAllocSingleton<T>().Allocate()) | |
| T(std::forward<U>(args)...); | |
| } | |
| template <typename T> | |
| inline llvm::SpecificBumpPtrAllocator<T> & | |
| getSpecificAllocSingletonThreadLocal() { | |
| thread_local SpecificAlloc<T> instance; | |
| return instance.alloc; | |
| } | |
| // Create a new instance of T off a thread-local SpecificAlloc, used by code | |
| // like parallel input section initialization. The use cases assume that the | |
| // return value outlives the containing parallelForEach (if exists), which is | |
| // currently guaranteed: when parallelForEach returns, the threads allocating | |
| // the TLS are not destroyed. | |
| // | |
| // Note: Some ports (e.g. ELF) have lots of global states which are currently | |
| // infeasible to remove, and context() just adds overhead with no benefit. The | |
| // allocation performance is of higher importance, so we simply use thread_local | |
| // allocators instead of doing context indirection and pthread_getspecific. | |
| template <typename T, typename... U> T *makeThreadLocal(U &&...args) { | |
| return new (getSpecificAllocSingletonThreadLocal<T>().Allocate()) | |
| T(std::forward<U>(args)...); | |
| } | |
| template <typename T> T *makeThreadLocalN(size_t n) { | |
| return new (getSpecificAllocSingletonThreadLocal<T>().Allocate(n)) T[n]; | |
| } | |
| } // namespace lld | |
| #endif |