pg_query 5.0.0 → 6.0.0

data/ext/pg_query/src_backend_utils_mmgr_slab.c

@@ -2,8 +2,11 @@
  * Symbols referenced in this file:
  * - SlabAlloc
  * - SlabBlocklistIndex
+ * - SlabAllocInvalidSize
+ * - SlabAllocFromNewBlock
  * - SlabGetNextFreeChunk
  * - SlabFindNextBlockListIndex
+ * - SlabAllocSetupNewChunk
  * - SlabFree
  * - SlabRealloc
  * - SlabReset
@@ -26,7 +29,7 @@
  * with minimal memory wastage and fragmentation.
  *
  *
- * Portions Copyright (c) 2017-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 2017-2024, PostgreSQL Global Development Group
  *
  * IDENTIFICATION
  *	  src/backend/utils/mmgr/slab.c
@@ -89,8 +92,8 @@
 #include "lib/ilist.h"
 #include "utils/memdebug.h"
 #include "utils/memutils.h"
-#include "utils/memutils_memorychunk.h"
 #include "utils/memutils_internal.h"
+#include "utils/memutils_memorychunk.h"
 
 #define Slab_BLOCKHDRSZ	MAXALIGN(sizeof(SlabBlock))
 
@@ -122,9 +125,9 @@ typedef struct SlabContext
 {
 	MemoryContextData header;	/* Standard memory-context fields */
 	/* Allocation parameters for this context: */
-	Size		chunkSize;		/* the requested (non-aligned) chunk size */
-	Size		fullChunkSize;	/* chunk size with chunk header and alignment */
-	Size		blockSize;		/* the size to make each block of chunks */
+	uint32		chunkSize;		/* the requested (non-aligned) chunk size */
+	uint32		fullChunkSize;	/* chunk size with chunk header and alignment */
+	uint32		blockSize;		/* the size to make each block of chunks */
 	int32		chunksPerBlock; /* number of chunks that fit in 1 block */
 	int32		curBlocklistIndex;	/* index into the blocklist[] element
 									 * containing the fullest, blocks */
@@ -332,7 +335,9 @@ SlabGetNextFreeChunk(SlabContext *slab, SlabBlock *block)
  * blockSize: allocation block size
  * chunkSize: allocation chunk size
  *
- * The MAXALIGN(chunkSize) may not exceed MEMORYCHUNK_MAX_VALUE
+ * The Slab_CHUNKHDRSZ + MAXALIGN(chunkSize + 1) may not exceed
+ * MEMORYCHUNK_MAX_VALUE.
+ * 'blockSize' may not exceed MEMORYCHUNK_MAX_BLOCKOFFSET.
  */
 #ifdef MEMORY_CONTEXT_CHECKING
 #else
@@ -411,85 +416,169 @@ SlabDelete(MemoryContext context)
 }
 
 /*
- * SlabAlloc
- *		Returns a pointer to allocated memory of given size or NULL if
- *		request could not be completed; memory is added to the slab.
+ * Small helper for allocating a new chunk from a chunk, to avoid duplicating
+ * the code between SlabAlloc() and SlabAllocFromNewBlock().
  */
