embedded-postgres 18.6.0__py3-none-win_amd64.whl

embedded_postgres/pginstall/include/server/funcapi.h

@@ -0,0 +1,360 @@
+/*-------------------------------------------------------------------------
+ *
+ * funcapi.h
+ *	  Definitions for functions which return composite type and/or sets
+ *	  or work on VARIADIC inputs.
+ *
+ * This file must be included by all Postgres modules that either define
+ * or call FUNCAPI-callable functions or macros.
+ *
+ *
+ * Copyright (c) 2002-2025, PostgreSQL Global Development Group
+ *
+ * src/include/funcapi.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef FUNCAPI_H
+#define FUNCAPI_H
+
+#include "access/tupdesc.h"
+#include "executor/executor.h"
+#include "executor/tuptable.h"
+#include "fmgr.h"
+
+/*-------------------------------------------------------------------------
+ *	Support to ease writing Functions returning composite types
+ *-------------------------------------------------------------------------
+ *
+ * This struct holds arrays of individual attribute information
+ * needed to create a tuple from raw C strings. It also requires
+ * a copy of the TupleDesc. The information carried here
+ * is derived from the TupleDesc, but it is stored here to
+ * avoid redundant cpu cycles on each call to an SRF.
+ */
+typedef struct AttInMetadata
+{
+	/* full TupleDesc */
+	TupleDesc	tupdesc;
+
+	/* array of attribute type input function finfo */
+	FmgrInfo   *attinfuncs;
+
+	/* array of attribute type i/o parameter OIDs */
+	Oid		   *attioparams;
+
+	/* array of attribute typmod */
+	int32	   *atttypmods;
+} AttInMetadata;
+
+/*-------------------------------------------------------------------------
+ *		Support struct to ease writing Set Returning Functions (SRFs)
+ *-------------------------------------------------------------------------
+ *
+ * This struct holds function context for Set Returning Functions.
+ * Use fn_extra to hold a pointer to it across calls
+ */
+typedef struct FuncCallContext
+{
+	/*
+	 * Number of times we've been called before
+	 *
+	 * call_cntr is initialized to 0 for you by SRF_FIRSTCALL_INIT(), and
+	 * incremented for you every time SRF_RETURN_NEXT() is called.
+	 */
+	uint64		call_cntr;
+
+	/*
+	 * OPTIONAL maximum number of calls
+	 *
+	 * max_calls is here for convenience only and setting it is optional. If
+	 * not set, you must provide alternative means to know when the function
+	 * is done.
+	 */
+	uint64		max_calls;
+
+	/*
+	 * OPTIONAL pointer to miscellaneous user-provided context information
+	 *
+	 * user_fctx is for use as a pointer to your own struct to retain
+	 * arbitrary context information between calls of your function.
+	 */
+	void	   *user_fctx;
+
+	/*
+	 * OPTIONAL pointer to struct containing attribute type input metadata
+	 *
+	 * attinmeta is for use when returning tuples (i.e. composite data types)
+	 * and is not used when returning base data types. It is only needed if
+	 * you intend to use BuildTupleFromCStrings() to create the return tuple.
+	 */
+	AttInMetadata *attinmeta;
+
+	/*
+	 * memory context used for structures that must live for multiple calls
+	 *
+	 * multi_call_memory_ctx is set by SRF_FIRSTCALL_INIT() for you, and used
+	 * by SRF_RETURN_DONE() for cleanup. It is the most appropriate memory
+	 * context for any memory that is to be reused across multiple calls of
+	 * the SRF.
+	 */
+	MemoryContext multi_call_memory_ctx;
+
+	/*
+	 * OPTIONAL pointer to struct containing tuple description
+	 *
+	 * tuple_desc is for use when returning tuples (i.e. composite data types)
+	 * and is only needed if you are going to build the tuples with
+	 * heap_form_tuple() rather than with BuildTupleFromCStrings(). Note that
+	 * the TupleDesc pointer stored here should usually have been run through
+	 * BlessTupleDesc() first.
+	 */
+	TupleDesc	tuple_desc;
+
+} FuncCallContext;
+
+/*----------
+ *	Support to ease writing functions returning composite types
+ *
+ * External declarations:
+ * get_call_result_type:
+ *		Given a function's call info record, determine the kind of datatype
+ *		it is supposed to return.  If resultTypeId isn't NULL, *resultTypeId
+ *		receives the actual datatype OID (this is mainly useful for scalar
+ *		result types).  If resultTupleDesc isn't NULL, *resultTupleDesc
+ *		receives a pointer to a TupleDesc when the result is of a composite
+ *		type, or NULL when it's a scalar result or the rowtype could not be
+ *		determined.  NB: the tupledesc should be copied if it is to be
+ *		accessed over a long period.
+ * get_expr_result_type:
+ *		Given an expression node, return the same info as for
+ *		get_call_result_type.  Note: the cases in which rowtypes cannot be
+ *		determined are different from the cases for get_call_result_type.
+ * get_func_result_type:
+ *		Given only a function's OID, return the same info as for
+ *		get_call_result_type.  Note: the cases in which rowtypes cannot be
+ *		determined are different from the cases for get_call_result_type.
+ *		Do *not* use this if you can use one of the others.
+ *
+ * See also get_expr_result_tupdesc(), which is a convenient wrapper around
+ * get_expr_result_type() for use when the caller only cares about
+ * determinable-rowtype cases.
+ *----------
+ */
+
+/* Type categories for get_call_result_type and siblings */
+typedef enum TypeFuncClass
+{
+	TYPEFUNC_SCALAR,			/* scalar result type */
+	TYPEFUNC_COMPOSITE,			/* determinable rowtype result */
+	TYPEFUNC_COMPOSITE_DOMAIN,	/* domain over determinable rowtype result */
+	TYPEFUNC_RECORD,			/* indeterminate rowtype result */
+	TYPEFUNC_OTHER,				/* bogus type, eg pseudotype */
+} TypeFuncClass;
+
+extern TypeFuncClass get_call_result_type(FunctionCallInfo fcinfo,
+										  Oid *resultTypeId,
+										  TupleDesc *resultTupleDesc);
+extern TypeFuncClass get_expr_result_type(Node *expr,
+										  Oid *resultTypeId,
+										  TupleDesc *resultTupleDesc);
+extern TypeFuncClass get_func_result_type(Oid functionId,
+										  Oid *resultTypeId,
+										  TupleDesc *resultTupleDesc);
+
+extern TupleDesc get_expr_result_tupdesc(Node *expr, bool noError);
+
+extern bool resolve_polymorphic_argtypes(int numargs, Oid *argtypes,
+										 char *argmodes,
+										 Node *call_expr);
+
+extern int	get_func_arg_info(HeapTuple procTup,
+							  Oid **p_argtypes, char ***p_argnames,
+							  char **p_argmodes);
+
+extern int	get_func_input_arg_names(Datum proargnames, Datum proargmodes,
+									 char ***arg_names);
+
+extern int	get_func_trftypes(HeapTuple procTup, Oid **p_trftypes);
+extern char *get_func_result_name(Oid functionId);
+
+extern TupleDesc build_function_result_tupdesc_d(char prokind,
+												 Datum proallargtypes,
+												 Datum proargmodes,
+												 Datum proargnames);
+extern TupleDesc build_function_result_tupdesc_t(HeapTuple procTuple);
+
+
+/*----------
+ *	Support to ease writing functions returning composite types
+ *
+ * External declarations:
+ * TupleDesc BlessTupleDesc(TupleDesc tupdesc) - "Bless" a completed tuple
+ *		descriptor so that it can be used to return properly labeled tuples.
+ *		You need to call this if you are going to use heap_form_tuple directly.
+ *		TupleDescGetAttInMetadata does it for you, however, so no need to call
+ *		it if you call TupleDescGetAttInMetadata.
+ * AttInMetadata *TupleDescGetAttInMetadata(TupleDesc tupdesc) - Build an
+ *		AttInMetadata struct based on the given TupleDesc. AttInMetadata can
+ *		be used in conjunction with C strings to produce a properly formed
+ *		tuple.
+ * HeapTuple BuildTupleFromCStrings(AttInMetadata *attinmeta, char **values) -
+ *		build a HeapTuple given user data in C string form. values is an array
+ *		of C strings, one for each attribute of the return tuple.
+ * Datum HeapTupleHeaderGetDatum(HeapTupleHeader tuple) - convert a
+ *		HeapTupleHeader to a Datum.
+ *
+ * Inline declarations:
+ * HeapTupleGetDatum(HeapTuple tuple) - convert a HeapTuple to a Datum.
+ *
+ * Obsolete routines and macros:
+ * TupleDesc RelationNameGetTupleDesc(const char *relname) - Use to get a
+ *		TupleDesc based on a named relation.
+ * TupleDesc TypeGetTupleDesc(Oid typeoid, List *colaliases) - Use to get a
+ *		TupleDesc based on a type OID.
+ * TupleGetDatum(TupleTableSlot *slot, HeapTuple tuple) - get a Datum
+ *		given a tuple and a slot.
+ *----------
+ */
+
+extern TupleDesc RelationNameGetTupleDesc(const char *relname);
+extern TupleDesc TypeGetTupleDesc(Oid typeoid, List *colaliases);
+
+/* from execTuples.c */
+extern TupleDesc BlessTupleDesc(TupleDesc tupdesc);
+extern AttInMetadata *TupleDescGetAttInMetadata(TupleDesc tupdesc);
+extern HeapTuple BuildTupleFromCStrings(AttInMetadata *attinmeta, char **values);
+extern Datum HeapTupleHeaderGetDatum(HeapTupleHeader tuple);
+
+static inline Datum
+HeapTupleGetDatum(const HeapTupleData *tuple)
+{
+	return HeapTupleHeaderGetDatum(tuple->t_data);
+}
+
+/* obsolete version of above */
+#define TupleGetDatum(_slot, _tuple)	HeapTupleGetDatum(_tuple)
+
+
+/*----------
+ *		Support for Set Returning Functions (SRFs)
+ *
+ * The basic API for SRFs using ValuePerCall mode looks something like this:
+ *
+ * Datum
+ * my_Set_Returning_Function(PG_FUNCTION_ARGS)
+ * {
+ *	FuncCallContext    *funcctx;
+ *	Datum				result;
+ *	MemoryContext		oldcontext;
+ *	<user defined declarations>
+ *
+ *	if (SRF_IS_FIRSTCALL())
+ *	{
+ *		funcctx = SRF_FIRSTCALL_INIT();
+ *		// switch context when allocating stuff to be used in later calls
+ *		oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
+ *		<user defined code>
+ *		<if returning composite>
+ *			<build TupleDesc, and perhaps AttInMetadata>
+ *		<endif returning composite>
+ *		<user defined code>
+ *		// return to original context when allocating transient memory
+ *		MemoryContextSwitchTo(oldcontext);
+ *	}
+ *	<user defined code>
+ *	funcctx = SRF_PERCALL_SETUP();
+ *	<user defined code>
+ *
+ *	if (funcctx->call_cntr < funcctx->max_calls)
+ *	{
+ *		<user defined code>
+ *		<obtain result Datum>
+ *		SRF_RETURN_NEXT(funcctx, result);
+ *	}
+ *	else
+ *		SRF_RETURN_DONE(funcctx);
+ * }
+ *
+ * NOTE: there is no guarantee that a SRF using ValuePerCall mode will be
+ * run to completion; for example, a query with LIMIT might stop short of
+ * fetching all the rows.  Therefore, do not expect that you can do resource
+ * cleanup just before SRF_RETURN_DONE().  You need not worry about releasing
+ * memory allocated in multi_call_memory_ctx, but holding file descriptors or
+ * other non-memory resources open across calls is a bug.  SRFs that need
+ * such resources should not use these macros, but instead populate a
+ * tuplestore during a single call, as set up by InitMaterializedSRF() (see
+ * fmgr/README).  Alternatively, set up a callback to release resources
+ * at query shutdown, using RegisterExprContextCallback().
+ *
+ *----------
+ */
+
+/* from funcapi.c */
+
+/* flag bits for InitMaterializedSRF() */
+#define MAT_SRF_USE_EXPECTED_DESC	0x01	/* use expectedDesc as tupdesc. */
+#define MAT_SRF_BLESS				0x02	/* "Bless" a tuple descriptor with
+											 * BlessTupleDesc(). */
+extern void InitMaterializedSRF(FunctionCallInfo fcinfo, bits32 flags);
+
+extern FuncCallContext *init_MultiFuncCall(PG_FUNCTION_ARGS);
+extern FuncCallContext *per_MultiFuncCall(PG_FUNCTION_ARGS);
+extern void end_MultiFuncCall(PG_FUNCTION_ARGS, FuncCallContext *funcctx);
+
+#define SRF_IS_FIRSTCALL() (fcinfo->flinfo->fn_extra == NULL)
+
+#define SRF_FIRSTCALL_INIT() init_MultiFuncCall(fcinfo)
+
+#define SRF_PERCALL_SETUP() per_MultiFuncCall(fcinfo)
+
+#define SRF_RETURN_NEXT(_funcctx, _result) \
+	do { \
+		ReturnSetInfo	   *rsi; \
+		(_funcctx)->call_cntr++; \
+		rsi = (ReturnSetInfo *) fcinfo->resultinfo; \
+		rsi->isDone = ExprMultipleResult; \
+		PG_RETURN_DATUM(_result); \
+	} while (0)
+
+#define SRF_RETURN_NEXT_NULL(_funcctx) \
+	do { \
+		ReturnSetInfo	   *rsi; \
+		(_funcctx)->call_cntr++; \
+		rsi = (ReturnSetInfo *) fcinfo->resultinfo; \
+		rsi->isDone = ExprMultipleResult; \
+		PG_RETURN_NULL(); \
+	} while (0)
+
+#define  SRF_RETURN_DONE(_funcctx) \
+	do { \
+		ReturnSetInfo	   *rsi; \
+		end_MultiFuncCall(fcinfo, _funcctx); \
+		rsi = (ReturnSetInfo *) fcinfo->resultinfo; \
+		rsi->isDone = ExprEndResult; \
+		PG_RETURN_NULL(); \
+	} while (0)
+
+/*----------
+ *	Support to ease writing of functions dealing with VARIADIC inputs
+ *----------
+ *
+ * This function extracts a set of argument values, types and NULL markers
+ * for a given input function. This returns a set of data:
+ * - **values includes the set of Datum values extracted.
+ * - **types the data type OID for each element.
+ * - **nulls tracks if an element is NULL.
+ *
+ * variadic_start indicates the argument number where the VARIADIC argument
+ * starts.
+ * convert_unknown set to true will enforce the conversion of arguments
+ * with unknown data type to text.
+ *
+ * The return result is the number of elements stored, or -1 in the case of
+ * "VARIADIC NULL".
+ */
+extern int	extract_variadic_args(FunctionCallInfo fcinfo, int variadic_start,
+								  bool convert_unknown, Datum **args,
+								  Oid **types, bool **nulls);
+
+#endif							/* FUNCAPI_H */