-void *
-SlabAlloc(MemoryContext context, Size size)
+static inline void *
+SlabAllocSetupNewChunk(MemoryContext context, SlabBlock *block,
+					   MemoryChunk *chunk, Size size)
+{
+	SlabContext *slab = (SlabContext *) context;
+
+	/*
+	 * Check that the chunk pointer is actually somewhere on the block and is
+	 * aligned as expected.
+	 */
+	Assert(chunk >= SlabBlockGetChunk(slab, block, 0));
+	Assert(chunk <= SlabBlockGetChunk(slab, block, slab->chunksPerBlock - 1));
+	Assert(SlabChunkMod(slab, block, chunk) == 0);
+
+	/* Prepare to initialize the chunk header. */
+	VALGRIND_MAKE_MEM_UNDEFINED(chunk, Slab_CHUNKHDRSZ);
+
+	MemoryChunkSetHdrMask(chunk, block, MAXALIGN(slab->chunkSize), MCTX_SLAB_ID);
+
+#ifdef MEMORY_CONTEXT_CHECKING
+	/* slab mark to catch clobber of "unused" space */
+	Assert(slab->chunkSize < (slab->fullChunkSize - Slab_CHUNKHDRSZ));
+	set_sentinel(MemoryChunkGetPointer(chunk), size);
+	VALGRIND_MAKE_MEM_NOACCESS(((char *) chunk) + Slab_CHUNKHDRSZ +
+							   slab->chunkSize,
+							   slab->fullChunkSize -
+							   (slab->chunkSize + Slab_CHUNKHDRSZ));
+#endif
+
+#ifdef RANDOMIZE_ALLOCATED_MEMORY
+	/* fill the allocated space with junk */
+	randomize_mem((char *) MemoryChunkGetPointer(chunk), size);
+#endif
+
+	/* Disallow access to the chunk header. */
+	VALGRIND_MAKE_MEM_NOACCESS(chunk, Slab_CHUNKHDRSZ);
+
+	return MemoryChunkGetPointer(chunk);
+}
+
+pg_noinline
+static void *
+SlabAllocFromNewBlock(MemoryContext context, Size size, int flags)
 {
 	SlabContext *slab = (SlabContext *) context;
 	SlabBlock  *block;
 	MemoryChunk *chunk;
+	dlist_head *blocklist;
+	int			blocklist_idx;
 
-	Assert(SlabIsValid(slab));
+	/* to save allocating a new one, first check the empty blocks list */
+	if (dclist_count(&slab->emptyblocks) > 0)
+	{
+		dlist_node *node = dclist_pop_head_node(&slab->emptyblocks);
 
-	/* sanity check that this is pointing to a valid blocklist */
-	Assert(slab->curBlocklistIndex >= 0);
-	Assert(slab->curBlocklistIndex <= SlabBlocklistIndex(slab, slab->chunksPerBlock));
+		block = dlist_container(SlabBlock, node, node);
 
-	/* make sure we only allow correct request size */
-	if (unlikely(size != slab->chunkSize))
-		elog(ERROR, "unexpected alloc chunk size %zu (expected %zu)",
-			 size, slab->chunkSize);
+		/*
+		 * SlabFree() should have left this block in a valid state with all
+		 * chunks free.  Ensure that's the case.
+		 */
+		Assert(block->nfree == slab->chunksPerBlock);
 
-	/*
-	 * Handle the case when there are no partially filled blocks available.
-	 * SlabFree() will have updated the curBlocklistIndex setting it to zero
-	 * to indicate that it has freed the final block.  Also later in
-	 * SlabAlloc() we will set the curBlocklistIndex to zero if we end up
-	 * filling the final block.
-	 */
-	if (unlikely(slab->curBlocklistIndex == 0))
+		/* fetch the next chunk from this block */
+		chunk = SlabGetNextFreeChunk(slab, block);
+	}
+	else
 	{
-		dlist_head *blocklist;
-		int			blocklist_idx;
+		block = (SlabBlock *) malloc(slab->blockSize);
 
-		/* to save allocating a new one, first check the empty blocks list */
-		if (dclist_count(&slab->emptyblocks) > 0)
-		{
-			dlist_node *node = dclist_pop_head_node(&slab->emptyblocks);
+		if (unlikely(block == NULL))
+			return MemoryContextAllocationFailure(context, size, flags);
 
-			block = dlist_container(SlabBlock, node, node);
+		block->slab = slab;
+		context->mem_allocated += slab->blockSize;
 
-			/*
-			 * SlabFree() should have left this block in a valid state with
-			 * all chunks free.  Ensure that's the case.
-			 */
-			Assert(block->nfree == slab->chunksPerBlock);
+		/* use the first chunk in the new block */
+		chunk = SlabBlockGetChunk(slab, block, 0);
 
-			/* fetch the next chunk from this block */
-			chunk = SlabGetNextFreeChunk(slab, block);
-		}
-		else
-		{
-			block = (SlabBlock *) malloc(slab->blockSize);
+		block->nfree = slab->chunksPerBlock - 1;
+		block->unused = SlabBlockGetChunk(slab, block, 1);
+		block->freehead = NULL;
+		block->nunused = slab->chunksPerBlock - 1;
+	}
 
-			if (unlikely(block == NULL))
-				return NULL;
+	/* find the blocklist element for storing blocks with 1 used chunk */
+	blocklist_idx = SlabBlocklistIndex(slab, block->nfree);
+	blocklist = &slab->blocklist[blocklist_idx];
 
-			block->slab = slab;
-			context->mem_allocated += slab->blockSize;
+	/* this better be empty.  We just added a block thinking it was */
+	Assert(dlist_is_empty(blocklist));
 
-			/* use the first chunk in the new block */
-			chunk = SlabBlockGetChunk(slab, block, 0);
+	dlist_push_head(blocklist, &block->node);
 
-			block->nfree = slab->chunksPerBlock - 1;
-			block->unused = SlabBlockGetChunk(slab, block, 1);
-			block->freehead = NULL;
-			block->nunused = slab->chunksPerBlock - 1;
-		}
+	slab->curBlocklistIndex = blocklist_idx;
+
+	return SlabAllocSetupNewChunk(context, block, chunk, size);
+}
+
+/*
+ * SlabAllocInvalidSize
+ *		Handle raising an ERROR for an invalid size request.  We don't do this
+ *		in slab alloc as calling the elog functions would force the compiler
+ *		to setup the stack frame in SlabAlloc.  For performance reasons, we
+ *		want to avoid that.
+ */
+pg_noinline
+static void
+pg_attribute_noreturn()
+SlabAllocInvalidSize(MemoryContext context, Size size)
+{
+	SlabContext *slab = (SlabContext *) context;
+
+	elog(ERROR, "unexpected alloc chunk size %zu (expected %u)", size,
+		 slab->chunkSize);
+}
+
+/*
+ * SlabAlloc
+ *		Returns a pointer to a newly allocated memory chunk or raises an ERROR
+ *		on allocation failure, or returns NULL when flags contains
+ *		MCXT_ALLOC_NO_OOM.  'size' must be the same size as was specified
+ *		during SlabContextCreate().
+ *
+ * This function should only contain the most common code paths.  Everything
+ * else should be in pg_noinline helper functions, thus avoiding the overhead
+ * of creating a stack frame for the common cases.  Allocating memory is often
+ * a bottleneck in many workloads, so avoiding stack frame setup is
+ * worthwhile.  Helper functions should always directly return the newly
+ * allocated memory so that we can just return that address directly as a tail
+ * call.
+ */
+void *
+SlabAlloc(MemoryContext context, Size size, int flags)
+{
+	SlabContext *slab = (SlabContext *) context;
+	SlabBlock  *block;
+	MemoryChunk *chunk;
 
-		/* find the blocklist element for storing blocks with 1 used chunk */
-		blocklist_idx = SlabBlocklistIndex(slab, block->nfree);
-		blocklist = &slab->blocklist[blocklist_idx];
+	Assert(SlabIsValid(slab));
 
-		/* this better be empty.  We just added a block thinking it was */
-		Assert(dlist_is_empty(blocklist));
+	/* sanity check that this is pointing to a valid blocklist */
+	Assert(slab->curBlocklistIndex >= 0);
+	Assert(slab->curBlocklistIndex <= SlabBlocklistIndex(slab, slab->chunksPerBlock));
 
-		dlist_push_head(blocklist, &block->node);
+	/*
+	 * Make sure we only allow correct request size.  This doubles as the
+	 * MemoryContextCheckSize check.
+	 */
+	if (unlikely(size != slab->chunkSize))
+		SlabAllocInvalidSize(context, size);
 
-		slab->curBlocklistIndex = blocklist_idx;
+	if (unlikely(slab->curBlocklistIndex == 0))
+	{
+		/*
+		 * Handle the case when there are no partially filled blocks
+		 * available.  This happens either when the last allocation took the
+		 * last chunk in the block, or when SlabFree() free'd the final block.
+		 */
+		return SlabAllocFromNewBlock(context, size, flags);
 	}
 	else
 	{
@@ -526,38 +615,7 @@ SlabAlloc(MemoryContext context, Size size)
 		}
 	}
 