embedded_postgres/pginstall/include/server/getopt_long.h

@@ -0,0 +1,37 @@
+/*
+ * Portions Copyright (c) 1987, 1993, 1994
+ * The Regents of the University of California.  All rights reserved.
+ *
+ * Portions Copyright (c) 2003-2025, PostgreSQL Global Development Group
+ *
+ * src/include/getopt_long.h
+ */
+/* IWYU pragma: always_keep */
+#ifndef GETOPT_LONG_H
+#define GETOPT_LONG_H
+
+#include "pg_getopt.h"			/* IWYU pragma: export */
+
+#ifndef HAVE_STRUCT_OPTION
+
+struct option
+{
+	const char *name;
+	int			has_arg;
+	int		   *flag;
+	int			val;
+};
+
+#define no_argument 0
+#define required_argument 1
+#define optional_argument 2
+#endif
+
+#ifndef HAVE_GETOPT_LONG
+
+extern int	getopt_long(int argc, char *const argv[],
+						const char *optstring,
+						const struct option *longopts, int *longindex);
+#endif
+
+#endif							/* GETOPT_LONG_H */

embedded_postgres/pginstall/include/server/jit/SectionMemoryManager.h

@@ -0,0 +1,226 @@
+/*
+ * This is a copy of LLVM source code modified by the PostgreSQL project.
+ * See SectionMemoryManager.cpp for notes on provenance and license.
+ */
+
+//===- SectionMemoryManager.h - Memory manager for MCJIT/RtDyld -*- 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 contains the declaration of a section-based memory manager used by
+// the MCJIT execution engine and RuntimeDyld.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_BACKPORT_SECTIONMEMORYMANAGER_H
+#define LLVM_EXECUTIONENGINE_BACKPORT_SECTIONMEMORYMANAGER_H
+
+#include <llvm/ADT/SmallVector.h>
+#include <llvm/ExecutionEngine/RTDyldMemoryManager.h>
+#include <llvm/Support/Alignment.h>
+#include <llvm/Support/Memory.h>
+#include <cstdint>
+#include <string>
+#include <system_error>
+
+namespace llvm {
+namespace backport {
+
+/// This is a simple memory manager which implements the methods called by
+/// the RuntimeDyld class to allocate memory for section-based loading of
+/// objects, usually those generated by the MCJIT execution engine.
+///
+/// This memory manager allocates all section memory as read-write.  The
+/// RuntimeDyld will copy JITed section memory into these allocated blocks
+/// and perform any necessary linking and relocations.
+///
+/// Any client using this memory manager MUST ensure that section-specific
+/// page permissions have been applied before attempting to execute functions
+/// in the JITed object.  Permissions can be applied either by calling
+/// MCJIT::finalizeObject or by calling SectionMemoryManager::finalizeMemory
+/// directly.  Clients of MCJIT should call MCJIT::finalizeObject.
+class SectionMemoryManager : public RTDyldMemoryManager {
+public:
+  /// This enum describes the various reasons to allocate pages from
+  /// allocateMappedMemory.
+  enum class AllocationPurpose {
+    Code,
+    ROData,
+    RWData,
+  };
+
+  /// Implementations of this interface are used by SectionMemoryManager to
+  /// request pages from the operating system.
+  class MemoryMapper {
+  public:
+    /// This method attempts to allocate \p NumBytes bytes of virtual memory for
+    /// \p Purpose.  \p NearBlock may point to an existing allocation, in which
+    /// case an attempt is made to allocate more memory near the existing block.
+    /// The actual allocated address is not guaranteed to be near the requested
+    /// address.  \p Flags is used to set the initial protection flags for the
+    /// block of the memory.  \p EC [out] returns an object describing any error
+    /// that occurs.
+    ///
+    /// This method may allocate more than the number of bytes requested.  The
+    /// actual number of bytes allocated is indicated in the returned
+    /// MemoryBlock.
+    ///
+    /// The start of the allocated block must be aligned with the system
+    /// allocation granularity (64K on Windows, page size on Linux).  If the
+    /// address following \p NearBlock is not so aligned, it will be rounded up
+    /// to the next allocation granularity boundary.
+    ///
+    /// \r a non-null MemoryBlock if the function was successful, otherwise a
+    /// null MemoryBlock with \p EC describing the error.
+    virtual sys::MemoryBlock
+    allocateMappedMemory(AllocationPurpose Purpose, size_t NumBytes,
+                         const sys::MemoryBlock *const NearBlock,
+                         unsigned Flags, std::error_code &EC) = 0;
+
+    /// This method sets the protection flags for a block of memory to the state
+    /// specified by \p Flags.  The behavior is not specified if the memory was
+    /// not allocated using the allocateMappedMemory method.
+    /// \p Block describes the memory block to be protected.
+    /// \p Flags specifies the new protection state to be assigned to the block.
+    ///
+    /// If \p Flags is MF_WRITE, the actual behavior varies with the operating
+    /// system (i.e. MF_READ | MF_WRITE on Windows) and the target architecture
+    /// (i.e. MF_WRITE -> MF_READ | MF_WRITE on i386).
+    ///
+    /// \r error_success if the function was successful, or an error_code
+    /// describing the failure if an error occurred.
+    virtual std::error_code protectMappedMemory(const sys::MemoryBlock &Block,
+                                                unsigned Flags) = 0;
+
+    /// This method releases a block of memory that was allocated with the
+    /// allocateMappedMemory method. It should not be used to release any memory
+    /// block allocated any other way.
+    /// \p Block describes the memory to be released.
+    ///
+    /// \r error_success if the function was successful, or an error_code
+    /// describing the failure if an error occurred.
+    virtual std::error_code releaseMappedMemory(sys::MemoryBlock &M) = 0;
+
+    virtual ~MemoryMapper();
+  };
+
+  /// Creates a SectionMemoryManager instance with \p MM as the associated
+  /// memory mapper.  If \p MM is nullptr then a default memory mapper is used
+  /// that directly calls into the operating system.
+  ///
+  /// If \p ReserveAlloc is true all memory will be pre-allocated, and any
+  /// attempts to allocate beyond pre-allocated memory will fail.
+  SectionMemoryManager(MemoryMapper *MM = nullptr, bool ReserveAlloc = false);
+  SectionMemoryManager(const SectionMemoryManager &) = delete;
+  void operator=(const SectionMemoryManager &) = delete;
+  ~SectionMemoryManager() override;
+
+  /// Enable reserveAllocationSpace when requested.
+  bool needsToReserveAllocationSpace() override { return ReserveAllocation; }
+
+  /// Implements allocating all memory in a single block. This is required to
+  /// limit memory offsets to fit the ARM ABI; large memory systems may
+  /// otherwise allocate separate sections too far apart.
+#if LLVM_VERSION_MAJOR < 16
+  virtual void reserveAllocationSpace(uintptr_t CodeSize, uint32_t CodeAlign,
+                                      uintptr_t RODataSize,
+                                      uint32_t RODataAlign,
+                                      uintptr_t RWDataSize,
+                                      uint32_t RWDataAlign) override;
+#else
+  void reserveAllocationSpace(uintptr_t CodeSize, Align CodeAlign,
+                              uintptr_t RODataSize, Align RODataAlign,
+                              uintptr_t RWDataSize, Align RWDataAlign) override;
+#endif
+
+  /// Allocates a memory block of (at least) the given size suitable for
+  /// executable code.
+  ///
+  /// The value of \p Alignment must be a power of two.  If \p Alignment is zero
+  /// a default alignment of 16 will be used.
+  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.
+  ///
+  /// The value of \p Alignment must be a power of two.  If \p Alignment is zero
+  /// a default alignment of 16 will be used.
+  uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
+                               unsigned SectionID, StringRef SectionName,
+                               bool IsReadOnly) override;
+
+  /// Update section-specific memory permissions and other attributes.
+  ///
+  /// This method is called when object loading is complete and section page
+  /// permissions can be applied.  It is up to the memory manager implementation
+  /// to decide whether or not to act on this method.  The memory manager will
+  /// typically allocate all sections as read-write and then apply specific
+  /// permissions when this method is called.  Code sections cannot be executed
+  /// until this function has been called.  In addition, any cache coherency
+  /// operations needed to reliably use the memory are also performed.
+  ///
+  /// \returns true if an error occurred, false otherwise.
+  bool finalizeMemory(std::string *ErrMsg = nullptr) override;
+
+  /// Invalidate instruction cache for code sections.
+  ///
+  /// Some platforms with separate data cache and instruction cache require
+  /// explicit cache flush, otherwise JIT code manipulations (like resolved
+  /// relocations) will get to the data cache but not to the instruction cache.
+  ///
+  /// This method is called from finalizeMemory.
+  virtual void invalidateInstructionCache();
+
+private:
+  struct FreeMemBlock {
+    // The actual block of free memory
+    sys::MemoryBlock Free;
+    // If there is a pending allocation from the same reservation right before
+    // this block, store its index in PendingMem, to be able to update the
+    // pending region if part of this block is allocated, rather than having to
+    // create a new one
+    unsigned PendingPrefixIndex;
+  };
+
+  struct MemoryGroup {
+    // PendingMem contains all blocks of memory (subblocks of AllocatedMem)
+    // which have not yet had their permissions applied, but have been given
+    // out to the user. FreeMem contains all block of memory, which have
+    // neither had their permissions applied, nor been given out to the user.
+    SmallVector<sys::MemoryBlock, 16> PendingMem;
+    SmallVector<FreeMemBlock, 16> FreeMem;
+
+    // All memory blocks that have been requested from the system
+    SmallVector<sys::MemoryBlock, 16> AllocatedMem;
+
+    sys::MemoryBlock Near;
+  };
+
+  uint8_t *allocateSection(AllocationPurpose Purpose, uintptr_t Size,
+                           unsigned Alignment);
+
+  std::error_code applyMemoryGroupPermissions(MemoryGroup &MemGroup,
+                                              unsigned Permissions);
+
+  bool hasSpace(const MemoryGroup &MemGroup, uintptr_t Size) const;
+
+  void anchor() override;
+
+  MemoryGroup CodeMem;
+  MemoryGroup RWDataMem;
+  MemoryGroup RODataMem;
+  MemoryMapper *MMapper;
+  std::unique_ptr<MemoryMapper> OwnedMMapper;
+  bool ReserveAllocation;
+};
+
+} // end namespace backport
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_BACKPORT_SECTIONMEMORYMANAGER_H