-	/*
-	 * Check that the chunk pointer is actually somewhere on the block and is
-	 * aligned as expected.
-	 */
-	Assert(chunk >= SlabBlockGetChunk(slab, block, 0));
-	Assert(chunk <= SlabBlockGetChunk(slab, block, slab->chunksPerBlock - 1));
-	Assert(SlabChunkMod(slab, block, chunk) == 0);
-
-	/* Prepare to initialize the chunk header. */
-	VALGRIND_MAKE_MEM_UNDEFINED(chunk, Slab_CHUNKHDRSZ);
-
-	MemoryChunkSetHdrMask(chunk, block, MAXALIGN(slab->chunkSize),
-						  MCTX_SLAB_ID);
-#ifdef MEMORY_CONTEXT_CHECKING
-	/* slab mark to catch clobber of "unused" space */
-	Assert(slab->chunkSize < (slab->fullChunkSize - Slab_CHUNKHDRSZ));
-	set_sentinel(MemoryChunkGetPointer(chunk), size);
-	VALGRIND_MAKE_MEM_NOACCESS(((char *) chunk) +
-							   Slab_CHUNKHDRSZ + slab->chunkSize,
-							   slab->fullChunkSize -
-							   (slab->chunkSize + Slab_CHUNKHDRSZ));
-#endif
-
-#ifdef RANDOMIZE_ALLOCATED_MEMORY
-	/* fill the allocated space with junk */
-	randomize_mem((char *) MemoryChunkGetPointer(chunk), size);
-#endif
-
-	/* Disallow access to the chunk header. */
-	VALGRIND_MAKE_MEM_NOACCESS(chunk, Slab_CHUNKHDRSZ);
-
-	return MemoryChunkGetPointer(chunk);
+	return SlabAllocSetupNewChunk(context, block, chunk, size);
 }
 
 /*
@@ -690,7 +748,7 @@ SlabFree(void *pointer)
  * realloc is usually used to enlarge the chunk.
  */
 void *
-SlabRealloc(void *pointer, Size size)
+SlabRealloc(void *pointer, Size size, int flags)
 {
 	MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
 	SlabBlock  *block;

data/ext/pg_query/src_common_encnames.c

@@ -9,7 +9,7 @@
  * encnames.c
  *	  Encoding names and routines for working with them.
  *
- * Portions Copyright (c) 2001-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 2001-2024, PostgreSQL Global Development Group
  *
  * IDENTIFICATION
  *	  src/common/encnames.c
@@ -46,7 +46,6 @@ typedef struct pg_encname
 
 /* ----------
  * These are "official" encoding names.
- * XXX must be sorted by the same order as enum pg_enc (in mb/pg_wchar.h)
  * ----------
  */
 #ifndef WIN32
@@ -57,48 +56,48 @@ typedef struct pg_encname
 
 const pg_enc2name pg_enc2name_tbl[] =
 {
-	DEF_ENC2NAME(SQL_ASCII, 0),
-	DEF_ENC2NAME(EUC_JP, 20932),
-	DEF_ENC2NAME(EUC_CN, 20936),
-	DEF_ENC2NAME(EUC_KR, 51949),
-	DEF_ENC2NAME(EUC_TW, 0),
-	DEF_ENC2NAME(EUC_JIS_2004, 20932),
-	DEF_ENC2NAME(UTF8, 65001),
-	DEF_ENC2NAME(MULE_INTERNAL, 0),
-	DEF_ENC2NAME(LATIN1, 28591),
-	DEF_ENC2NAME(LATIN2, 28592),
-	DEF_ENC2NAME(LATIN3, 28593),
-	DEF_ENC2NAME(LATIN4, 28594),
-	DEF_ENC2NAME(LATIN5, 28599),
-	DEF_ENC2NAME(LATIN6, 0),
-	DEF_ENC2NAME(LATIN7, 0),
-	DEF_ENC2NAME(LATIN8, 0),
-	DEF_ENC2NAME(LATIN9, 28605),
-	DEF_ENC2NAME(LATIN10, 0),
-	DEF_ENC2NAME(WIN1256, 1256),
-	DEF_ENC2NAME(WIN1258, 1258),
-	DEF_ENC2NAME(WIN866, 866),
-	DEF_ENC2NAME(WIN874, 874),
-	DEF_ENC2NAME(KOI8R, 20866),
-	DEF_ENC2NAME(WIN1251, 1251),
-	DEF_ENC2NAME(WIN1252, 1252),
-	DEF_ENC2NAME(ISO_8859_5, 28595),
-	DEF_ENC2NAME(ISO_8859_6, 28596),
-	DEF_ENC2NAME(ISO_8859_7, 28597),
-	DEF_ENC2NAME(ISO_8859_8, 28598),
-	DEF_ENC2NAME(WIN1250, 1250),
-	DEF_ENC2NAME(WIN1253, 1253),
-	DEF_ENC2NAME(WIN1254, 1254),
-	DEF_ENC2NAME(WIN1255, 1255),
-	DEF_ENC2NAME(WIN1257, 1257),
-	DEF_ENC2NAME(KOI8U, 21866),
-	DEF_ENC2NAME(SJIS, 932),
-	DEF_ENC2NAME(BIG5, 950),
-	DEF_ENC2NAME(GBK, 936),
-	DEF_ENC2NAME(UHC, 949),
-	DEF_ENC2NAME(GB18030, 54936),
-	DEF_ENC2NAME(JOHAB, 0),
-	DEF_ENC2NAME(SHIFT_JIS_2004, 932)
+	[PG_SQL_ASCII] = DEF_ENC2NAME(SQL_ASCII, 0),
+	[PG_EUC_JP] = DEF_ENC2NAME(EUC_JP, 20932),
+	[PG_EUC_CN] = DEF_ENC2NAME(EUC_CN, 20936),
+	[PG_EUC_KR] = DEF_ENC2NAME(EUC_KR, 51949),
+	[PG_EUC_TW] = DEF_ENC2NAME(EUC_TW, 0),
+	[PG_EUC_JIS_2004] = DEF_ENC2NAME(EUC_JIS_2004, 20932),
+	[PG_UTF8] = DEF_ENC2NAME(UTF8, 65001),
+	[PG_MULE_INTERNAL] = DEF_ENC2NAME(MULE_INTERNAL, 0),
+	[PG_LATIN1] = DEF_ENC2NAME(LATIN1, 28591),
+	[PG_LATIN2] = DEF_ENC2NAME(LATIN2, 28592),
+	[PG_LATIN3] = DEF_ENC2NAME(LATIN3, 28593),
+	[PG_LATIN4] = DEF_ENC2NAME(LATIN4, 28594),
+	[PG_LATIN5] = DEF_ENC2NAME(LATIN5, 28599),
+	[PG_LATIN6] = DEF_ENC2NAME(LATIN6, 0),
+	[PG_LATIN7] = DEF_ENC2NAME(LATIN7, 0),
+	[PG_LATIN8] = DEF_ENC2NAME(LATIN8, 0),
+	[PG_LATIN9] = DEF_ENC2NAME(LATIN9, 28605),
+	[PG_LATIN10] = DEF_ENC2NAME(LATIN10, 0),
+	[PG_WIN1256] = DEF_ENC2NAME(WIN1256, 1256),
+	[PG_WIN1258] = DEF_ENC2NAME(WIN1258, 1258),
+	[PG_WIN866] = DEF_ENC2NAME(WIN866, 866),
+	[PG_WIN874] = DEF_ENC2NAME(WIN874, 874),
+	[PG_KOI8R] = DEF_ENC2NAME(KOI8R, 20866),
+	[PG_WIN1251] = DEF_ENC2NAME(WIN1251, 1251),
+	[PG_WIN1252] = DEF_ENC2NAME(WIN1252, 1252),
+	[PG_ISO_8859_5] = DEF_ENC2NAME(ISO_8859_5, 28595),
+	[PG_ISO_8859_6] = DEF_ENC2NAME(ISO_8859_6, 28596),
+	[PG_ISO_8859_7] = DEF_ENC2NAME(ISO_8859_7, 28597),
+	[PG_ISO_8859_8] = DEF_ENC2NAME(ISO_8859_8, 28598),
+	[PG_WIN1250] = DEF_ENC2NAME(WIN1250, 1250),
+	[PG_WIN1253] = DEF_ENC2NAME(WIN1253, 1253),
+	[PG_WIN1254] = DEF_ENC2NAME(WIN1254, 1254),
+	[PG_WIN1255] = DEF_ENC2NAME(WIN1255, 1255),
+	[PG_WIN1257] = DEF_ENC2NAME(WIN1257, 1257),
+	[PG_KOI8U] = DEF_ENC2NAME(KOI8U, 21866),
+	[PG_SJIS] = DEF_ENC2NAME(SJIS, 932),
+	[PG_BIG5] = DEF_ENC2NAME(BIG5, 950),
+	[PG_GBK] = DEF_ENC2NAME(GBK, 936),
+	[PG_UHC] = DEF_ENC2NAME(UHC, 949),
+	[PG_GB18030] = DEF_ENC2NAME(GB18030, 54936),
+	[PG_JOHAB] = DEF_ENC2NAME(JOHAB, 0),
+	[PG_SHIFT_JIS_2004] = DEF_ENC2NAME(SHIFT_JIS_2004, 932),
 };
 
 /* ----------

data/ext/pg_query/src_common_hashfn.c

@@ -11,7 +11,7 @@
  *		hashtables
  *
  *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  *

data/ext/pg_query/src_common_keywords.c

@@ -10,7 +10,7 @@
  *	  PostgreSQL's list of SQL keywords
  *
  *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  *