From 51c43a5dbd86ad8461544e54c00bd9f487abfacd Mon Sep 17 00:00:00 2001 From: Michael Paquier Date: Mon, 17 Aug 2026 16:15:45 +0900 Subject: [PATCH] Use safer allocation routines in more places of the tree This is part of a more global effort to modernize the code tree with safer allocation functions, which offer more protection in terms of: - stronger type safety guarantees - size overflow checks, particulary for arrays. This set of updates includes allocation changes based on palloc_object(), palloc_array() and repalloc_array(). This work is similar to 1b105f9472bd, expanding more the new APIs in the tree in an incremental fashion. Author: Tristan Partin Discussion: https://postgr.es/m/DKJB5887LGX9.359DV1UMZ1URK@partin.io --- contrib/btree_gist/btree_bool.c | 2 +- contrib/btree_gist/btree_cash.c | 2 +- contrib/btree_gist/btree_date.c | 2 +- contrib/btree_gist/btree_enum.c | 2 +- contrib/btree_gist/btree_float4.c | 2 +- contrib/btree_gist/btree_float8.c | 2 +- contrib/btree_gist/btree_inet.c | 2 +- contrib/btree_gist/btree_int2.c | 2 +- contrib/btree_gist/btree_int4.c | 2 +- contrib/btree_gist/btree_int8.c | 2 +- contrib/btree_gist/btree_interval.c | 2 +- contrib/btree_gist/btree_macaddr.c | 2 +- contrib/btree_gist/btree_macaddr8.c | 2 +- contrib/btree_gist/btree_oid.c | 2 +- contrib/btree_gist/btree_time.c | 2 +- contrib/btree_gist/btree_ts.c | 2 +- contrib/btree_gist/btree_utils_num.c | 12 ++--- contrib/btree_gist/btree_uuid.c | 2 +- contrib/dict_xsyn/dict_xsyn.c | 2 +- contrib/file_fdw/file_fdw.c | 4 +- contrib/hstore/hstore_gin.c | 6 +-- contrib/hstore/hstore_io.c | 18 +++---- contrib/hstore/hstore_op.c | 18 +++---- contrib/pageinspect/btreefuncs.c | 2 +- contrib/pageinspect/ginfuncs.c | 2 +- contrib/pg_logicalinspect/pg_logicalinspect.c | 4 +- contrib/pg_plan_advice/pgpa_scan.c | 2 +- contrib/pg_stash_advice/stashpersist.c | 5 +- .../pg_stat_statements/pg_stat_statements.c | 2 +- contrib/pg_trgm/trgm_gist.c | 2 +- contrib/pg_trgm/trgm_regexp.c | 5 +- contrib/pg_visibility/pg_visibility.c | 5 +- contrib/pgrowlocks/pgrowlocks.c | 8 +-- contrib/postgres_fdw/connection.c | 4 +- contrib/postgres_fdw/postgres_fdw.c | 13 +++-- contrib/seg/seg.c | 7 ++- contrib/tablefunc/tablefunc.c | 8 +-- contrib/xml2/xpath.c | 4 +- contrib/xml2/xslt_proc.c | 5 +- doc/src/sgml/xfunc.sgml | 8 +-- src/backend/access/brin/brin_minmax_multi.c | 4 +- src/backend/access/common/printtup.c | 3 +- src/backend/access/common/reloptions.c | 7 ++- src/backend/access/common/tupdesc.c | 6 +-- src/backend/access/gin/gindatapage.c | 4 +- src/backend/access/gin/ginget.c | 8 +-- src/backend/access/gin/gininsert.c | 6 +-- src/backend/access/gin/ginpostinglist.c | 8 +-- src/backend/access/gin/ginscan.c | 10 ++-- src/backend/access/gist/gistbuildbuffers.c | 14 ++---- src/backend/access/gist/gistget.c | 8 +-- src/backend/access/gist/gistproc.c | 10 ++-- src/backend/access/gist/gistscan.c | 8 +-- src/backend/access/gist/gistsplit.c | 12 ++--- src/backend/access/gist/gistxlog.c | 2 +- src/backend/access/heap/heapam.c | 4 +- src/backend/access/heap/vacuumlazy.c | 3 +- src/backend/access/nbtree/nbtinsert.c | 10 ++-- src/backend/access/nbtree/nbtpage.c | 5 +- src/backend/access/nbtree/nbtpreprocesskeys.c | 20 ++++---- src/backend/access/nbtree/nbtree.c | 2 +- src/backend/access/tablesample/bernoulli.c | 2 +- src/backend/access/transam/multixact.c | 2 +- src/backend/access/transam/twophase.c | 4 +- src/backend/access/transam/xact.c | 5 +- src/backend/access/transam/xloginsert.c | 5 +- src/backend/backup/basebackup_incremental.c | 2 +- src/backend/catalog/aclchk.c | 2 +- src/backend/catalog/dependency.c | 21 +++----- src/backend/catalog/heap.c | 2 +- src/backend/catalog/pg_constraint.c | 6 +-- src/backend/catalog/pg_inherits.c | 4 +- src/backend/catalog/pg_shdepend.c | 7 +-- src/backend/commands/alter.c | 18 +++---- src/backend/commands/analyze.c | 49 +++++++++---------- src/backend/commands/async.c | 2 +- src/backend/commands/collationcmds.c | 5 +- src/backend/commands/copyfrom.c | 18 +++---- src/backend/commands/copyfromparse.c | 4 +- src/backend/commands/copyto.c | 4 +- src/backend/commands/dbcommands.c | 2 +- src/backend/commands/explain.c | 7 ++- src/backend/commands/explain_dr.c | 2 +- src/backend/commands/explain_state.c | 10 ++-- src/backend/commands/extension.c | 2 +- src/backend/commands/functioncmds.c | 14 +++--- src/backend/commands/policy.c | 2 +- src/backend/commands/subscriptioncmds.c | 6 +-- src/backend/commands/tablecmds.c | 7 ++- src/backend/commands/tablespace.c | 2 +- src/backend/commands/trigger.c | 28 +++++------ src/backend/commands/vacuum.c | 2 +- src/backend/executor/execExpr.c | 5 +- src/backend/executor/execExprInterp.c | 12 ++--- src/backend/executor/execGrouping.c | 6 +-- src/backend/executor/execJunk.c | 4 +- src/backend/executor/execParallel.c | 6 +-- src/backend/executor/execPartition.c | 22 ++++----- src/backend/executor/execSRF.c | 4 +- src/backend/executor/execTuples.c | 10 ++-- src/backend/executor/execUtils.c | 7 ++- src/backend/executor/functions.c | 2 +- src/backend/executor/nodeAgg.c | 24 ++++----- src/backend/executor/nodeAppend.c | 9 ++-- src/backend/executor/nodeBitmapAnd.c | 2 +- src/backend/executor/nodeBitmapOr.c | 2 +- src/backend/executor/nodeGather.c | 3 +- src/backend/executor/nodeGatherMerge.c | 9 ++-- src/backend/executor/nodeIncrementalSort.c | 4 +- src/backend/executor/nodeIndexscan.c | 44 +++++++---------- src/backend/executor/nodeMemoize.c | 6 +-- src/backend/executor/nodeMergejoin.c | 2 +- src/backend/executor/nodeModifyTable.c | 2 +- src/backend/executor/nodeSetOp.c | 3 +- src/backend/executor/nodeSubplan.c | 14 +++--- src/backend/executor/nodeTidscan.c | 15 ++---- src/backend/executor/nodeValuesscan.c | 6 +-- src/backend/executor/spi.c | 4 +- src/backend/jit/llvm/llvmjit_expr.c | 3 +- src/backend/lib/bipartite_match.c | 8 +-- src/backend/lib/knapsack.c | 4 +- src/backend/libpq/be-secure-common.c | 2 +- src/backend/libpq/be-secure-openssl.c | 2 +- src/backend/libpq/hba.c | 4 +- src/backend/nodes/list.c | 3 +- src/backend/nodes/queryjumblefuncs.c | 10 ++-- src/backend/nodes/readfuncs.c | 2 +- src/backend/optimizer/path/allpaths.c | 8 +-- src/backend/optimizer/path/equivclass.c | 3 +- src/backend/optimizer/path/pathkeys.c | 4 +- src/backend/optimizer/plan/analyzejoins.c | 2 +- src/backend/optimizer/plan/createplan.c | 46 ++++++++--------- src/backend/optimizer/plan/initsplan.c | 2 +- src/backend/optimizer/plan/planner.c | 22 ++++----- src/backend/optimizer/plan/setrefs.c | 6 +-- src/backend/optimizer/prep/prepjointree.c | 15 ++---- src/backend/optimizer/util/appendinfo.c | 3 +- src/backend/optimizer/util/clauses.c | 4 +- src/backend/optimizer/util/extendplan.c | 3 +- src/backend/optimizer/util/inherit.c | 3 +- src/backend/optimizer/util/plancat.c | 6 +-- src/backend/optimizer/util/tlist.c | 11 ++--- src/backend/parser/analyze.c | 5 +- src/backend/parser/parse_clause.c | 5 +- src/backend/parser/parse_cte.c | 2 +- src/backend/parser/parse_relation.c | 6 +-- src/backend/partitioning/partbounds.c | 24 ++++----- src/backend/partitioning/partdesc.c | 10 ++-- src/backend/partitioning/partprune.c | 11 ++--- src/backend/postmaster/autovacuum.c | 2 +- src/backend/postmaster/checkpointer.c | 2 +- src/backend/postmaster/datachecksum_state.c | 2 +- src/backend/postmaster/pmchild.c | 2 +- src/backend/postmaster/postmaster.c | 2 +- src/backend/replication/pgoutput/pgoutput.c | 2 +- src/backend/rewrite/rewriteHandler.c | 4 +- src/backend/statistics/dependencies.c | 5 +- src/backend/statistics/extended_stats.c | 10 ++-- src/backend/statistics/mcv.c | 4 +- src/backend/statistics/mvdistinct.c | 3 +- src/backend/storage/buffer/bufmgr.c | 2 +- src/backend/storage/ipc/shmem.c | 2 +- src/backend/storage/lmgr/deadlock.c | 18 +++---- src/backend/storage/lmgr/lock.c | 22 +++------ src/backend/storage/lmgr/lwlock.c | 2 +- src/backend/storage/smgr/md.c | 4 +- src/backend/tcop/fastpath.c | 2 +- src/backend/tsearch/dict_thesaurus.c | 6 +-- src/backend/tsearch/spell.c | 18 +++---- src/backend/tsearch/ts_parse.c | 6 +-- src/backend/tsearch/wparser.c | 2 +- src/backend/tsearch/wparser_def.c | 4 +- src/backend/utils/activity/pgstat_xact.c | 3 +- src/backend/utils/adt/acl.c | 2 +- src/backend/utils/adt/array_typanalyze.c | 4 +- src/backend/utils/adt/array_userfuncs.c | 12 ++--- src/backend/utils/adt/arrayfuncs.c | 40 +++++++-------- src/backend/utils/adt/arrayutils.c | 2 +- src/backend/utils/adt/enum.c | 4 +- src/backend/utils/adt/jsonb_util.c | 8 +-- src/backend/utils/adt/jsonfuncs.c | 13 +++-- src/backend/utils/adt/levenshtein.c | 2 +- src/backend/utils/adt/like_support.c | 4 +- src/backend/utils/adt/lockfuncs.c | 6 +-- src/backend/utils/adt/multirangetypes.c | 13 +++-- src/backend/utils/adt/name.c | 2 +- src/backend/utils/adt/numeric.c | 10 ++-- src/backend/utils/adt/oracle_compat.c | 8 +-- src/backend/utils/adt/orderedsetaggs.c | 20 ++++---- src/backend/utils/adt/pg_ndistinct.c | 2 +- src/backend/utils/adt/rangetypes_typanalyze.c | 4 +- src/backend/utils/adt/regexp.c | 3 +- src/backend/utils/adt/rowtypes.c | 32 ++++++------ src/backend/utils/adt/ruleutils.c | 25 +++++----- src/backend/utils/adt/selfuncs.c | 4 +- src/backend/utils/adt/tsquery_rewrite.c | 2 +- src/backend/utils/adt/tsrank.c | 2 +- src/backend/utils/adt/tsvector.c | 6 +-- src/backend/utils/adt/tsvector_op.c | 9 ++-- src/backend/utils/adt/xml.c | 4 +- src/backend/utils/cache/catcache.c | 2 +- src/backend/utils/cache/inval.c | 7 +-- src/backend/utils/cache/lsyscache.c | 2 +- src/backend/utils/cache/relcache.c | 19 +++---- src/backend/utils/cache/typcache.c | 11 ++--- src/backend/utils/misc/conffiles.c | 3 +- src/backend/utils/misc/tzparser.c | 2 +- src/backend/utils/sort/logtape.c | 8 ++- src/backend/utils/sort/tuplesort.c | 8 +-- src/backend/utils/sort/tuplesortvariants.c | 14 ++---- src/backend/utils/sort/tuplestore.c | 8 ++- src/backend/utils/time/combocid.c | 3 +- src/backend/utils/time/snapmgr.c | 4 +- src/common/blkreftable.c | 14 ++---- src/common/rmtree.c | 3 +- src/include/lib/simplehash.h | 2 +- src/pl/plpgsql/src/pl_comp.c | 2 +- src/pl/plpgsql/src/pl_gram.y | 2 +- src/pl/plpython/plpy_cursorobject.c | 4 +- src/pl/plpython/plpy_exec.c | 6 +-- src/pl/plpython/plpy_procedure.c | 4 +- src/pl/plpython/plpy_spi.c | 4 +- src/test/modules/plsample/plsample.c | 2 +- src/test/modules/test_aio/test_aio.c | 10 ++-- .../modules/test_binaryheap/test_binaryheap.c | 2 +- .../modules/test_integerset/test_integerset.c | 2 +- .../modules/test_radixtree/test_radixtree.c | 2 +- src/test/modules/test_rbtree/test_rbtree.c | 8 +-- src/test/modules/test_regex/test_regex.c | 8 ++- .../test_resowner/test_resowner_basic.c | 4 +- .../test_resowner/test_resowner_many.c | 4 +- .../modules/test_saslprep/test_saslprep.c | 2 +- .../modules/test_tidstore/test_tidstore.c | 12 ++--- src/test/regress/regress.c | 14 +++--- 234 files changed, 728 insertions(+), 892 deletions(-) diff --git a/contrib/btree_gist/btree_bool.c b/contrib/btree_gist/btree_bool.c index 8a79c7a0db7..febd1ba1f34 100644 --- a/contrib/btree_gist/btree_bool.c +++ b/contrib/btree_gist/btree_bool.c @@ -129,7 +129,7 @@ Datum gbt_bool_union(PG_FUNCTION_ARGS) { GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc(sizeof(boolKEY)); + void *out = palloc_object(boolKEY); *(int *) PG_GETARG_POINTER(1) = sizeof(boolKEY); PG_RETURN_POINTER(gbt_num_union(out, entryvec, &tinfo, fcinfo->flinfo)); diff --git a/contrib/btree_gist/btree_cash.c b/contrib/btree_gist/btree_cash.c index e5427e53180..f5ecce2c68c 100644 --- a/contrib/btree_gist/btree_cash.c +++ b/contrib/btree_gist/btree_cash.c @@ -179,7 +179,7 @@ Datum gbt_cash_union(PG_FUNCTION_ARGS) { GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc(sizeof(cashKEY)); + void *out = palloc_object(cashKEY); *(int *) PG_GETARG_POINTER(1) = sizeof(cashKEY); PG_RETURN_POINTER(gbt_num_union(out, entryvec, &tinfo, fcinfo->flinfo)); diff --git a/contrib/btree_gist/btree_date.c b/contrib/btree_gist/btree_date.c index 92c725664dd..1824a3d0e6e 100644 --- a/contrib/btree_gist/btree_date.c +++ b/contrib/btree_gist/btree_date.c @@ -194,7 +194,7 @@ Datum gbt_date_union(PG_FUNCTION_ARGS) { GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc(sizeof(dateKEY)); + void *out = palloc_object(dateKEY); *(int *) PG_GETARG_POINTER(1) = sizeof(dateKEY); PG_RETURN_POINTER(gbt_num_union(out, entryvec, &tinfo, fcinfo->flinfo)); diff --git a/contrib/btree_gist/btree_enum.c b/contrib/btree_gist/btree_enum.c index e95ac926c93..386c92b6e9e 100644 --- a/contrib/btree_gist/btree_enum.c +++ b/contrib/btree_gist/btree_enum.c @@ -148,7 +148,7 @@ Datum gbt_enum_union(PG_FUNCTION_ARGS) { GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc(sizeof(oidKEY)); + void *out = palloc_object(oidKEY); *(int *) PG_GETARG_POINTER(1) = sizeof(oidKEY); PG_RETURN_POINTER(gbt_num_union(out, entryvec, &tinfo, fcinfo->flinfo)); diff --git a/contrib/btree_gist/btree_float4.c b/contrib/btree_gist/btree_float4.c index df0a1908db6..a8121ba9961 100644 --- a/contrib/btree_gist/btree_float4.c +++ b/contrib/btree_gist/btree_float4.c @@ -198,7 +198,7 @@ Datum gbt_float4_union(PG_FUNCTION_ARGS) { GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc(sizeof(float4KEY)); + void *out = palloc_object(float4KEY); *(int *) PG_GETARG_POINTER(1) = sizeof(float4KEY); PG_RETURN_POINTER(gbt_num_union(out, entryvec, &tinfo, fcinfo->flinfo)); diff --git a/contrib/btree_gist/btree_float8.c b/contrib/btree_gist/btree_float8.c index 41db58e2602..478324ce4f3 100644 --- a/contrib/btree_gist/btree_float8.c +++ b/contrib/btree_gist/btree_float8.c @@ -200,7 +200,7 @@ Datum gbt_float8_union(PG_FUNCTION_ARGS) { GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc(sizeof(float8KEY)); + void *out = palloc_object(float8KEY); *(int *) PG_GETARG_POINTER(1) = sizeof(float8KEY); PG_RETURN_POINTER(gbt_num_union(out, entryvec, &tinfo, fcinfo->flinfo)); diff --git a/contrib/btree_gist/btree_inet.c b/contrib/btree_gist/btree_inet.c index 146f3cb6494..4584b32c150 100644 --- a/contrib/btree_gist/btree_inet.c +++ b/contrib/btree_gist/btree_inet.c @@ -146,7 +146,7 @@ Datum gbt_inet_union(PG_FUNCTION_ARGS) { GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc(sizeof(inetKEY)); + void *out = palloc_object(inetKEY); *(int *) PG_GETARG_POINTER(1) = sizeof(inetKEY); PG_RETURN_POINTER(gbt_num_union(out, entryvec, &tinfo, fcinfo->flinfo)); diff --git a/contrib/btree_gist/btree_int2.c b/contrib/btree_gist/btree_int2.c index 4d03fb2aa36..6d5ca44fe8f 100644 --- a/contrib/btree_gist/btree_int2.c +++ b/contrib/btree_gist/btree_int2.c @@ -178,7 +178,7 @@ Datum gbt_int2_union(PG_FUNCTION_ARGS) { GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc(sizeof(int16KEY)); + void *out = palloc_object(int16KEY); *(int *) PG_GETARG_POINTER(1) = sizeof(int16KEY); PG_RETURN_POINTER(gbt_num_union(out, entryvec, &tinfo, fcinfo->flinfo)); diff --git a/contrib/btree_gist/btree_int4.c b/contrib/btree_gist/btree_int4.c index 2db4baa0926..8e0c010c633 100644 --- a/contrib/btree_gist/btree_int4.c +++ b/contrib/btree_gist/btree_int4.c @@ -176,7 +176,7 @@ Datum gbt_int4_union(PG_FUNCTION_ARGS) { GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc(sizeof(int32KEY)); + void *out = palloc_object(int32KEY); *(int *) PG_GETARG_POINTER(1) = sizeof(int32KEY); PG_RETURN_POINTER(gbt_num_union(out, entryvec, &tinfo, fcinfo->flinfo)); diff --git a/contrib/btree_gist/btree_int8.c b/contrib/btree_gist/btree_int8.c index 4b2333cb315..ed55ac8dbfd 100644 --- a/contrib/btree_gist/btree_int8.c +++ b/contrib/btree_gist/btree_int8.c @@ -178,7 +178,7 @@ Datum gbt_int8_union(PG_FUNCTION_ARGS) { GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc(sizeof(int64KEY)); + void *out = palloc_object(int64KEY); *(int *) PG_GETARG_POINTER(1) = sizeof(int64KEY); PG_RETURN_POINTER(gbt_num_union(out, entryvec, &tinfo, fcinfo->flinfo)); diff --git a/contrib/btree_gist/btree_interval.c b/contrib/btree_gist/btree_interval.c index 831662d3b9d..5cc66a908cf 100644 --- a/contrib/btree_gist/btree_interval.c +++ b/contrib/btree_gist/btree_interval.c @@ -252,7 +252,7 @@ Datum gbt_intv_union(PG_FUNCTION_ARGS) { GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc(sizeof(intvKEY)); + void *out = palloc_object(intvKEY); *(int *) PG_GETARG_POINTER(1) = sizeof(intvKEY); PG_RETURN_POINTER(gbt_num_union(out, entryvec, &tinfo, fcinfo->flinfo)); diff --git a/contrib/btree_gist/btree_macaddr.c b/contrib/btree_gist/btree_macaddr.c index 97f088d7795..7ed8499adcf 100644 --- a/contrib/btree_gist/btree_macaddr.c +++ b/contrib/btree_gist/btree_macaddr.c @@ -148,7 +148,7 @@ Datum gbt_macad_union(PG_FUNCTION_ARGS) { GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc0(sizeof(macKEY)); + void *out = palloc0_object(macKEY); *(int *) PG_GETARG_POINTER(1) = sizeof(macKEY); PG_RETURN_POINTER(gbt_num_union(out, entryvec, &tinfo, fcinfo->flinfo)); diff --git a/contrib/btree_gist/btree_macaddr8.c b/contrib/btree_gist/btree_macaddr8.c index 53d10612018..b51e738f7e6 100644 --- a/contrib/btree_gist/btree_macaddr8.c +++ b/contrib/btree_gist/btree_macaddr8.c @@ -146,7 +146,7 @@ Datum gbt_macad8_union(PG_FUNCTION_ARGS) { GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc0(sizeof(mac8KEY)); + void *out = palloc0_object(mac8KEY); *(int *) PG_GETARG_POINTER(1) = sizeof(mac8KEY); PG_RETURN_POINTER(gbt_num_union(out, entryvec, &tinfo, fcinfo->flinfo)); diff --git a/contrib/btree_gist/btree_oid.c b/contrib/btree_gist/btree_oid.c index a33ceb32883..ccaa150528a 100644 --- a/contrib/btree_gist/btree_oid.c +++ b/contrib/btree_gist/btree_oid.c @@ -178,7 +178,7 @@ Datum gbt_oid_union(PG_FUNCTION_ARGS) { GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc(sizeof(oidKEY)); + void *out = palloc_object(oidKEY); *(int *) PG_GETARG_POINTER(1) = sizeof(oidKEY); PG_RETURN_POINTER(gbt_num_union(out, entryvec, &tinfo, fcinfo->flinfo)); diff --git a/contrib/btree_gist/btree_time.c b/contrib/btree_gist/btree_time.c index 9496112889d..c4f9f19c411 100644 --- a/contrib/btree_gist/btree_time.c +++ b/contrib/btree_gist/btree_time.c @@ -259,7 +259,7 @@ Datum gbt_time_union(PG_FUNCTION_ARGS) { GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc(sizeof(timeKEY)); + void *out = palloc_object(timeKEY); *(int *) PG_GETARG_POINTER(1) = sizeof(timeKEY); PG_RETURN_POINTER(gbt_num_union(out, entryvec, &tinfo, fcinfo->flinfo)); diff --git a/contrib/btree_gist/btree_ts.c b/contrib/btree_gist/btree_ts.c index 9f3a51ad728..53d63e5c852 100644 --- a/contrib/btree_gist/btree_ts.c +++ b/contrib/btree_gist/btree_ts.c @@ -329,7 +329,7 @@ Datum gbt_ts_union(PG_FUNCTION_ARGS) { GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc(sizeof(tsKEY)); + void *out = palloc_object(tsKEY); *(int *) PG_GETARG_POINTER(1) = sizeof(tsKEY); PG_RETURN_POINTER(gbt_num_union(out, entryvec, &tinfo, fcinfo->flinfo)); diff --git a/contrib/btree_gist/btree_utils_num.c b/contrib/btree_gist/btree_utils_num.c index 971485dc8eb..e1f6d0fb2e1 100644 --- a/contrib/btree_gist/btree_utils_num.c +++ b/contrib/btree_gist/btree_utils_num.c @@ -31,7 +31,7 @@ gbt_num_compress(GISTENTRY *entry, const gbtree_ninfo *tinfo) Cash ch; } v; - GBT_NUMKEY *r = (GBT_NUMKEY *) palloc0(tinfo->indexsize); + GBT_NUMKEY *r = palloc0_array(GBT_NUMKEY, tinfo->indexsize); void *leaf = NULL; switch (tinfo->t) @@ -374,12 +374,12 @@ gbt_num_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v, OffsetNumber i, maxoff = entryvec->n - 1; Nsrt *arr; - int nbytes; + int noffsets; - arr = (Nsrt *) palloc((maxoff + 1) * sizeof(Nsrt)); - nbytes = (maxoff + 2) * sizeof(OffsetNumber); - v->spl_left = (OffsetNumber *) palloc(nbytes); - v->spl_right = (OffsetNumber *) palloc(nbytes); + arr = palloc_array(Nsrt, maxoff + 1); + noffsets = maxoff + 2; + v->spl_left = palloc_array(OffsetNumber, noffsets); + v->spl_right = palloc_array(OffsetNumber, noffsets); v->spl_ldatum = PointerGetDatum(0); v->spl_rdatum = PointerGetDatum(0); v->spl_nleft = 0; diff --git a/contrib/btree_gist/btree_uuid.c b/contrib/btree_gist/btree_uuid.c index 36aaa85933c..c560158ec94 100644 --- a/contrib/btree_gist/btree_uuid.c +++ b/contrib/btree_gist/btree_uuid.c @@ -158,7 +158,7 @@ Datum gbt_uuid_union(PG_FUNCTION_ARGS) { GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc(sizeof(uuidKEY)); + void *out = palloc_object(uuidKEY); *(int *) PG_GETARG_POINTER(1) = sizeof(uuidKEY); PG_RETURN_POINTER(gbt_num_union(out, entryvec, &tinfo, fcinfo->flinfo)); diff --git a/contrib/dict_xsyn/dict_xsyn.c b/contrib/dict_xsyn/dict_xsyn.c index b4fa3b2e524..cd77a176a6c 100644 --- a/contrib/dict_xsyn/dict_xsyn.c +++ b/contrib/dict_xsyn/dict_xsyn.c @@ -235,7 +235,7 @@ dxsyn_lexize(PG_FUNCTION_ARGS) pos = value; while ((syn = find_word(pos, &end)) != NULL) { - res = repalloc(res, sizeof(TSLexeme) * (nsyns + 2)); + res = repalloc_array(res, TSLexeme, nsyns + 2); /* The first word is output only if keeporig=true */ if (pos != value || d->keeporig) diff --git a/contrib/file_fdw/file_fdw.c b/contrib/file_fdw/file_fdw.c index 33a37d832ce..7d9dc3baf74 100644 --- a/contrib/file_fdw/file_fdw.c +++ b/contrib/file_fdw/file_fdw.c @@ -1206,8 +1206,8 @@ file_acquire_sample_rows(Relation onerel, int elevel, Assert(targrows > 0); tupDesc = RelationGetDescr(onerel); - values = (Datum *) palloc(tupDesc->natts * sizeof(Datum)); - nulls = (bool *) palloc(tupDesc->natts * sizeof(bool)); + values = palloc_array(Datum, tupDesc->natts); + nulls = palloc_array(bool, tupDesc->natts); /* Fetch options of foreign table */ fileGetOptions(RelationGetRelid(onerel), &filename, &is_program, &options); diff --git a/contrib/hstore/hstore_gin.c b/contrib/hstore/hstore_gin.c index 1365539f95f..a0aa7aed7c7 100644 --- a/contrib/hstore/hstore_gin.c +++ b/contrib/hstore/hstore_gin.c @@ -53,7 +53,7 @@ gin_extract_hstore(PG_FUNCTION_ARGS) *nentries = 2 * count; if (count) - entries = (Datum *) palloc(sizeof(Datum) * 2 * count); + entries = palloc_array(Datum, 2 * count); for (i = 0; i < count; ++i) { @@ -103,7 +103,7 @@ gin_extract_hstore_query(PG_FUNCTION_ARGS) text *item; *nentries = 1; - entries = (Datum *) palloc(sizeof(Datum)); + entries = palloc_object(Datum); item = makeitem(VARDATA_ANY(query), VARSIZE_ANY_EXHDR(query), KEYFLAG); entries[0] = PointerGetDatum(item); } @@ -120,7 +120,7 @@ gin_extract_hstore_query(PG_FUNCTION_ARGS) deconstruct_array_builtin(query, TEXTOID, &key_datums, &key_nulls, &key_count); - entries = (Datum *) palloc(sizeof(Datum) * key_count); + entries = palloc_array(Datum, key_count); for (i = 0, j = 0; i < key_count; ++i) { diff --git a/contrib/hstore/hstore_io.c b/contrib/hstore/hstore_io.c index 9b72efb8674..e6152bbc1a3 100644 --- a/contrib/hstore/hstore_io.c +++ b/contrib/hstore/hstore_io.c @@ -239,7 +239,7 @@ parse_hstore(HSParser *state) if (state->pcur >= state->plen) { state->plen *= 2; - state->pairs = (Pairs *) repalloc(state->pairs, sizeof(Pairs) * state->plen); + state->pairs = repalloc_array(state->pairs, Pairs, state->plen); } if (!hstoreCheckKeyLength(state->cur - state->word, state)) return false; @@ -523,7 +523,7 @@ hstore_recv(PG_FUNCTION_ARGS) (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED), errmsg("number of pairs (%d) exceeds the maximum allowed (%d)", pcount, (int) (MaxAllocSize / sizeof(Pairs))))); - pairs = palloc(pcount * sizeof(Pairs)); + pairs = palloc_array(Pairs, pcount); for (i = 0; i < pcount; ++i) { @@ -674,7 +674,7 @@ hstore_from_arrays(PG_FUNCTION_ARGS) Assert(key_count == value_count); } - pairs = palloc(key_count * sizeof(Pairs)); + pairs = palloc_array(Pairs, key_count); for (i = 0; i < key_count; ++i) { @@ -768,7 +768,7 @@ hstore_from_array(PG_FUNCTION_ARGS) errmsg("number of pairs (%d) exceeds the maximum allowed (%d)", count, (int) (MaxAllocSize / sizeof(Pairs))))); - pairs = palloc(count * sizeof(Pairs)); + pairs = palloc_array(Pairs, count); for (i = 0; i < count; ++i) { @@ -909,7 +909,7 @@ hstore_from_record(PG_FUNCTION_ARGS) } Assert(ncolumns <= MaxTupleAttributeNumber); /* thus, no overflow */ - pairs = palloc(ncolumns * sizeof(Pairs)); + pairs = palloc_array(Pairs, ncolumns); if (rec) { @@ -919,8 +919,8 @@ hstore_from_record(PG_FUNCTION_ARGS) tuple.t_tableOid = InvalidOid; tuple.t_data = rec; - values = (Datum *) palloc(ncolumns * sizeof(Datum)); - nulls = (bool *) palloc(ncolumns * sizeof(bool)); + values = palloc_array(Datum, ncolumns); + nulls = palloc_array(bool, ncolumns); /* Break down the tuple into fields */ heap_deform_tuple(&tuple, tupdesc, values, nulls); @@ -1102,8 +1102,8 @@ hstore_populate_record(PG_FUNCTION_ARGS) my_extra->ncolumns = ncolumns; } - values = (Datum *) palloc(ncolumns * sizeof(Datum)); - nulls = (bool *) palloc(ncolumns * sizeof(bool)); + values = palloc_array(Datum, ncolumns); + nulls = palloc_array(bool, ncolumns); if (rec) { diff --git a/contrib/hstore/hstore_op.c b/contrib/hstore/hstore_op.c index bcba75f9258..cab59700c0d 100644 --- a/contrib/hstore/hstore_op.c +++ b/contrib/hstore/hstore_op.c @@ -101,7 +101,7 @@ hstoreArrayToPairs(ArrayType *a, int *npairs) errmsg("number of pairs (%d) exceeds the maximum allowed (%d)", key_count, (int) (MaxAllocSize / sizeof(Pairs))))); - key_pairs = palloc(sizeof(Pairs) * key_count); + key_pairs = palloc_array(Pairs, key_count); for (i = 0, j = 0; i < key_count; i++) { @@ -588,8 +588,8 @@ hstore_slice_to_array(PG_FUNCTION_ARGS) PG_RETURN_POINTER(aout); } - out_datums = palloc(sizeof(Datum) * key_count); - out_nulls = palloc(sizeof(bool) * key_count); + out_datums = palloc_array(Datum, key_count); + out_nulls = palloc_array(bool, key_count); for (i = 0; i < key_count; ++i) { @@ -649,7 +649,7 @@ hstore_slice_to_hstore(PG_FUNCTION_ARGS) } /* hstoreArrayToPairs() checked overflow */ - out_pairs = palloc(sizeof(Pairs) * nkeys); + out_pairs = palloc_array(Pairs, nkeys); bufsiz = 0; /* @@ -705,7 +705,7 @@ hstore_akeys(PG_FUNCTION_ARGS) PG_RETURN_POINTER(a); } - d = (Datum *) palloc(sizeof(Datum) * count); + d = palloc_array(Datum, count); for (i = 0; i < count; ++i) { @@ -741,8 +741,8 @@ hstore_avals(PG_FUNCTION_ARGS) PG_RETURN_POINTER(a); } - d = (Datum *) palloc(sizeof(Datum) * count); - nulls = (bool *) palloc(sizeof(bool) * count); + d = palloc_array(Datum, count); + nulls = palloc_array(bool, count); for (i = 0; i < count; ++i) { @@ -786,8 +786,8 @@ hstore_to_array_internal(HStore *hs, int ndims) return construct_empty_array(TEXTOID); out_size[0] = count * 2 / ndims; - out_datums = palloc(sizeof(Datum) * count * 2); - out_nulls = palloc(sizeof(bool) * count * 2); + out_datums = palloc_array(Datum, count * 2); + out_nulls = palloc_array(bool, count * 2); for (i = 0; i < count; ++i) { diff --git a/contrib/pageinspect/btreefuncs.c b/contrib/pageinspect/btreefuncs.c index 3381e7cc2a7..9917663593b 100644 --- a/contrib/pageinspect/btreefuncs.c +++ b/contrib/pageinspect/btreefuncs.c @@ -597,7 +597,7 @@ bt_page_print_tuples(ua_page_items *uargs) tids = BTreeTupleGetPosting(itup); nposting = BTreeTupleGetNPosting(itup); - tids_datum = (Datum *) palloc(nposting * sizeof(Datum)); + tids_datum = palloc_array(Datum, nposting); for (int i = 0; i < nposting; i++) tids_datum[i] = ItemPointerGetDatum(&tids[i]); values[j++] = PointerGetDatum(construct_array_builtin(tids_datum, nposting, TIDOID)); diff --git a/contrib/pageinspect/ginfuncs.c b/contrib/pageinspect/ginfuncs.c index e4461db7f0a..058ad52b671 100644 --- a/contrib/pageinspect/ginfuncs.c +++ b/contrib/pageinspect/ginfuncs.c @@ -262,7 +262,7 @@ gin_leafpage_items(PG_FUNCTION_ARGS) /* build an array of decoded item pointers */ tids = ginPostingListDecode(cur, &ndecoded); - tids_datum = (Datum *) palloc(ndecoded * sizeof(Datum)); + tids_datum = palloc_array(Datum, ndecoded); for (i = 0; i < ndecoded; i++) tids_datum[i] = ItemPointerGetDatum(&tids[i]); values[2] = PointerGetDatum(construct_array_builtin(tids_datum, ndecoded, TIDOID)); diff --git a/contrib/pg_logicalinspect/pg_logicalinspect.c b/contrib/pg_logicalinspect/pg_logicalinspect.c index 20b63ed4b8e..ee6c141e5bc 100644 --- a/contrib/pg_logicalinspect/pg_logicalinspect.c +++ b/contrib/pg_logicalinspect/pg_logicalinspect.c @@ -168,7 +168,7 @@ pg_get_logical_snapshot_info(PG_FUNCTION_ARGS) { Datum *arrayelems; - arrayelems = (Datum *) palloc(ondisk.builder.committed.xcnt * sizeof(Datum)); + arrayelems = palloc_array(Datum, ondisk.builder.committed.xcnt); for (size_t j = 0; j < ondisk.builder.committed.xcnt; j++) arrayelems[j] = TransactionIdGetDatum(ondisk.builder.committed.xip[j]); @@ -185,7 +185,7 @@ pg_get_logical_snapshot_info(PG_FUNCTION_ARGS) { Datum *arrayelems; - arrayelems = (Datum *) palloc(ondisk.builder.catchange.xcnt * sizeof(Datum)); + arrayelems = palloc_array(Datum, ondisk.builder.catchange.xcnt); for (size_t j = 0; j < ondisk.builder.catchange.xcnt; j++) arrayelems[j] = TransactionIdGetDatum(ondisk.builder.catchange.xip[j]); diff --git a/contrib/pg_plan_advice/pgpa_scan.c b/contrib/pg_plan_advice/pgpa_scan.c index 4da77936216..1d8894e5440 100644 --- a/contrib/pg_plan_advice/pgpa_scan.c +++ b/contrib/pg_plan_advice/pgpa_scan.c @@ -245,7 +245,7 @@ pgpa_make_scan(pgpa_plan_walker_context *walker, Plan *plan, pgpa_scan *scan; /* Create the scan object. */ - scan = palloc(sizeof(pgpa_scan)); + scan = palloc_object(pgpa_scan); scan->plan = plan; scan->strategy = strategy; scan->relids = relids; diff --git a/contrib/pg_stash_advice/stashpersist.c b/contrib/pg_stash_advice/stashpersist.c index 5bdf4bddaae..ccdd13872b5 100644 --- a/contrib/pg_stash_advice/stashpersist.c +++ b/contrib/pg_stash_advice/stashpersist.c @@ -319,7 +319,7 @@ pgsa_read_from_disk(void) /* Initial memory allocations. */ saved_stashes = pgsa_saved_stash_table_create(tmpcxt, 64, NULL); - entries = palloc(max_entries * sizeof(pgsa_saved_entry)); + entries = palloc_array(pgsa_saved_entry, max_entries); /* * For memory and CPU efficiency, we parse the file in place. The end of @@ -454,8 +454,7 @@ pgsa_read_from_disk(void) if (num_entries >= max_entries) { max_entries *= 2; - entries = repalloc(entries, - max_entries * sizeof(pgsa_saved_entry)); + entries = repalloc_array(entries, pgsa_saved_entry, max_entries); } entries[num_entries].stash_name = stash_name; entries[num_entries].queryId = queryId; diff --git a/contrib/pg_stat_statements/pg_stat_statements.c b/contrib/pg_stat_statements/pg_stat_statements.c index 8bc94ca04a8..4562222c9fc 100644 --- a/contrib/pg_stat_statements/pg_stat_statements.c +++ b/contrib/pg_stat_statements/pg_stat_statements.c @@ -2158,7 +2158,7 @@ entry_dealloc(void) * cur_median_usage includes the entries we're about to zap. */ - entries = palloc(hash_get_num_entries(pgss_hash) * sizeof(pgssEntry *)); + entries = palloc_array(pgssEntry *, hash_get_num_entries(pgss_hash)); i = 0; tottextlen = 0; diff --git a/contrib/pg_trgm/trgm_gist.c b/contrib/pg_trgm/trgm_gist.c index dad821def95..42d0b7a5d65 100644 --- a/contrib/pg_trgm/trgm_gist.c +++ b/contrib/pg_trgm/trgm_gist.c @@ -424,7 +424,7 @@ gtrgm_consistent(PG_FUNCTION_ARGS) * So we can apply trigramsMatchGraph despite uncertainty, * and that usefully improves the quality of the search. */ - check = (bool *) palloc(len * sizeof(bool)); + check = palloc_array(bool, len); for (k = 0; k < len; k++) { CPTRGM(&tmp, ptr + k); diff --git a/contrib/pg_trgm/trgm_regexp.c b/contrib/pg_trgm/trgm_regexp.c index b4eaeec6090..b3eca178c5a 100644 --- a/contrib/pg_trgm/trgm_regexp.c +++ b/contrib/pg_trgm/trgm_regexp.c @@ -728,7 +728,7 @@ RE_compile(regex_t *regex, text *text_re, int cflags, Oid collation) char errMsg[100]; /* Convert pattern string to wide characters */ - pattern = (pg_wchar *) palloc((text_re_len + 1) * sizeof(pg_wchar)); + pattern = palloc_array(pg_wchar, text_re_len + 1); pattern_len = pg_mb2wchar_with_len(text_re_val, pattern, text_re_len); @@ -768,8 +768,7 @@ getColorInfo(regex_t *regex, TrgmNFA *trgmNFA) int i; trgmNFA->ncolors = colorsCount; - trgmNFA->colorInfo = (TrgmColorInfo *) - palloc0(colorsCount * sizeof(TrgmColorInfo)); + trgmNFA->colorInfo = palloc0_array(TrgmColorInfo, colorsCount); /* * Loop over colors, filling TrgmColorInfo about each. Note we include diff --git a/contrib/pg_visibility/pg_visibility.c b/contrib/pg_visibility/pg_visibility.c index dfab0b64cf5..4292d077be1 100644 --- a/contrib/pg_visibility/pg_visibility.c +++ b/contrib/pg_visibility/pg_visibility.c @@ -725,7 +725,7 @@ collect_corrupt_items(Oid relid, bool all_visible, bool all_frozen) items = palloc0_object(corrupt_items); items->next = 0; items->count = 64; - items->tids = palloc(items->count * sizeof(ItemPointerData)); + items->tids = palloc_array(ItemPointerData, items->count); p.current_blocknum = 0; p.last_exclusive = RelationGetNumberOfBlocks(rel); @@ -882,8 +882,7 @@ record_corrupt_item(corrupt_items *items, ItemPointer tid) if (items->next >= items->count) { items->count *= 2; - items->tids = repalloc(items->tids, - items->count * sizeof(ItemPointerData)); + items->tids = repalloc_array(items->tids, ItemPointerData, items->count); } /* and add the new item */ items->tids[items->next++] = *tid; diff --git a/contrib/pgrowlocks/pgrowlocks.c b/contrib/pgrowlocks/pgrowlocks.c index d164c4c03ad..87bbde59937 100644 --- a/contrib/pgrowlocks/pgrowlocks.c +++ b/contrib/pgrowlocks/pgrowlocks.c @@ -120,7 +120,7 @@ pgrowlocks(PG_FUNCTION_ARGS) attinmeta = TupleDescGetAttInMetadata(rsinfo->setDesc); - values = (char **) palloc(rsinfo->setDesc->natts * sizeof(char *)); + values = palloc_array(char *, rsinfo->setDesc->natts); while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL) { @@ -145,7 +145,7 @@ pgrowlocks(PG_FUNCTION_ARGS) values[Atnum_tid] = DatumGetCString(DirectFunctionCall1(tidout, PointerGetDatum(&tuple->t_self))); - values[Atnum_xmax] = palloc(NCHARS * sizeof(char)); + values[Atnum_xmax] = palloc_array(char, NCHARS); snprintf(values[Atnum_xmax], NCHARS, "%u", xmax); if (infomask & HEAP_XMAX_IS_MULTI) { @@ -227,7 +227,7 @@ pgrowlocks(PG_FUNCTION_ARGS) { values[Atnum_ismulti] = pstrdup("false"); - values[Atnum_xids] = palloc(NCHARS * sizeof(char)); + values[Atnum_xids] = palloc_array(char, NCHARS); snprintf(values[Atnum_xids], NCHARS, "{%u}", xmax); values[Atnum_modes] = palloc(NCHARS); @@ -257,7 +257,7 @@ pgrowlocks(PG_FUNCTION_ARGS) snprintf(values[Atnum_modes], NCHARS, "{No Key Update}"); } - values[Atnum_pids] = palloc(NCHARS * sizeof(char)); + values[Atnum_pids] = palloc_array(char, NCHARS); snprintf(values[Atnum_pids], NCHARS, "{%d}", BackendXidGetPid(xmax)); } diff --git a/contrib/postgres_fdw/connection.c b/contrib/postgres_fdw/connection.c index 094eac2f343..fc9583f369f 100644 --- a/contrib/postgres_fdw/connection.c +++ b/contrib/postgres_fdw/connection.c @@ -507,8 +507,8 @@ construct_connection_params(ForeignServer *server, UserMapping *user, * required scram pass-through options. */ n = list_length(server->options) + list_length(user->options) + 4 + 3; - keywords = (const char **) palloc(n * sizeof(char *)); - values = (const char **) palloc(n * sizeof(char *)); + keywords = palloc_array(const char *, n); + values = palloc_array(const char *, n); n = 0; n += ExtractConnectionOptions(server->options, diff --git a/contrib/postgres_fdw/postgres_fdw.c b/contrib/postgres_fdw/postgres_fdw.c index 0469a761a9d..479a40719bd 100644 --- a/contrib/postgres_fdw/postgres_fdw.c +++ b/contrib/postgres_fdw/postgres_fdw.c @@ -3933,7 +3933,7 @@ fetch_more_data(ForeignScanState *node) /* Convert the data into HeapTuples */ numrows = PQntuples(res); - fsstate->tuples = (HeapTuple *) palloc0(numrows * sizeof(HeapTuple)); + fsstate->tuples = palloc0_array(HeapTuple, numrows); fsstate->num_tuples = numrows; fsstate->next_tuple = 0; @@ -4345,7 +4345,7 @@ convert_prep_stmt_params(PgFdwModifyState *fmstate, oldcontext = MemoryContextSwitchTo(fmstate->temp_cxt); - p_values = (const char **) palloc(sizeof(char *) * fmstate->p_nums * numSlots); + p_values = palloc_array(const char *, fmstate->p_nums * numSlots); /* ctid is provided only for UPDATE/DELETE, which don't allow batching */ Assert(!(tupleid != NULL && numSlots > 1)); @@ -4738,8 +4738,7 @@ init_returning_filter(PgFdwDirectModifyState *dmstate, * * Also get the indexes of the entries for ctid and oid if any. */ - dmstate->attnoMap = (AttrNumber *) - palloc0(resultTupType->natts * sizeof(AttrNumber)); + dmstate->attnoMap = palloc0_array(AttrNumber, resultTupType->natts); dmstate->ctidAttno = dmstate->oidAttno = 0; @@ -4928,7 +4927,7 @@ prepare_query_params(PlanState *node, *param_exprs = ExecInitExprList(fdw_exprs, node); /* Allocate buffer for text form of query parameters. */ - *param_values = (const char **) palloc0(numParams * sizeof(char *)); + *param_values = palloc0_array(const char *, numParams); } /* @@ -8403,8 +8402,8 @@ make_tuple_from_result_row(PGresult *res, tupdesc = fsstate->ss.ss_ScanTupleSlot->tts_tupleDescriptor; } - values = (Datum *) palloc0(tupdesc->natts * sizeof(Datum)); - nulls = (bool *) palloc(tupdesc->natts * sizeof(bool)); + values = palloc0_array(Datum, tupdesc->natts); + nulls = palloc_array(bool, tupdesc->natts); /* Initialize to nulls for any columns not present in result */ memset(nulls, true, tupdesc->natts * sizeof(bool)); diff --git a/contrib/seg/seg.c b/contrib/seg/seg.c index c7b374825f8..f5c53d10763 100644 --- a/contrib/seg/seg.c +++ b/contrib/seg/seg.c @@ -345,8 +345,7 @@ gseg_picksplit(PG_FUNCTION_ARGS) /* * Prepare the auxiliary array and sort it. */ - sort_items = (gseg_picksplit_item *) - palloc(maxoff * sizeof(gseg_picksplit_item)); + sort_items = palloc_array(gseg_picksplit_item, maxoff); for (i = 1; i <= maxoff; i++) { seg = DatumGetSegP(entryvec->vector[i].key); @@ -361,8 +360,8 @@ gseg_picksplit(PG_FUNCTION_ARGS) /* sort items below "firstright" will go into the left side */ firstright = maxoff / 2; - v->spl_left = (OffsetNumber *) palloc(maxoff * sizeof(OffsetNumber)); - v->spl_right = (OffsetNumber *) palloc(maxoff * sizeof(OffsetNumber)); + v->spl_left = palloc_array(OffsetNumber, maxoff); + v->spl_right = palloc_array(OffsetNumber, maxoff); left = v->spl_left; v->spl_nleft = 0; right = v->spl_right; diff --git a/contrib/tablefunc/tablefunc.c b/contrib/tablefunc/tablefunc.c index 31f70b7bc10..5e5cc6a71e0 100644 --- a/contrib/tablefunc/tablefunc.c +++ b/contrib/tablefunc/tablefunc.c @@ -487,7 +487,7 @@ crosstab(PG_FUNCTION_ARGS) char **values; /* allocate and zero space */ - values = (char **) palloc0((1 + num_categories) * sizeof(char *)); + values = palloc0_array(char *, 1 + num_categories); /* * now loop through the sql results and assign each value in sequence @@ -864,7 +864,7 @@ get_crosstab_tuplestore(char *sql, result_ncols, tupdesc->natts))); /* allocate space and make sure it's clear */ - values = (char **) palloc0(result_ncols * sizeof(char *)); + values = palloc0_array(char *, result_ncols); for (i = 0; i < proc; i++) { @@ -1247,9 +1247,9 @@ build_tuplestore_recursively(char *key_fld, } if (show_branch) - values = (char **) palloc((CONNECTBY_NCOLS + serial_column) * sizeof(char *)); + values = palloc_array(char *, CONNECTBY_NCOLS + serial_column); else - values = (char **) palloc((CONNECTBY_NCOLS_NOBRANCH + serial_column) * sizeof(char *)); + values = palloc_array(char *, CONNECTBY_NCOLS_NOBRANCH + serial_column); /* First time through, do a little setup */ if (level == 0) diff --git a/contrib/xml2/xpath.c b/contrib/xml2/xpath.c index 391e39827ce..4cb924541e3 100644 --- a/contrib/xml2/xpath.c +++ b/contrib/xml2/xpath.c @@ -700,8 +700,8 @@ xpath_table(PG_FUNCTION_ARGS) attinmeta = TupleDescGetAttInMetadata(rsinfo->setDesc); - values = (char **) palloc0(rsinfo->setDesc->natts * sizeof(char *)); - xpaths = (xmlChar **) palloc(rsinfo->setDesc->natts * sizeof(xmlChar *)); + values = palloc0_array(char *, rsinfo->setDesc->natts); + xpaths = palloc_array(xmlChar *, rsinfo->setDesc->natts); /* * Split XPaths. xpathset is a writable CString. diff --git a/contrib/xml2/xslt_proc.c b/contrib/xml2/xslt_proc.c index c42469cfaa3..a1e18671ce8 100644 --- a/contrib/xml2/xslt_proc.c +++ b/contrib/xml2/xslt_proc.c @@ -228,7 +228,7 @@ parse_params(text *paramstr) pstr = text_to_cstring(paramstr); max_params = 20; /* must be even! */ - params = (const char **) palloc((max_params + 1) * sizeof(char *)); + params = palloc_array(const char *, max_params + 1); nparams = 0; pos = pstr; @@ -238,8 +238,7 @@ parse_params(text *paramstr) if (nparams >= max_params) { max_params *= 2; - params = (const char **) repalloc(params, - (max_params + 1) * sizeof(char *)); + params = repalloc_array(params, const char *, max_params + 1); } params[nparams++] = pos; pos = strstr(pos, nvsep); diff --git a/doc/src/sgml/xfunc.sgml b/doc/src/sgml/xfunc.sgml index 2b8a11e7ad0..050e1e50bec 100644 --- a/doc/src/sgml/xfunc.sgml +++ b/doc/src/sgml/xfunc.sgml @@ -3454,10 +3454,10 @@ retcomposite(PG_FUNCTION_ARGS) * This should be an array of C strings which will * be processed later by the type input functions. */ - values = (char **) palloc(3 * sizeof(char *)); - values[0] = (char *) palloc(16 * sizeof(char)); - values[1] = (char *) palloc(16 * sizeof(char)); - values[2] = (char *) palloc(16 * sizeof(char)); + values = palloc_array(char *, 3); + values[0] = palloc_array(char, 16); + values[1] = palloc_array(char, 16); + values[2] = palloc_array(char, 16); snprintf(values[0], 16, "%d", 1 * PG_GETARG_INT32(1)); snprintf(values[1], 16, "%d", 2 * PG_GETARG_INT32(1)); diff --git a/src/backend/access/brin/brin_minmax_multi.c b/src/backend/access/brin/brin_minmax_multi.c index 207ae336091..1a6056a6b47 100644 --- a/src/backend/access/brin/brin_minmax_multi.c +++ b/src/backend/access/brin/brin_minmax_multi.c @@ -1390,7 +1390,7 @@ build_expanded_ranges(FmgrInfo *cmp, Oid colloid, Ranges *ranges, /* both ranges and points are expanded into a separate element */ neranges = ranges->nranges + ranges->nvalues; - eranges = (ExpandedRange *) palloc0(neranges * sizeof(ExpandedRange)); + eranges = palloc0_array(ExpandedRange, neranges); /* fill the expanded ranges */ fill_expanded_ranges(eranges, neranges, ranges); @@ -2783,7 +2783,7 @@ brin_minmax_multi_union(PG_FUNCTION_ARGS) oldctx = MemoryContextSwitchTo(ctx); /* allocate and fill */ - eranges = (ExpandedRange *) palloc0(neranges * sizeof(ExpandedRange)); + eranges = palloc0_array(ExpandedRange, neranges); /* fill the expanded ranges with entries for the first range */ fill_expanded_ranges(eranges, ranges_a->nranges + ranges_a->nvalues, diff --git a/src/backend/access/common/printtup.c b/src/backend/access/common/printtup.c index 616bdafd395..06d56cf2f20 100644 --- a/src/backend/access/common/printtup.c +++ b/src/backend/access/common/printtup.c @@ -263,8 +263,7 @@ printtup_prepare_info(DR_printtup *myState, TupleDesc typeinfo, int numAttrs) if (numAttrs <= 0) return; - myState->myinfo = (PrinttupAttrInfo *) - palloc0(numAttrs * sizeof(PrinttupAttrInfo)); + myState->myinfo = palloc0_array(PrinttupAttrInfo, numAttrs); for (i = 0; i < numAttrs; i++) { diff --git a/src/backend/access/common/reloptions.c b/src/backend/access/common/reloptions.c index 3e832c3797e..11ace24dd53 100644 --- a/src/backend/access/common/reloptions.c +++ b/src/backend/access/common/reloptions.c @@ -768,13 +768,12 @@ add_reloption(relopt_gen *newoption) if (max_custom_options == 0) { max_custom_options = 8; - custom_options = palloc(max_custom_options * sizeof(relopt_gen *)); + custom_options = palloc_array(relopt_gen *, max_custom_options); } else { max_custom_options *= 2; - custom_options = repalloc(custom_options, - max_custom_options * sizeof(relopt_gen *)); + custom_options = repalloc_array(custom_options, relopt_gen *, max_custom_options); } MemoryContextSwitchTo(oldcxt); } @@ -1634,7 +1633,7 @@ parseRelOptions(Datum options, bool validate, relopt_kind kind, if (numoptions > 0) { - reloptions = palloc(numoptions * sizeof(relopt_value)); + reloptions = palloc_array(relopt_value, numoptions); for (i = 0, j = 0; relOpts[i]; i++) { diff --git a/src/backend/access/common/tupdesc.c b/src/backend/access/common/tupdesc.c index 36026d3ec3f..a3f4c8f918e 100644 --- a/src/backend/access/common/tupdesc.c +++ b/src/backend/access/common/tupdesc.c @@ -366,7 +366,7 @@ CreateTupleDescCopyConstr(TupleDesc tupdesc) if ((cpy->num_defval = constr->num_defval) > 0) { - cpy->defval = (AttrDefault *) palloc(cpy->num_defval * sizeof(AttrDefault)); + cpy->defval = palloc_array(AttrDefault, cpy->num_defval); memcpy(cpy->defval, constr->defval, cpy->num_defval * sizeof(AttrDefault)); for (i = cpy->num_defval - 1; i >= 0; i--) cpy->defval[i].adbin = pstrdup(constr->defval[i].adbin); @@ -374,7 +374,7 @@ CreateTupleDescCopyConstr(TupleDesc tupdesc) if (constr->missing) { - cpy->missing = (AttrMissing *) palloc(tupdesc->natts * sizeof(AttrMissing)); + cpy->missing = palloc_array(AttrMissing, tupdesc->natts); memcpy(cpy->missing, constr->missing, tupdesc->natts * sizeof(AttrMissing)); for (i = tupdesc->natts - 1; i >= 0; i--) { @@ -391,7 +391,7 @@ CreateTupleDescCopyConstr(TupleDesc tupdesc) if ((cpy->num_check = constr->num_check) > 0) { - cpy->check = (ConstrCheck *) palloc(cpy->num_check * sizeof(ConstrCheck)); + cpy->check = palloc_array(ConstrCheck, cpy->num_check); memcpy(cpy->check, constr->check, cpy->num_check * sizeof(ConstrCheck)); for (i = cpy->num_check - 1; i >= 0; i--) { diff --git a/src/backend/access/gin/gindatapage.c b/src/backend/access/gin/gindatapage.c index c5d7db28077..6a40da5eb04 100644 --- a/src/backend/access/gin/gindatapage.c +++ b/src/backend/access/gin/gindatapage.c @@ -168,7 +168,7 @@ GinDataLeafPageGetItems(Page page, int *nitems, ItemPointerData advancePast) { ItemPointer tmp = dataLeafPageGetUncompressed(page, nitems); - result = palloc((*nitems) * sizeof(ItemPointerData)); + result = palloc_array(ItemPointerData, *nitems); memcpy(result, tmp, (*nitems) * sizeof(ItemPointerData)); } @@ -1418,7 +1418,7 @@ disassembleLeaf(Page page) seginfo->action = GIN_SEGMENT_REPLACE; seginfo->seg = NULL; - seginfo->items = palloc(nuncompressed * sizeof(ItemPointerData)); + seginfo->items = palloc_array(ItemPointerData, nuncompressed); memcpy(seginfo->items, uncompressed, nuncompressed * sizeof(ItemPointerData)); seginfo->nitems = nuncompressed; diff --git a/src/backend/access/gin/ginget.c b/src/backend/access/gin/ginget.c index b82f03a86b3..2bcb32ca3d0 100644 --- a/src/backend/access/gin/ginget.c +++ b/src/backend/access/gin/ginget.c @@ -542,7 +542,7 @@ startScanKey(GinState *ginstate, GinScanOpaque so, GinScanKey key) key->nrequired = 0; key->nadditional = key->nentries; - key->additionalEntries = palloc(key->nadditional * sizeof(GinScanEntry)); + key->additionalEntries = palloc_array(GinScanEntry, key->nadditional); for (int i = 0; i < key->nadditional; i++) key->additionalEntries[i] = key->scanEntry[i]; } @@ -578,8 +578,8 @@ startScanKey(GinState *ginstate, GinScanOpaque so, GinScanKey key) key->nrequired = i + 1; key->nadditional = key->nentries - key->nrequired; - key->requiredEntries = palloc(key->nrequired * sizeof(GinScanEntry)); - key->additionalEntries = palloc(key->nadditional * sizeof(GinScanEntry)); + key->requiredEntries = palloc_array(GinScanEntry, key->nrequired); + key->additionalEntries = palloc_array(GinScanEntry, key->nadditional); j = 0; for (int k = 0; k < key->nrequired; k++) @@ -596,7 +596,7 @@ startScanKey(GinState *ginstate, GinScanOpaque so, GinScanKey key) key->nrequired = 1; key->nadditional = 0; - key->requiredEntries = palloc(1 * sizeof(GinScanEntry)); + key->requiredEntries = palloc_array(GinScanEntry, 1); key->requiredEntries[0] = key->scanEntry[0]; } MemoryContextSwitchTo(oldCtx); diff --git a/src/backend/access/gin/gininsert.c b/src/backend/access/gin/gininsert.c index 16abb76c001..37f689a2cac 100644 --- a/src/backend/access/gin/gininsert.c +++ b/src/backend/access/gin/gininsert.c @@ -1527,10 +1527,10 @@ GinBufferStoreTuple(GinBuffer *buffer, GinTuple *tup) * still pass 0 as number of elements in that array though. */ if (buffer->items == NULL) - buffer->items = palloc((buffer->nitems + tup->nitems) * sizeof(ItemPointerData)); + buffer->items = palloc_array(ItemPointerData, buffer->nitems + tup->nitems); else - buffer->items = repalloc(buffer->items, - (buffer->nitems + tup->nitems) * sizeof(ItemPointerData)); + buffer->items = repalloc_array(buffer->items, + ItemPointerData, buffer->nitems + tup->nitems); new = ginMergeItemPointers(&buffer->items[buffer->nfrozen], /* first unfrozen */ (buffer->nitems - buffer->nfrozen), /* num of unfrozen */ diff --git a/src/backend/access/gin/ginpostinglist.c b/src/backend/access/gin/ginpostinglist.c index d8dfcee4bde..07656574029 100644 --- a/src/backend/access/gin/ginpostinglist.c +++ b/src/backend/access/gin/ginpostinglist.c @@ -308,7 +308,7 @@ ginPostingListDecodeAllSegments(GinPostingList *segment, int len, int *ndecoded_ * Guess an initial size of the array. */ nallocated = segment->nbytes * 2 + 1; - result = palloc(nallocated * sizeof(ItemPointerData)); + result = palloc_array(ItemPointerData, nallocated); ndecoded = 0; while ((char *) segment < endseg) @@ -317,7 +317,7 @@ ginPostingListDecodeAllSegments(GinPostingList *segment, int len, int *ndecoded_ if (ndecoded >= nallocated) { nallocated *= 2; - result = repalloc(result, nallocated * sizeof(ItemPointerData)); + result = repalloc_array(result, ItemPointerData, nallocated); } /* copy the first item */ @@ -335,7 +335,7 @@ ginPostingListDecodeAllSegments(GinPostingList *segment, int len, int *ndecoded_ if (ndecoded >= nallocated) { nallocated *= 2; - result = repalloc(result, nallocated * sizeof(ItemPointerData)); + result = repalloc_array(result, ItemPointerData, nallocated); } val += decode_varbyte(&ptr); @@ -381,7 +381,7 @@ ginMergeItemPointers(ItemPointerData *a, uint32 na, { ItemPointerData *dst; - dst = (ItemPointer) palloc((na + nb) * sizeof(ItemPointerData)); + dst = palloc_array(ItemPointerData, na + nb); /* * If the argument arrays don't overlap, we can just append them to each diff --git a/src/backend/access/gin/ginscan.c b/src/backend/access/gin/ginscan.c index 075779b4b4f..1564b409bdb 100644 --- a/src/backend/access/gin/ginscan.c +++ b/src/backend/access/gin/ginscan.c @@ -281,15 +281,13 @@ ginNewScanKey(IndexScanDesc scan) oldCtx = MemoryContextSwitchTo(so->keyCtx); /* if no scan keys provided, allocate extra EVERYTHING GinScanKey */ - so->keys = (GinScanKey) - palloc(Max(scan->numberOfKeys, 1) * sizeof(GinScanKeyData)); + so->keys = palloc_array(GinScanKeyData, Max(scan->numberOfKeys, 1)); so->nkeys = 0; /* initialize expansible array of GinScanEntry pointers */ so->totalentries = 0; so->allocentries = 32; - so->entries = (GinScanEntry *) - palloc(so->allocentries * sizeof(GinScanEntry)); + so->entries = palloc_array(GinScanEntry, so->allocentries); so->isVoidRes = false; @@ -357,7 +355,7 @@ ginNewScanKey(IndexScanDesc scan) * didn't create a nullFlags array, we assume everything is non-null. * While at it, detect whether any null keys are present. */ - categories = (GinNullCategory *) palloc0(nQueryValues * sizeof(GinNullCategory)); + categories = palloc0_array(GinNullCategory, nQueryValues); if (nullFlags) { int32 j; @@ -422,7 +420,7 @@ ginNewScanKey(IndexScanDesc scan) /* We'd better have made at least one normal key */ Assert(numExcludeOnly < so->nkeys); /* Make a temporary array to hold the re-ordered scan keys */ - tmpkeys = (GinScanKey) palloc(so->nkeys * sizeof(GinScanKeyData)); + tmpkeys = palloc_array(GinScanKeyData, so->nkeys); /* Re-order the keys ... */ iNormalKey = 0; iExcludeOnly = so->nkeys - numExcludeOnly; diff --git a/src/backend/access/gist/gistbuildbuffers.c b/src/backend/access/gist/gistbuildbuffers.c index 3213cf45aa6..82576111b0c 100644 --- a/src/backend/access/gist/gistbuildbuffers.c +++ b/src/backend/access/gist/gistbuildbuffers.c @@ -142,9 +142,7 @@ gistGetNodeBuffer(GISTBuildBuffers *gfbb, GISTSTATE *giststate, { int i; - gfbb->buffersOnLevels = - (List **) repalloc(gfbb->buffersOnLevels, - (level + 1) * sizeof(List *)); + gfbb->buffersOnLevels = repalloc_array(gfbb->buffersOnLevels, List *, level + 1); /* initialize the enlarged portion */ for (i = gfbb->buffersOnLevelsLen; i <= level; i++) @@ -203,9 +201,8 @@ gistAddLoadedBuffer(GISTBuildBuffers *gfbb, GISTNodeBuffer *nodeBuffer) if (gfbb->loadedBuffersCount >= gfbb->loadedBuffersLen) { gfbb->loadedBuffersLen *= 2; - gfbb->loadedBuffers = (GISTNodeBuffer **) - repalloc(gfbb->loadedBuffers, - gfbb->loadedBuffersLen * sizeof(GISTNodeBuffer *)); + gfbb->loadedBuffers = repalloc_array(gfbb->loadedBuffers, + GISTNodeBuffer *, gfbb->loadedBuffersLen); } gfbb->loadedBuffers[gfbb->loadedBuffersCount] = nodeBuffer; @@ -488,9 +485,8 @@ gistBuffersReleaseBlock(GISTBuildBuffers *gfbb, long blocknum) if (gfbb->nFreeBlocks >= gfbb->freeBlocksLen) { gfbb->freeBlocksLen *= 2; - gfbb->freeBlocks = (long *) repalloc(gfbb->freeBlocks, - gfbb->freeBlocksLen * - sizeof(long)); + gfbb->freeBlocks = repalloc_array(gfbb->freeBlocks, + long, gfbb->freeBlocksLen); } /* Add blocknum to array */ diff --git a/src/backend/access/gist/gistget.c b/src/backend/access/gist/gistget.c index e8a1e456287..5df2d402273 100644 --- a/src/backend/access/gist/gistget.c +++ b/src/backend/access/gist/gistget.c @@ -670,9 +670,7 @@ gistgettuple(IndexScanDesc scan, ScanDirection dir) MemoryContext oldCxt = MemoryContextSwitchTo(so->giststate->scanCxt); - so->killedItems = - (OffsetNumber *) palloc(MaxIndexTuplesPerPage - * sizeof(OffsetNumber)); + so->killedItems = palloc_array(OffsetNumber, MaxIndexTuplesPerPage); MemoryContextSwitchTo(oldCxt); } @@ -707,9 +705,7 @@ gistgettuple(IndexScanDesc scan, ScanDirection dir) MemoryContext oldCxt = MemoryContextSwitchTo(so->giststate->scanCxt); - so->killedItems = - (OffsetNumber *) palloc(MaxIndexTuplesPerPage - * sizeof(OffsetNumber)); + so->killedItems = palloc_array(OffsetNumber, MaxIndexTuplesPerPage); MemoryContextSwitchTo(oldCxt); } diff --git a/src/backend/access/gist/gistproc.c b/src/backend/access/gist/gistproc.c index a7340bb9c8c..f1044f49d6c 100644 --- a/src/backend/access/gist/gistproc.c +++ b/src/backend/access/gist/gistproc.c @@ -516,8 +516,8 @@ gist_box_picksplit(PG_FUNCTION_ARGS) nentries = context.entriesCount = maxoff - FirstOffsetNumber + 1; /* Allocate arrays for intervals along axes */ - intervalsLower = (SplitInterval *) palloc(nentries * sizeof(SplitInterval)); - intervalsUpper = (SplitInterval *) palloc(nentries * sizeof(SplitInterval)); + intervalsLower = palloc_array(SplitInterval, nentries); + intervalsUpper = palloc_array(SplitInterval, nentries); /* * Calculate the overall minimum bounding box over all the entries. @@ -693,8 +693,8 @@ gist_box_picksplit(PG_FUNCTION_ARGS) */ /* Allocate vectors for results */ - v->spl_left = (OffsetNumber *) palloc(nentries * sizeof(OffsetNumber)); - v->spl_right = (OffsetNumber *) palloc(nentries * sizeof(OffsetNumber)); + v->spl_left = palloc_array(OffsetNumber, nentries); + v->spl_right = palloc_array(OffsetNumber, nentries); v->spl_nleft = 0; v->spl_nright = 0; @@ -707,7 +707,7 @@ gist_box_picksplit(PG_FUNCTION_ARGS) * either group without affecting overlap along selected axis. */ commonEntriesCount = 0; - commonEntries = (CommonEntry *) palloc(nentries * sizeof(CommonEntry)); + commonEntries = palloc_array(CommonEntry, nentries); /* Helper macros to place an entry in the left or right group */ #define PLACE_LEFT(box, off) \ diff --git a/src/backend/access/gist/gistscan.c b/src/backend/access/gist/gistscan.c index c65f93abdae..5583a5a35a4 100644 --- a/src/backend/access/gist/gistscan.c +++ b/src/backend/access/gist/gistscan.c @@ -97,7 +97,7 @@ gistbeginscan(Relation r, int nkeys, int norderbys) so->queueCxt = giststate->scanCxt; /* see gistrescan */ /* workspaces with size dependent on numberOfOrderBys: */ - so->distances = palloc(sizeof(so->distances[0]) * scan->numberOfOrderBys); + so->distances = palloc_array(IndexOrderByDistance, scan->numberOfOrderBys); so->qual_ok = true; /* in case there are zero keys */ if (scan->numberOfOrderBys > 0) { @@ -229,7 +229,7 @@ gistrescan(IndexScanDesc scan, ScanKey key, int nkeys, */ if (!first_time) { - fn_extras = (void **) palloc(scan->numberOfKeys * sizeof(void *)); + fn_extras = palloc_array(void *, scan->numberOfKeys); for (i = 0; i < scan->numberOfKeys; i++) fn_extras[i] = scan->keyData[i].sk_func.fn_extra; } @@ -284,14 +284,14 @@ gistrescan(IndexScanDesc scan, ScanKey key, int nkeys, /* As above, preserve fn_extra if not first time through */ if (!first_time) { - fn_extras = (void **) palloc(scan->numberOfOrderBys * sizeof(void *)); + fn_extras = palloc_array(void *, scan->numberOfOrderBys); for (i = 0; i < scan->numberOfOrderBys; i++) fn_extras[i] = scan->orderByData[i].sk_func.fn_extra; } memcpy(scan->orderByData, orderbys, scan->numberOfOrderBys * sizeof(ScanKeyData)); - so->orderByTypes = (Oid *) palloc(scan->numberOfOrderBys * sizeof(Oid)); + so->orderByTypes = palloc_array(Oid, scan->numberOfOrderBys); /* * Modify the order-by key so that the Distance method is called for diff --git a/src/backend/access/gist/gistsplit.c b/src/backend/access/gist/gistsplit.c index dc899565320..48eff023826 100644 --- a/src/backend/access/gist/gistsplit.c +++ b/src/backend/access/gist/gistsplit.c @@ -587,8 +587,8 @@ gistSplitHalf(GIST_SPLITVEC *v, int len) int i; v->spl_nright = v->spl_nleft = 0; - v->spl_left = (OffsetNumber *) palloc(len * sizeof(OffsetNumber)); - v->spl_right = (OffsetNumber *) palloc(len * sizeof(OffsetNumber)); + v->spl_left = palloc_array(OffsetNumber, len); + v->spl_right = palloc_array(OffsetNumber, len); for (i = 1; i <= len; i++) if (i < len / 2) v->spl_right[v->spl_nright++] = i; @@ -632,7 +632,7 @@ gistSplitByKey(Relation r, Page page, IndexTuple *itup, int len, /* note that entryvec->vector[0] goes unused in this code */ entryvec = palloc(GEVHDRSZ + (len + 1) * sizeof(GISTENTRY)); entryvec->n = len + 1; - offNullTuples = (OffsetNumber *) palloc(len * sizeof(OffsetNumber)); + offNullTuples = palloc_array(OffsetNumber, len); for (i = 1; i <= len; i++) { @@ -674,7 +674,7 @@ gistSplitByKey(Relation r, Page page, IndexTuple *itup, int len, v->splitVector.spl_nright = nOffNullTuples; v->spl_risnull[attno] = true; - v->splitVector.spl_left = (OffsetNumber *) palloc(len * sizeof(OffsetNumber)); + v->splitVector.spl_left = palloc_array(OffsetNumber, len); v->splitVector.spl_nleft = 0; for (i = 1; i <= len; i++) if (j < v->splitVector.spl_nright && offNullTuples[j] == i) @@ -716,8 +716,8 @@ gistSplitByKey(Relation r, Page page, IndexTuple *itup, int len, * Form an array of just the don't-care tuples to pass to a * recursive invocation of this function for the next column. */ - IndexTuple *newitup = (IndexTuple *) palloc(len * sizeof(IndexTuple)); - OffsetNumber *map = (OffsetNumber *) palloc(len * sizeof(OffsetNumber)); + IndexTuple *newitup = palloc_array(IndexTuple, len); + OffsetNumber *map = palloc_array(OffsetNumber, len); int newlen = 0; GIST_SPLITVEC backupSplit; diff --git a/src/backend/access/gist/gistxlog.c b/src/backend/access/gist/gistxlog.c index ae538dc81ca..171e0d4d1b4 100644 --- a/src/backend/access/gist/gistxlog.c +++ b/src/backend/access/gist/gistxlog.c @@ -228,7 +228,7 @@ decodePageSplitRecord(char *begin, int len, int *n) memcpy(n, begin, sizeof(int)); ptr = begin + sizeof(int); - tuples = palloc(*n * sizeof(IndexTuple)); + tuples = palloc_array(IndexTuple, *n); for (i = 0; i < *n; i++) { diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c index d0ffad19a16..72d6541734c 100644 --- a/src/backend/access/heap/heapam.c +++ b/src/backend/access/heap/heapam.c @@ -2333,7 +2333,7 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples, HEAP_DEFAULT_FILLFACTOR); /* Toast and set header data in all the slots */ - heaptuples = palloc(ntuples * sizeof(HeapTuple)); + heaptuples = palloc_array(HeapTuple, ntuples); for (i = 0; i < ntuples; i++) { HeapTuple tuple; @@ -8979,7 +8979,7 @@ bottomup_sort_and_shrink(TM_IndexDeleteOp *delstate) /* Sort groups and rearrange caller's deltids array */ qsort(blockgroups, nblockgroups, sizeof(IndexDeleteCounts), bottomup_sort_and_shrink_cmp); - reordereddeltids = palloc(delstate->ndeltids * sizeof(TM_IndexDelete)); + reordereddeltids = palloc_array(TM_IndexDelete, delstate->ndeltids); nblockgroups = Min(BOTTOMUP_MAX_NBLOCKS, nblockgroups); /* Determine number of favorable blocks at the start of final deltids */ diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c index 9bce43e563c..063ef2208de 100644 --- a/src/backend/access/heap/vacuumlazy.c +++ b/src/backend/access/heap/vacuumlazy.c @@ -760,8 +760,7 @@ heap_vacuum_rel(Relation rel, const VacuumParams *params, /* Allocate/initialize output statistics state */ vacrel->new_rel_tuples = 0; vacrel->new_live_tuples = 0; - vacrel->indstats = (IndexBulkDeleteResult **) - palloc0(vacrel->nindexes * sizeof(IndexBulkDeleteResult *)); + vacrel->indstats = palloc0_array(IndexBulkDeleteResult *, vacrel->nindexes); /* Initialize remaining counters (be tidy) */ vacrel->num_index_scans = 0; diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c index c8af97dd23d..3b945342d83 100644 --- a/src/backend/access/nbtree/nbtinsert.c +++ b/src/backend/access/nbtree/nbtinsert.c @@ -2876,8 +2876,8 @@ _bt_simpledel_pass(Relation rel, Buffer buffer, Relation heapRel, delstate.bottomup = false; delstate.bottomupfreespace = 0; delstate.ndeltids = 0; - delstate.deltids = palloc(MaxTIDsPerBTreePage * sizeof(TM_IndexDelete)); - delstate.status = palloc(MaxTIDsPerBTreePage * sizeof(TM_IndexStatus)); + delstate.deltids = palloc_array(TM_IndexDelete, MaxTIDsPerBTreePage); + delstate.status = palloc_array(TM_IndexStatus, MaxTIDsPerBTreePage); for (offnum = minoff; offnum <= maxoff; @@ -3019,8 +3019,7 @@ _bt_deadblocks(Page page, OffsetNumber *deletable, int ndeletable, if (ntids + 1 > spacentids) { spacentids *= 2; - tidblocks = (BlockNumber *) - repalloc(tidblocks, sizeof(BlockNumber) * spacentids); + tidblocks = repalloc_array(tidblocks, BlockNumber, spacentids); } tidblocks[ntids++] = ItemPointerGetBlockNumber(&itup->t_tid); @@ -3032,8 +3031,7 @@ _bt_deadblocks(Page page, OffsetNumber *deletable, int ndeletable, if (ntids + nposting > spacentids) { spacentids = Max(spacentids * 2, ntids + nposting); - tidblocks = (BlockNumber *) - repalloc(tidblocks, sizeof(BlockNumber) * spacentids); + tidblocks = repalloc_array(tidblocks, BlockNumber, spacentids); } for (int j = 0; j < nposting; j++) diff --git a/src/backend/access/nbtree/nbtpage.c b/src/backend/access/nbtree/nbtpage.c index 109017d6b52..ff7d2a93948 100644 --- a/src/backend/access/nbtree/nbtpage.c +++ b/src/backend/access/nbtree/nbtpage.c @@ -3120,9 +3120,8 @@ _bt_pendingfsm_add(BTVacState *vstate, newbufsize = vstate->maxbufsize; vstate->bufsize = newbufsize; - vstate->pendingpages = - repalloc(vstate->pendingpages, - sizeof(BTPendingFSM) * vstate->bufsize); + vstate->pendingpages = repalloc_array(vstate->pendingpages, + BTPendingFSM, vstate->bufsize); } /* Save metadata for newly deleted page */ diff --git a/src/backend/access/nbtree/nbtpreprocesskeys.c b/src/backend/access/nbtree/nbtpreprocesskeys.c index 39c0a5d610f..287e1a8e3fa 100644 --- a/src/backend/access/nbtree/nbtpreprocesskeys.c +++ b/src/backend/access/nbtree/nbtpreprocesskeys.c @@ -258,8 +258,8 @@ _bt_preprocess_keys(IndexScanDesc scan) * a skip array's scan key */ if (numberOfKeys > scan->numberOfKeys) - so->keyData = repalloc(so->keyData, - numberOfKeys * sizeof(ScanKeyData)); + so->keyData = repalloc_array(so->keyData, + ScanKeyData, numberOfKeys); } else inkeys = scan->keyData; @@ -1568,7 +1568,7 @@ _bt_unmark_keys(IndexScanDesc scan, int *keyDataMap) * Any requiredness markings that we might leave on later keys/attributes * are predicated on there being required = keys on all prior columns. */ - unmarkikey = palloc0(so->numberOfKeys * sizeof(bool)); + unmarkikey = palloc0_array(bool, so->numberOfKeys); nunmark = 0; /* Set things up for first key's attribute */ @@ -1653,14 +1653,14 @@ _bt_unmark_keys(IndexScanDesc scan, int *keyDataMap) * Next, allocate temp arrays: one for required keys that'll remain * required, the other for all remaining keys */ - unmarkKeys = palloc(nunmark * sizeof(ScanKeyData)); - keepKeys = palloc((so->numberOfKeys - nunmark) * sizeof(ScanKeyData)); + unmarkKeys = palloc_array(ScanKeyData, nunmark); + keepKeys = palloc_array(ScanKeyData, so->numberOfKeys - nunmark); nunmarked = 0; nkept = 0; if (so->numArrayKeys) { - unmarkOrderProcs = palloc(nunmark * sizeof(FmgrInfo)); - keepOrderProcs = palloc((so->numberOfKeys - nunmark) * sizeof(FmgrInfo)); + unmarkOrderProcs = palloc_array(FmgrInfo, nunmark); + keepOrderProcs = palloc_array(FmgrInfo, so->numberOfKeys - nunmark); } /* @@ -1890,13 +1890,13 @@ _bt_preprocess_array_keys(IndexScanDesc scan, int *new_numberOfKeys) oldContext = MemoryContextSwitchTo(so->arrayContext); /* Create output scan keys in the workspace context */ - arrayKeyData = (ScanKey) palloc(numArrayKeyData * sizeof(ScanKeyData)); + arrayKeyData = palloc_array(ScanKeyData, numArrayKeyData); /* Allocate space for per-array data in the workspace context */ - so->arrayKeys = (BTArrayKeyInfo *) palloc(numArrayKeys * sizeof(BTArrayKeyInfo)); + so->arrayKeys = palloc_array(BTArrayKeyInfo, numArrayKeys); /* Allocate space for ORDER procs used to help _bt_checkkeys */ - so->orderProcs = (FmgrInfo *) palloc(numArrayKeyData * sizeof(FmgrInfo)); + so->orderProcs = palloc_array(FmgrInfo, numArrayKeyData); numArrayKeys = 0; numArrayKeyData = 0; diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c index 3df2c752ead..0abdd7b49f5 100644 --- a/src/backend/access/nbtree/nbtree.c +++ b/src/backend/access/nbtree/nbtree.c @@ -352,7 +352,7 @@ btbeginscan(Relation rel, int nkeys, int norderbys) BTScanPosInvalidate(so->currPos); BTScanPosInvalidate(so->markPos); if (scan->numberOfKeys > 0) - so->keyData = (ScanKey) palloc(scan->numberOfKeys * sizeof(ScanKeyData)); + so->keyData = palloc_array(ScanKeyData, scan->numberOfKeys); else so->keyData = NULL; diff --git a/src/backend/access/tablesample/bernoulli.c b/src/backend/access/tablesample/bernoulli.c index 7d8560464c8..a8ec1e1b9ac 100644 --- a/src/backend/access/tablesample/bernoulli.c +++ b/src/backend/access/tablesample/bernoulli.c @@ -126,7 +126,7 @@ bernoulli_samplescangetsamplesize(PlannerInfo *root, static void bernoulli_initsamplescan(SampleScanState *node, int eflags) { - node->tsm_state = palloc0(sizeof(BernoulliSamplerData)); + node->tsm_state = palloc0_object(BernoulliSamplerData); } /* diff --git a/src/backend/access/transam/multixact.c b/src/backend/access/transam/multixact.c index 424516dc106..d688815083c 100644 --- a/src/backend/access/transam/multixact.c +++ b/src/backend/access/transam/multixact.c @@ -1337,7 +1337,7 @@ GetMultiXactIdMembers(MultiXactId multi, MultiXactMember **members, length = nextMXOffset - offset; /* read the members */ - ptr = (MultiXactMember *) palloc(length * sizeof(MultiXactMember)); + ptr = palloc_array(MultiXactMember, length); prev_pageno = -1; for (int i = 0; i < length; i++, offset++) { diff --git a/src/backend/access/transam/twophase.c b/src/backend/access/transam/twophase.c index fa3bc50ec48..48e478a4ecb 100644 --- a/src/backend/access/transam/twophase.c +++ b/src/backend/access/transam/twophase.c @@ -2012,12 +2012,12 @@ PrescanPreparedTransactions(TransactionId **xids_p, int *nxids_p) if (nxids == 0) { allocsize = 10; - xids = palloc(allocsize * sizeof(TransactionId)); + xids = palloc_array(TransactionId, allocsize); } else { allocsize = allocsize * 2; - xids = repalloc(xids, allocsize * sizeof(TransactionId)); + xids = repalloc_array(xids, TransactionId, allocsize); } } xids[nxids++] = xid; diff --git a/src/backend/access/transam/xact.c b/src/backend/access/transam/xact.c index 3a89149016f..5e08415e50c 100644 --- a/src/backend/access/transam/xact.c +++ b/src/backend/access/transam/xact.c @@ -1747,8 +1747,7 @@ AtSubCommit_childXids(void) MemoryContextAlloc(TopTransactionContext, new_maxChildXids * sizeof(TransactionId)); else - new_childXids = repalloc(s->parent->childXids, - new_maxChildXids * sizeof(TransactionId)); + new_childXids = repalloc_array(s->parent->childXids, TransactionId, new_maxChildXids); s->parent->childXids = new_childXids; s->parent->maxChildXids = new_maxChildXids; @@ -5640,7 +5639,7 @@ SerializeTransactionState(Size maxsize, char *start_address) <= maxsize); /* Copy them to our scratch space. */ - workspace = palloc(nxids * sizeof(TransactionId)); + workspace = palloc_array(TransactionId, nxids); for (s = CurrentTransactionState; s != NULL; s = s->parent) { if (FullTransactionIdIsValid(s->fullTransactionId)) diff --git a/src/backend/access/transam/xloginsert.c b/src/backend/access/transam/xloginsert.c index f2e10b82b7d..c9aff944a2e 100644 --- a/src/backend/access/transam/xloginsert.c +++ b/src/backend/access/transam/xloginsert.c @@ -200,8 +200,7 @@ XLogEnsureRecordSpace(int max_block_id, int ndatas) if (nbuffers > max_registered_buffers) { - registered_buffers = (registered_buffer *) - repalloc(registered_buffers, sizeof(registered_buffer) * nbuffers); + registered_buffers = repalloc_array(registered_buffers, registered_buffer, nbuffers); /* * At least the padding bytes in the structs must be zeroed, because @@ -214,7 +213,7 @@ XLogEnsureRecordSpace(int max_block_id, int ndatas) if (ndatas > max_rdatas) { - rdatas = (XLogRecData *) repalloc(rdatas, sizeof(XLogRecData) * ndatas); + rdatas = repalloc_array(rdatas, XLogRecData, ndatas); max_rdatas = ndatas; } } diff --git a/src/backend/backup/basebackup_incremental.c b/src/backend/backup/basebackup_incremental.c index 9235f6b268c..27fc42a2a43 100644 --- a/src/backend/backup/basebackup_incremental.c +++ b/src/backend/backup/basebackup_incremental.c @@ -310,7 +310,7 @@ PrepareForIncrementalBackup(IncrementalBackupInfo *ib, * to the beginning. */ expectedTLEs = readTimeLineHistory(backup_state->starttli); - tlep = palloc0(num_wal_ranges * sizeof(TimeLineHistoryEntry *)); + tlep = palloc0_array(TimeLineHistoryEntry *, num_wal_ranges); for (int i = 0; i < num_wal_ranges; ++i) { backup_wal_range *range = list_nth(ib->manifest_wal_ranges, i); diff --git a/src/backend/catalog/aclchk.c b/src/backend/catalog/aclchk.c index 427213ecf1f..91b02317ce7 100644 --- a/src/backend/catalog/aclchk.c +++ b/src/backend/catalog/aclchk.c @@ -1927,7 +1927,7 @@ ExecGrant_Relation(InternalGrant *istmt) * corresponds to FirstLowInvalidHeapAttributeNumber. */ num_col_privileges = pg_class_tuple->relnatts - FirstLowInvalidHeapAttributeNumber + 1; - col_privileges = (AclMode *) palloc0(num_col_privileges * sizeof(AclMode)); + col_privileges = palloc0_array(AclMode, num_col_privileges); have_col_privileges = false; /* diff --git a/src/backend/catalog/dependency.c b/src/backend/catalog/dependency.c index 026b743275f..109945a26cc 100644 --- a/src/backend/catalog/dependency.c +++ b/src/backend/catalog/dependency.c @@ -971,9 +971,9 @@ findDependentObjects(const ObjectAddress *object, { /* enlarge array if needed */ maxDependentObjects *= 2; - dependentObjects = (ObjectAddressAndFlags *) - repalloc(dependentObjects, - maxDependentObjects * sizeof(ObjectAddressAndFlags)); + dependentObjects = repalloc_array(dependentObjects, + ObjectAddressAndFlags, + maxDependentObjects); } dependentObjects[numDependentObjects].obj = otherObject; @@ -2813,8 +2813,7 @@ add_object_address(Oid classId, Oid objectId, int32 subId, if (addrs->numrefs >= addrs->maxrefs) { addrs->maxrefs *= 2; - addrs->refs = (ObjectAddress *) - repalloc(addrs->refs, addrs->maxrefs * sizeof(ObjectAddress)); + addrs->refs = repalloc_array(addrs->refs, ObjectAddress, addrs->maxrefs); Assert(!addrs->extras); } /* record this item */ @@ -2840,8 +2839,7 @@ add_exact_object_address(const ObjectAddress *object, if (addrs->numrefs >= addrs->maxrefs) { addrs->maxrefs *= 2; - addrs->refs = (ObjectAddress *) - repalloc(addrs->refs, addrs->maxrefs * sizeof(ObjectAddress)); + addrs->refs = repalloc_array(addrs->refs, ObjectAddress, addrs->maxrefs); Assert(!addrs->extras); } /* record this item */ @@ -2865,17 +2863,14 @@ add_exact_object_address_extra(const ObjectAddress *object, /* allocate extra space if first time */ if (!addrs->extras) - addrs->extras = (ObjectAddressExtra *) - palloc(addrs->maxrefs * sizeof(ObjectAddressExtra)); + addrs->extras = palloc_array(ObjectAddressExtra, addrs->maxrefs); /* enlarge array if needed */ if (addrs->numrefs >= addrs->maxrefs) { addrs->maxrefs *= 2; - addrs->refs = (ObjectAddress *) - repalloc(addrs->refs, addrs->maxrefs * sizeof(ObjectAddress)); - addrs->extras = (ObjectAddressExtra *) - repalloc(addrs->extras, addrs->maxrefs * sizeof(ObjectAddressExtra)); + addrs->refs = repalloc_array(addrs->refs, ObjectAddress, addrs->maxrefs); + addrs->extras = repalloc_array(addrs->extras, ObjectAddressExtra, addrs->maxrefs); } /* record this item */ item = addrs->refs + addrs->numrefs; diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c index 0fbbf8bcf56..b018f26545b 100644 --- a/src/backend/catalog/heap.c +++ b/src/backend/catalog/heap.c @@ -2197,7 +2197,7 @@ StoreRelCheck(Relation rel, const char *ccname, Node *expr, ListCell *vl; int i = 0; - attNos = (int16 *) palloc(keycount * sizeof(int16)); + attNos = palloc_array(int16, keycount); foreach(vl, varList) { Var *var = (Var *) lfirst(vl); diff --git a/src/backend/catalog/pg_constraint.c b/src/backend/catalog/pg_constraint.c index 8aba9cbbc57..75e4870d5d6 100644 --- a/src/backend/catalog/pg_constraint.c +++ b/src/backend/catalog/pg_constraint.c @@ -121,7 +121,7 @@ CreateConstraintEntry(const char *constraintName, { Datum *conkey; - conkey = (Datum *) palloc(constraintNKeys * sizeof(Datum)); + conkey = palloc_array(Datum, constraintNKeys); for (i = 0; i < constraintNKeys; i++) conkey[i] = Int16GetDatum(constraintKey[i]); conkeyArray = construct_array_builtin(conkey, constraintNKeys, INT2OID); @@ -134,7 +134,7 @@ CreateConstraintEntry(const char *constraintName, Datum *fkdatums; int nkeys = Max(foreignNKeys, numFkDeleteSetCols); - fkdatums = (Datum *) palloc(nkeys * sizeof(Datum)); + fkdatums = palloc_array(Datum, nkeys); for (i = 0; i < foreignNKeys; i++) fkdatums[i] = Int16GetDatum(foreignKey[i]); confkeyArray = construct_array_builtin(fkdatums, foreignNKeys, INT2OID); @@ -170,7 +170,7 @@ CreateConstraintEntry(const char *constraintName, { Datum *opdatums; - opdatums = (Datum *) palloc(constraintNKeys * sizeof(Datum)); + opdatums = palloc_array(Datum, constraintNKeys); for (i = 0; i < constraintNKeys; i++) opdatums[i] = ObjectIdGetDatum(exclOp[i]); conexclopArray = construct_array_builtin(opdatums, constraintNKeys, OIDOID); diff --git a/src/backend/catalog/pg_inherits.c b/src/backend/catalog/pg_inherits.c index 4b9802aafcc..23fb7886cfb 100644 --- a/src/backend/catalog/pg_inherits.c +++ b/src/backend/catalog/pg_inherits.c @@ -106,7 +106,7 @@ find_inheritance_children_extended(Oid parentrelId, bool omit_detached, * Scan pg_inherits and build a working array of subclass OIDs. */ maxoids = 32; - oidarr = (Oid *) palloc(maxoids * sizeof(Oid)); + oidarr = palloc_array(Oid, maxoids); numoids = 0; relation = table_open(InheritsRelationId, AccessShareLock); @@ -183,7 +183,7 @@ find_inheritance_children_extended(Oid parentrelId, bool omit_detached, if (numoids >= maxoids) { maxoids *= 2; - oidarr = (Oid *) repalloc(oidarr, maxoids * sizeof(Oid)); + oidarr = repalloc_array(oidarr, Oid, maxoids); } oidarr[numoids++] = inhrelid; } diff --git a/src/backend/catalog/pg_shdepend.c b/src/backend/catalog/pg_shdepend.c index c9998531b2f..f70bffd527f 100644 --- a/src/backend/catalog/pg_shdepend.c +++ b/src/backend/catalog/pg_shdepend.c @@ -716,8 +716,7 @@ checkSharedDependencies(Oid classId, Oid objectId, #define MAX_REPORTED_DEPS 100 allocedobjects = 128; /* arbitrary initial array size */ - objects = (ShDependObjectInfo *) - palloc(allocedobjects * sizeof(ShDependObjectInfo)); + objects = palloc_array(ShDependObjectInfo, allocedobjects); numobjects = 0; initStringInfo(&descs); initStringInfo(&alldescs); @@ -757,9 +756,7 @@ checkSharedDependencies(Oid classId, Oid objectId, if (numobjects >= allocedobjects) { allocedobjects *= 2; - objects = (ShDependObjectInfo *) - repalloc(objects, - allocedobjects * sizeof(ShDependObjectInfo)); + objects = repalloc_array(objects, ShDependObjectInfo, allocedobjects); } objects[numobjects].object = object; objects[numobjects].deptype = sdepForm->deptype; diff --git a/src/backend/commands/alter.c b/src/backend/commands/alter.c index 74ceb5fe20d..26e05f061e2 100644 --- a/src/backend/commands/alter.c +++ b/src/backend/commands/alter.c @@ -318,9 +318,9 @@ AlterObjectRename_internal(Relation rel, Oid objectId, const char *new_name) } /* Build modified tuple */ - values = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(Datum)); - nulls = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(bool)); - replaces = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(bool)); + values = palloc0_array(Datum, RelationGetNumberOfAttributes(rel)); + nulls = palloc0_array(bool, RelationGetNumberOfAttributes(rel)); + replaces = palloc0_array(bool, RelationGetNumberOfAttributes(rel)); namestrcpy(&nameattrdata, new_name); values[Anum_name - 1] = NameGetDatum(&nameattrdata); replaces[Anum_name - 1] = true; @@ -798,9 +798,9 @@ AlterObjectNamespace_internal(Relation rel, Oid objid, Oid nspOid) nspOid); /* Build modified tuple */ - values = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(Datum)); - nulls = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(bool)); - replaces = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(bool)); + values = palloc0_array(Datum, RelationGetNumberOfAttributes(rel)); + nulls = palloc0_array(bool, RelationGetNumberOfAttributes(rel)); + replaces = palloc0_array(bool, RelationGetNumberOfAttributes(rel)); values[Anum_namespace - 1] = ObjectIdGetDatum(nspOid); replaces[Anum_namespace - 1] = true; newtup = heap_modify_tuple(tup, RelationGetDescr(rel), @@ -1024,9 +1024,9 @@ AlterObjectOwner_internal(Oid classId, Oid objectId, Oid new_ownerId) /* Build a modified tuple */ nattrs = RelationGetNumberOfAttributes(rel); - values = palloc0(nattrs * sizeof(Datum)); - nulls = palloc0(nattrs * sizeof(bool)); - replaces = palloc0(nattrs * sizeof(bool)); + values = palloc0_array(Datum, nattrs); + nulls = palloc0_array(bool, nattrs); + replaces = palloc0_array(bool, nattrs); values[Anum_owner - 1] = ObjectIdGetDatum(new_ownerId); replaces[Anum_owner - 1] = true; diff --git a/src/backend/commands/analyze.c b/src/backend/commands/analyze.c index c28b9dae983..c3ad6d33e86 100644 --- a/src/backend/commands/analyze.c +++ b/src/backend/commands/analyze.c @@ -397,8 +397,7 @@ do_analyze_rel(Relation onerel, const VacuumParams *params, { ListCell *le; - vacattrstats = (VacAttrStats **) palloc(list_length(va_cols) * - sizeof(VacAttrStats *)); + vacattrstats = palloc_array(VacAttrStats *, list_length(va_cols)); tcnt = 0; foreach(le, va_cols) { @@ -415,8 +414,7 @@ do_analyze_rel(Relation onerel, const VacuumParams *params, else { attr_cnt = onerel->rd_att->natts; - vacattrstats = (VacAttrStats **) - palloc(attr_cnt * sizeof(VacAttrStats *)); + vacattrstats = palloc_array(VacAttrStats *, attr_cnt); tcnt = 0; for (i = 1; i <= attr_cnt; i++) { @@ -459,7 +457,7 @@ do_analyze_rel(Relation onerel, const VacuumParams *params, indexdata = NULL; if (nindexes > 0) { - indexdata = (AnlIndexData *) palloc0(nindexes * sizeof(AnlIndexData)); + indexdata = palloc0_array(AnlIndexData, nindexes); for (ind = 0; ind < nindexes; ind++) { AnlIndexData *thisdata = &indexdata[ind]; @@ -471,8 +469,8 @@ do_analyze_rel(Relation onerel, const VacuumParams *params, { ListCell *indexpr_item = list_head(indexInfo->ii_Expressions); - thisdata->vacattrstats = (VacAttrStats **) - palloc(indexInfo->ii_NumIndexAttrs * sizeof(VacAttrStats *)); + thisdata->vacattrstats = palloc_array(VacAttrStats *, + indexInfo->ii_NumIndexAttrs); tcnt = 0; for (i = 0; i < indexInfo->ii_NumIndexAttrs; i++) { @@ -535,7 +533,7 @@ do_analyze_rel(Relation onerel, const VacuumParams *params, /* * Acquire the sample rows */ - rows = (HeapTuple *) palloc(targrows * sizeof(HeapTuple)); + rows = palloc_array(HeapTuple, targrows); pgstat_progress_update_param(PROGRESS_ANALYZE_PHASE, inh ? PROGRESS_ANALYZE_PHASE_ACQUIRE_SAMPLE_ROWS_INH : PROGRESS_ANALYZE_PHASE_ACQUIRE_SAMPLE_ROWS); @@ -930,8 +928,8 @@ compute_index_stats(Relation onerel, double totalrows, predicate = ExecPrepareQual(indexInfo->ii_Predicate, estate); /* Compute and save index expression values */ - exprvals = (Datum *) palloc(numrows * attr_cnt * sizeof(Datum)); - exprnulls = (bool *) palloc(numrows * attr_cnt * sizeof(bool)); + exprvals = palloc_array(Datum, numrows * attr_cnt); + exprnulls = palloc_array(bool, numrows * attr_cnt); numindexrows = 0; tcnt = 0; for (rowno = 0; rowno < numrows; rowno++) @@ -1497,10 +1495,9 @@ acquire_inherited_sample_rows(Relation onerel, int elevel, * Identify acquirefuncs to use, and count blocks in all the relations. * The result could overflow BlockNumber, so we use double arithmetic. */ - rels = (Relation *) palloc(list_length(tableOIDs) * sizeof(Relation)); - acquirefuncs = (AcquireSampleRowsFunc *) - palloc(list_length(tableOIDs) * sizeof(AcquireSampleRowsFunc)); - relblocks = (double *) palloc(list_length(tableOIDs) * sizeof(double)); + rels = palloc_array(Relation, list_length(tableOIDs)); + acquirefuncs = palloc_array(AcquireSampleRowsFunc, list_length(tableOIDs)); + relblocks = palloc_array(double, list_length(tableOIDs)); totalblocks = 0; nrels = 0; has_child = false; @@ -1775,7 +1772,7 @@ update_attstats(Oid relid, bool inh, int natts, VacAttrStats **vacattrstats) if (stats->stanumbers[k] != NULL) { int nnum = stats->numnumbers[k]; - Datum *numdatums = (Datum *) palloc(nnum * sizeof(Datum)); + Datum *numdatums = palloc_array(Datum, nnum); ArrayType *arry; for (n = 0; n < nnum; n++) @@ -2148,7 +2145,7 @@ compute_distinct_stats(VacAttrStatsP stats, track_max = 2 * num_mcv; if (track_max < 10) track_max = 10; - track = (TrackItem *) palloc(track_max * sizeof(TrackItem)); + track = palloc_array(TrackItem, track_max); track_cnt = 0; fmgr_info(mystats->eqfunc, &f_cmpeq); @@ -2385,7 +2382,7 @@ compute_distinct_stats(VacAttrStatsP stats, if (num_mcv > 0) { - mcv_counts = (int *) palloc(num_mcv * sizeof(int)); + mcv_counts = palloc_array(int, num_mcv); for (i = 0; i < num_mcv; i++) mcv_counts[i] = track[i].count; @@ -2405,8 +2402,8 @@ compute_distinct_stats(VacAttrStatsP stats, /* Must copy the target values into anl_context */ old_context = MemoryContextSwitchTo(stats->anl_context); - mcv_values = (Datum *) palloc(num_mcv * sizeof(Datum)); - mcv_freqs = (float4 *) palloc(num_mcv * sizeof(float4)); + mcv_values = palloc_array(Datum, num_mcv); + mcv_freqs = palloc_array(float4, num_mcv); for (i = 0; i < num_mcv; i++) { mcv_values[i] = datumCopy(track[i].value, @@ -2484,9 +2481,9 @@ compute_scalar_stats(VacAttrStatsP stats, int num_bins = stats->attstattarget; StdAnalyzeData *mystats = (StdAnalyzeData *) stats->extra_data; - values = (ScalarItem *) palloc(samplerows * sizeof(ScalarItem)); - tupnoLink = (int *) palloc(samplerows * sizeof(int)); - track = (ScalarMCVItem *) palloc(num_mcv * sizeof(ScalarMCVItem)); + values = palloc_array(ScalarItem, samplerows); + tupnoLink = palloc_array(int, samplerows); + track = palloc_array(ScalarMCVItem, num_mcv); memset(&ssup, 0, sizeof(ssup)); ssup.ssup_cxt = CurrentMemoryContext; @@ -2750,7 +2747,7 @@ compute_scalar_stats(VacAttrStatsP stats, if (num_mcv > 0) { - mcv_counts = (int *) palloc(num_mcv * sizeof(int)); + mcv_counts = palloc_array(int, num_mcv); for (i = 0; i < num_mcv; i++) mcv_counts[i] = track[i].count; @@ -2770,8 +2767,8 @@ compute_scalar_stats(VacAttrStatsP stats, /* Must copy the target values into anl_context */ old_context = MemoryContextSwitchTo(stats->anl_context); - mcv_values = (Datum *) palloc(num_mcv * sizeof(Datum)); - mcv_freqs = (float4 *) palloc(num_mcv * sizeof(float4)); + mcv_values = palloc_array(Datum, num_mcv); + mcv_freqs = palloc_array(float4, num_mcv); for (i = 0; i < num_mcv; i++) { mcv_values[i] = datumCopy(values[track[i].first].value, @@ -2865,7 +2862,7 @@ compute_scalar_stats(VacAttrStatsP stats, /* Must copy the target values into anl_context */ old_context = MemoryContextSwitchTo(stats->anl_context); - hist_values = (Datum *) palloc(num_hist * sizeof(Datum)); + hist_values = palloc_array(Datum, num_hist); /* * The object of this loop is to copy the first and last values[] diff --git a/src/backend/commands/async.c b/src/backend/commands/async.c index 2799f989b96..4069dde3ba6 100644 --- a/src/backend/commands/async.c +++ b/src/backend/commands/async.c @@ -1109,7 +1109,7 @@ pg_listening_channels(PG_FUNCTION_ARGS) MemoryContext oldcontext; oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx); - status = (HASH_SEQ_STATUS *) palloc(sizeof(HASH_SEQ_STATUS)); + status = palloc_object(HASH_SEQ_STATUS); hash_seq_init(status, localChannelTable); funcctx->user_fctx = status; MemoryContextSwitchTo(oldcontext); diff --git a/src/backend/commands/collationcmds.c b/src/backend/commands/collationcmds.c index 0bc31ec2b6f..cfa0e4610d9 100644 --- a/src/backend/commands/collationcmds.c +++ b/src/backend/commands/collationcmds.c @@ -867,7 +867,7 @@ pg_import_system_collations(PG_FUNCTION_ARGS) /* expansible array of aliases */ maxaliases = 100; - aliases = (CollAliasData *) palloc(maxaliases * sizeof(CollAliasData)); + aliases = palloc_array(CollAliasData, maxaliases); naliases = 0; locale_a_handle = OpenPipeStream("locale -a", "r"); @@ -911,8 +911,7 @@ pg_import_system_collations(PG_FUNCTION_ARGS) if (naliases >= maxaliases) { maxaliases *= 2; - aliases = (CollAliasData *) - repalloc(aliases, maxaliases * sizeof(CollAliasData)); + aliases = repalloc_array(aliases, CollAliasData, maxaliases); } aliases[naliases].localename = pstrdup(localebuf); aliases[naliases].alias = pstrdup(alias); diff --git a/src/backend/commands/copyfrom.c b/src/backend/commands/copyfrom.c index 80a527ed4c6..3782db171be 100644 --- a/src/backend/commands/copyfrom.c +++ b/src/backend/commands/copyfrom.c @@ -194,7 +194,7 @@ CopyFromTextLikeStart(CopyFromState cstate, TupleDesc tupDesc) */ attr_count = list_length(cstate->attnumlist); cstate->max_fields = attr_count; - cstate->raw_fields = (char **) palloc(attr_count * sizeof(char *)); + cstate->raw_fields = palloc_array(char *, attr_count); } /* @@ -1595,7 +1595,7 @@ BeginCopyFrom(ParseState *pstate, num_phys_attrs = tupDesc->natts; /* Convert FORCE_NOT_NULL name list to per-column flags, check validity */ - cstate->opts.force_notnull_flags = (bool *) palloc0(num_phys_attrs * sizeof(bool)); + cstate->opts.force_notnull_flags = palloc0_array(bool, num_phys_attrs); if (cstate->opts.force_notnull_all) MemSet(cstate->opts.force_notnull_flags, true, num_phys_attrs * sizeof(bool)); else if (cstate->opts.force_notnull) @@ -1655,7 +1655,7 @@ BeginCopyFrom(ParseState *pstate, } /* Convert FORCE_NULL name list to per-column flags, check validity */ - cstate->opts.force_null_flags = (bool *) palloc0(num_phys_attrs * sizeof(bool)); + cstate->opts.force_null_flags = palloc0_array(bool, num_phys_attrs); if (cstate->opts.force_null_all) MemSet(cstate->opts.force_null_flags, true, num_phys_attrs * sizeof(bool)); else if (cstate->opts.force_null) @@ -1686,7 +1686,7 @@ BeginCopyFrom(ParseState *pstate, List *attnums; ListCell *cur; - cstate->convert_select_flags = (bool *) palloc0(num_phys_attrs * sizeof(bool)); + cstate->convert_select_flags = palloc0_array(bool, num_phys_attrs); attnums = CopyGetAttnums(tupDesc, cstate->rel, cstate->opts.convert_select); @@ -1773,10 +1773,10 @@ BeginCopyFrom(ParseState *pstate, * the input function), and info about defaults and constraints. (Which * input function we use depends on text/binary format choice.) */ - in_functions = (FmgrInfo *) palloc(num_phys_attrs * sizeof(FmgrInfo)); - typioparams = (Oid *) palloc(num_phys_attrs * sizeof(Oid)); - defmap = (int *) palloc(num_phys_attrs * sizeof(int)); - defexprs = (ExprState **) palloc(num_phys_attrs * sizeof(ExprState *)); + in_functions = palloc_array(FmgrInfo, num_phys_attrs); + typioparams = palloc_array(Oid, num_phys_attrs); + defmap = palloc_array(int, num_phys_attrs); + defexprs = palloc_array(ExprState *, num_phys_attrs); for (int attnum = 1; attnum <= num_phys_attrs; attnum++) { @@ -1842,7 +1842,7 @@ BeginCopyFrom(ParseState *pstate, } } - cstate->defaults = (bool *) palloc0(tupDesc->natts * sizeof(bool)); + cstate->defaults = palloc0_array(bool, tupDesc->natts); /* initialize progress */ pgstat_progress_start_command(PROGRESS_COMMAND_COPY, diff --git a/src/backend/commands/copyfromparse.c b/src/backend/commands/copyfromparse.c index 500810577ad..37750cca13a 100644 --- a/src/backend/commands/copyfromparse.c +++ b/src/backend/commands/copyfromparse.c @@ -1879,7 +1879,7 @@ CopyReadAttributesText(CopyFromState cstate) { cstate->max_fields *= 2; cstate->raw_fields = - repalloc(cstate->raw_fields, cstate->max_fields * sizeof(char *)); + repalloc_array(cstate->raw_fields, char *, cstate->max_fields); } /* Remember start of field on both input and output sides */ @@ -2135,7 +2135,7 @@ CopyReadAttributesCSV(CopyFromState cstate) { cstate->max_fields *= 2; cstate->raw_fields = - repalloc(cstate->raw_fields, cstate->max_fields * sizeof(char *)); + repalloc_array(cstate->raw_fields, char *, cstate->max_fields); } /* Remember start of field on both input and output sides */ diff --git a/src/backend/commands/copyto.c b/src/backend/commands/copyto.c index b0bdfb58104..5850608a3fb 100644 --- a/src/backend/commands/copyto.c +++ b/src/backend/commands/copyto.c @@ -1093,7 +1093,7 @@ BeginCopyTo(ParseState *pstate, num_phys_attrs = tupDesc->natts; /* Convert FORCE_QUOTE name list to per-column flags, check validity */ - cstate->opts.force_quote_flags = (bool *) palloc0(num_phys_attrs * sizeof(bool)); + cstate->opts.force_quote_flags = palloc0_array(bool, num_phys_attrs); if (cstate->opts.force_quote_all) { MemSet(cstate->opts.force_quote_flags, true, num_phys_attrs * sizeof(bool)); @@ -1283,7 +1283,7 @@ DoCopyTo(CopyToState cstate) cstate->fe_msgbuf = makeStringInfo(); /* Get info about the columns we need to process. */ - cstate->out_functions = (FmgrInfo *) palloc(num_phys_attrs * sizeof(FmgrInfo)); + cstate->out_functions = palloc_array(FmgrInfo, num_phys_attrs); foreach(cur, cstate->attnumlist) { int attnum = lfirst_int(cur); diff --git a/src/backend/commands/dbcommands.c b/src/backend/commands/dbcommands.c index a32af9894bf..7e3fc59eafd 100644 --- a/src/backend/commands/dbcommands.c +++ b/src/backend/commands/dbcommands.c @@ -3103,7 +3103,7 @@ remove_dbtablespaces(Oid db_id) return; } - tablespace_ids = (Oid *) palloc(ntblspc * sizeof(Oid)); + tablespace_ids = palloc_array(Oid, ntblspc); i = 0; foreach(cell, ltblspc) tablespace_ids[i++] = lfirst_oid(cell); diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c index f223c12f294..e35e0a649b3 100644 --- a/src/backend/commands/explain.c +++ b/src/backend/commands/explain.c @@ -5194,10 +5194,9 @@ ExplainCreateWorkersState(int num_workers) wstate = palloc_object(ExplainWorkersState); wstate->num_workers = num_workers; - wstate->worker_inited = (bool *) palloc0(num_workers * sizeof(bool)); - wstate->worker_str = (StringInfoData *) - palloc0(num_workers * sizeof(StringInfoData)); - wstate->worker_state_save = (int *) palloc(num_workers * sizeof(int)); + wstate->worker_inited = palloc0_array(bool, num_workers); + wstate->worker_str = palloc0_array(StringInfoData, num_workers); + wstate->worker_state_save = palloc_array(int, num_workers); return wstate; } diff --git a/src/backend/commands/explain_dr.c b/src/backend/commands/explain_dr.c index 3c96061cf32..97166f9c06c 100644 --- a/src/backend/commands/explain_dr.c +++ b/src/backend/commands/explain_dr.c @@ -63,7 +63,7 @@ serialize_prepare_info(SerializeDestReceiver *receiver, if (nattrs <= 0) return; - receiver->finfos = (FmgrInfo *) palloc0(nattrs * sizeof(FmgrInfo)); + receiver->finfos = palloc0_array(FmgrInfo, nattrs); for (int i = 0; i < nattrs; i++) { diff --git a/src/backend/commands/explain_state.c b/src/backend/commands/explain_state.c index a0ee0a664be..35e48bbdc37 100644 --- a/src/backend/commands/explain_state.c +++ b/src/backend/commands/explain_state.c @@ -251,8 +251,7 @@ GetExplainExtensionId(const char *extension_name) { int i = pg_nextpower2_32(ExplainExtensionNamesAssigned + 1); - ExplainExtensionNameArray = (const char **) - repalloc(ExplainExtensionNameArray, i * sizeof(char *)); + ExplainExtensionNameArray = repalloc_array(ExplainExtensionNameArray, const char *, i); ExplainExtensionNamesAllocated = i; } @@ -295,8 +294,7 @@ SetExplainExtensionState(ExplainState *es, int extension_id, void *opaque) { es->extension_state_allocated = Max(16, pg_nextpower2_32(extension_id + 1)); - es->extension_state = - palloc0(es->extension_state_allocated * sizeof(void *)); + es->extension_state = palloc0_array(void *, es->extension_state_allocated); } /* If there's an array but it's currently full, expand it. */ @@ -367,8 +365,8 @@ RegisterExtensionExplainOption(const char *option_name, { int i = pg_nextpower2_32(ExplainExtensionOptionsAssigned + 1); - ExplainExtensionOptionArray = (ExplainExtensionOption *) - repalloc(ExplainExtensionOptionArray, i * sizeof(ExplainExtensionOption)); + ExplainExtensionOptionArray = repalloc_array(ExplainExtensionOptionArray, + ExplainExtensionOption, i); ExplainExtensionOptionsAllocated = i; } diff --git a/src/backend/commands/extension.c b/src/backend/commands/extension.c index ae03f20c343..f7e7395c173 100644 --- a/src/backend/commands/extension.c +++ b/src/backend/commands/extension.c @@ -2751,7 +2751,7 @@ convert_requires_to_datum(List *requires) ListCell *lc; ndatums = list_length(requires); - datums = (Datum *) palloc(ndatums * sizeof(Datum)); + datums = palloc_array(Datum, ndatums); ndatums = 0; foreach(lc, requires) { diff --git a/src/backend/commands/functioncmds.c b/src/backend/commands/functioncmds.c index 3afd762e9dc..ba24a708982 100644 --- a/src/backend/commands/functioncmds.c +++ b/src/backend/commands/functioncmds.c @@ -213,10 +213,10 @@ interpret_function_parameter_list(ParseState *pstate, *variadicArgType = InvalidOid; /* default result */ *requiredResultType = InvalidOid; /* default result */ - inTypes = (Oid *) palloc(parameterCount * sizeof(Oid)); - allTypes = (Datum *) palloc(parameterCount * sizeof(Datum)); - paramModes = (Datum *) palloc(parameterCount * sizeof(Datum)); - paramNames = (Datum *) palloc0(parameterCount * sizeof(Datum)); + inTypes = palloc_array(Oid, parameterCount); + allTypes = palloc_array(Datum, parameterCount); + paramModes = palloc_array(Datum, parameterCount); + paramNames = palloc0_array(Datum, parameterCount); *parameterDefaults = NIL; /* Scan the list and extract data into work arrays */ @@ -918,8 +918,8 @@ interpret_AS_clause(Oid languageOid, const char *languageName, pinfo->fname = funcname; pinfo->nargs = list_length(parameterTypes); - pinfo->argtypes = (Oid *) palloc(pinfo->nargs * sizeof(Oid)); - pinfo->argnames = (char **) palloc(pinfo->nargs * sizeof(char *)); + pinfo->argtypes = palloc_array(Oid, pinfo->nargs); + pinfo->argnames = palloc_array(char *, pinfo->nargs); for (int i = 0; i < list_length(parameterTypes); i++) { char *s = strVal(list_nth(inParameterNames, i)); @@ -1227,7 +1227,7 @@ CreateFunction(ParseState *pstate, CreateFunctionStmt *stmt) Datum *arr; int i; - arr = palloc(list_length(trftypes_list) * sizeof(Datum)); + arr = palloc_array(Datum, list_length(trftypes_list)); i = 0; foreach(lc, trftypes_list) arr[i++] = ObjectIdGetDatum(lfirst_oid(lc)); diff --git a/src/backend/commands/policy.c b/src/backend/commands/policy.c index 1b4b1ee41ce..e57cc30b570 100644 --- a/src/backend/commands/policy.c +++ b/src/backend/commands/policy.c @@ -163,7 +163,7 @@ policy_role_list_to_array(List *roles, int *num_roles) } *num_roles = list_length(roles); - role_oids = (Datum *) palloc(*num_roles * sizeof(Datum)); + role_oids = palloc_array(Datum, *num_roles); foreach(cell, roles) { diff --git a/src/backend/commands/subscriptioncmds.c b/src/backend/commands/subscriptioncmds.c index 9938f4b7fe3..6e805394808 100644 --- a/src/backend/commands/subscriptioncmds.c +++ b/src/backend/commands/subscriptioncmds.c @@ -1175,8 +1175,8 @@ AlterSubscription_refresh(Subscription *sub, bool copy_data, * allocate separate arrays for table OIDs and sequence OIDs based on * the total number of relations (subrel_count). */ - subrel_local_oids = palloc(subrel_count * sizeof(Oid)); - subseq_local_oids = palloc(subrel_count * sizeof(Oid)); + subrel_local_oids = palloc_array(Oid, subrel_count); + subseq_local_oids = palloc_array(Oid, subrel_count); foreach(lc, subrel_states) { SubscriptionRelState *relstate = (SubscriptionRelState *) lfirst(lc); @@ -1208,7 +1208,7 @@ AlterSubscription_refresh(Subscription *sub, bool copy_data, * step. */ off = 0; - pubrel_local_oids = palloc(list_length(pubrels) * sizeof(Oid)); + pubrel_local_oids = palloc_array(Oid, list_length(pubrels)); foreach_ptr(PublicationRelKind, pubrelinfo, pubrels) { diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c index 8349e724c2b..12beb37246f 100644 --- a/src/backend/commands/tablecmds.c +++ b/src/backend/commands/tablecmds.c @@ -2171,8 +2171,7 @@ ExecuteTruncateGuts(List *explicit_rels, * ExecGetTriggerResultRel() find them. */ estate = CreateExecutorState(); - resultRelInfos = (ResultRelInfo *) - palloc(list_length(rels) * sizeof(ResultRelInfo)); + resultRelInfos = palloc_array(ResultRelInfo, list_length(rels)); resultRelInfo = resultRelInfos; foreach(cell, rels) { @@ -2379,7 +2378,7 @@ ExecuteTruncateGuts(List *explicit_rels, /* should only get here if effective_wal_level is 'logical' */ Assert(XLogLogicalInfoActive()); - logrelids = palloc(list_length(relids_logged) * sizeof(Oid)); + logrelids = palloc_array(Oid, list_length(relids_logged)); foreach(cell, relids_logged) logrelids[i++] = lfirst_oid(cell); @@ -23678,7 +23677,7 @@ collectPartitionIndexExtDeps(List *partitionOids) if (!OidIsValid(parentIndexOid)) continue; - entry = palloc(sizeof(PartitionIndexExtDepEntry)); + entry = palloc_object(PartitionIndexExtDepEntry); entry->parentIndexOid = parentIndexOid; entry->indexOid = indexOid; entry->extensionOids = getAutoExtensionsOfObject(RelationRelationId, diff --git a/src/backend/commands/tablespace.c b/src/backend/commands/tablespace.c index d91fcf0facf..e3c4a7fac87 100644 --- a/src/backend/commands/tablespace.c +++ b/src/backend/commands/tablespace.c @@ -1241,7 +1241,7 @@ check_temp_tablespaces(char **newval, void **extra, GucSource source) ListCell *l; /* temporary workspace until we are done verifying the list */ - tblSpcs = (Oid *) palloc(list_length(namelist) * sizeof(Oid)); + tblSpcs = palloc_array(Oid, list_length(namelist)); numSpcs = 0; foreach(l, namelist) { diff --git a/src/backend/commands/trigger.c b/src/backend/commands/trigger.c index e2581a7b7c7..b7881bf4a29 100644 --- a/src/backend/commands/trigger.c +++ b/src/backend/commands/trigger.c @@ -946,7 +946,7 @@ CreateTriggerFiringOn(const CreateTrigStmt *stmt, const char *queryString, ListCell *cell; int i = 0; - columns = (int16 *) palloc(ncolumns * sizeof(int16)); + columns = palloc_array(int16, ncolumns); foreach(cell, stmt->columns) { char *name = strVal(lfirst(cell)); @@ -1908,7 +1908,7 @@ RelationBuildTriggers(Relation relation) * necessary) */ maxtrigs = 16; - triggers = (Trigger *) palloc(maxtrigs * sizeof(Trigger)); + triggers = palloc_array(Trigger, maxtrigs); numtrigs = 0; /* @@ -1936,7 +1936,7 @@ RelationBuildTriggers(Relation relation) if (numtrigs >= maxtrigs) { maxtrigs *= 2; - triggers = (Trigger *) repalloc(triggers, maxtrigs * sizeof(Trigger)); + triggers = repalloc_array(triggers, Trigger, maxtrigs); } build = &(triggers[numtrigs]); @@ -1958,7 +1958,7 @@ RelationBuildTriggers(Relation relation) build->tgnattr = pg_trigger->tgattr.dim1; if (build->tgnattr > 0) { - build->tgattr = (int16 *) palloc(build->tgnattr * sizeof(int16)); + build->tgattr = palloc_array(int16, build->tgnattr); memcpy(build->tgattr, &(pg_trigger->tgattr.values), build->tgnattr * sizeof(int16)); } @@ -1976,7 +1976,7 @@ RelationBuildTriggers(Relation relation) elog(ERROR, "tgargs is null in trigger for relation \"%s\"", RelationGetRelationName(relation)); p = (char *) VARDATA_ANY(val); - build->tgargs = (char **) palloc(build->tgnargs * sizeof(char *)); + build->tgargs = palloc_array(char *, build->tgnargs); for (i = 0; i < build->tgnargs; i++) { build->tgargs[i] = pstrdup(p); @@ -2131,7 +2131,7 @@ CopyTriggerDesc(TriggerDesc *trigdesc) newdesc = palloc_object(TriggerDesc); memcpy(newdesc, trigdesc, sizeof(TriggerDesc)); - trigger = (Trigger *) palloc(trigdesc->numtriggers * sizeof(Trigger)); + trigger = palloc_array(Trigger, trigdesc->numtriggers); memcpy(trigger, trigdesc->triggers, trigdesc->numtriggers * sizeof(Trigger)); newdesc->triggers = trigger; @@ -2143,7 +2143,7 @@ CopyTriggerDesc(TriggerDesc *trigdesc) { int16 *newattr; - newattr = (int16 *) palloc(trigger->tgnattr * sizeof(int16)); + newattr = palloc_array(int16, trigger->tgnattr); memcpy(newattr, trigger->tgattr, trigger->tgnattr * sizeof(int16)); trigger->tgattr = newattr; @@ -2153,7 +2153,7 @@ CopyTriggerDesc(TriggerDesc *trigdesc) char **newargs; int16 j; - newargs = (char **) palloc(trigger->tgnargs * sizeof(char *)); + newargs = palloc_array(char *, trigger->tgnargs); for (j = 0; j < trigger->tgnargs; j++) newargs[j] = pstrdup(trigger->tgargs[j]); trigger->tgargs = newargs; @@ -5507,9 +5507,8 @@ AfterTriggerBeginSubXact(void) /* repalloc will keep the stack in the same context */ int new_alloc = afterTriggers.maxtransdepth * 2; - afterTriggers.trans_stack = (AfterTriggersTransData *) - repalloc(afterTriggers.trans_stack, - new_alloc * sizeof(AfterTriggersTransData)); + afterTriggers.trans_stack = repalloc_array(afterTriggers.trans_stack, + AfterTriggersTransData, new_alloc); afterTriggers.maxtransdepth = new_alloc; } } @@ -5762,9 +5761,8 @@ AfterTriggerEnlargeQueryState(void) int new_alloc = Max(afterTriggers.query_depth + 1, old_alloc * 2); - afterTriggers.query_stack = (AfterTriggersQueryData *) - repalloc(afterTriggers.query_stack, - new_alloc * sizeof(AfterTriggersQueryData)); + afterTriggers.query_stack = repalloc_array(afterTriggers.query_stack, + AfterTriggersQueryData, new_alloc); afterTriggers.maxquerydepth = new_alloc; } @@ -6891,7 +6889,7 @@ RegisterAfterTriggerBatchCallback(AfterTriggerBatchCallback callback, Assert(afterTriggers.firing_depth > 0); Assert(!afterTriggers.firing_batch_callbacks); oldcxt = MemoryContextSwitchTo(TopTransactionContext); - item = palloc(sizeof(AfterTriggerCallbackItem)); + item = palloc_object(AfterTriggerCallbackItem); item->callback = callback; item->arg = arg; if (afterTriggers.query_depth >= 0) diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c index 31f9824899c..6024bf2df31 100644 --- a/src/backend/commands/vacuum.c +++ b/src/backend/commands/vacuum.c @@ -2405,7 +2405,7 @@ vac_open_indexes(Relation relation, LOCKMODE lockmode, i = list_length(indexoidlist); if (i > 0) - *Irel = (Relation *) palloc(i * sizeof(Relation)); + *Irel = palloc_array(Relation, i); else *Irel = NULL; diff --git a/src/backend/executor/execExpr.c b/src/backend/executor/execExpr.c index cfea7e160c2..82e846a1f4f 100644 --- a/src/backend/executor/execExpr.c +++ b/src/backend/executor/execExpr.c @@ -1745,7 +1745,7 @@ ExecInitExprRec(Expr *node, ExprState *state, ExprEvalRowtypeCache *rowcachep; /* cache structs must be out-of-line for space reasons */ - rowcachep = palloc(2 * sizeof(ExprEvalRowtypeCache)); + rowcachep = palloc_array(ExprEvalRowtypeCache, 2); rowcachep[0].cacheptr = NULL; rowcachep[1].cacheptr = NULL; @@ -2678,8 +2678,7 @@ ExprEvalPushStep(ExprState *es, const ExprEvalStep *s) else if (es->steps_alloc == es->steps_len) { es->steps_alloc *= 2; - es->steps = repalloc(es->steps, - sizeof(ExprEvalStep) * es->steps_alloc); + es->steps = repalloc_array(es->steps, ExprEvalStep, es->steps_alloc); } memcpy(&es->steps[es->steps_len++], s, sizeof(ExprEvalStep)); diff --git a/src/backend/executor/execExprInterp.c b/src/backend/executor/execExprInterp.c index 9bc23cb16fa..397219f7a3a 100644 --- a/src/backend/executor/execExprInterp.c +++ b/src/backend/executor/execExprInterp.c @@ -3457,10 +3457,10 @@ ExecEvalArrayExpr(ExprState *state, ExprEvalStep *op) char *dat; int iitem; - subdata = (char **) palloc(nelems * sizeof(char *)); - subbitmaps = (uint8 **) palloc(nelems * sizeof(uint8 *)); - subbytes = (int *) palloc(nelems * sizeof(int)); - subnitems = (int *) palloc(nelems * sizeof(int)); + subdata = palloc_array(char *, nelems); + subbitmaps = palloc_array(uint8 *, nelems); + subbytes = palloc_array(int, nelems); + subnitems = palloc_array(int, nelems); /* loop through and get data area from each element */ for (int elemoff = 0; elemoff < nelems; elemoff++) @@ -3511,9 +3511,9 @@ ExecEvalArrayExpr(ExprState *state, ExprEvalStep *op) errmsg("number of array dimensions (%d) exceeds the maximum allowed (%d)", ndims, MAXDIM))); - elem_dims = (int *) palloc(elem_ndims * sizeof(int)); + elem_dims = palloc_array(int, elem_ndims); memcpy(elem_dims, ARR_DIMS(array), elem_ndims * sizeof(int)); - elem_lbs = (int *) palloc(elem_ndims * sizeof(int)); + elem_lbs = palloc_array(int, elem_ndims); memcpy(elem_lbs, ARR_LBOUND(array), elem_ndims * sizeof(int)); firstone = false; diff --git a/src/backend/executor/execGrouping.c b/src/backend/executor/execGrouping.c index c107514a85d..feee88294aa 100644 --- a/src/backend/executor/execGrouping.c +++ b/src/backend/executor/execGrouping.c @@ -72,7 +72,7 @@ execTuplesMatchPrepare(TupleDesc desc, if (numCols == 0) return NULL; - eqFunctions = (Oid *) palloc(numCols * sizeof(Oid)); + eqFunctions = palloc_array(Oid, numCols); /* lookup equality functions */ for (i = 0; i < numCols; i++) @@ -104,8 +104,8 @@ execTuplesHashPrepare(int numCols, { int i; - *eqFuncOids = (Oid *) palloc(numCols * sizeof(Oid)); - *hashFunctions = (FmgrInfo *) palloc(numCols * sizeof(FmgrInfo)); + *eqFuncOids = palloc_array(Oid, numCols); + *hashFunctions = palloc_array(FmgrInfo, numCols); for (i = 0; i < numCols; i++) { diff --git a/src/backend/executor/execJunk.c b/src/backend/executor/execJunk.c index 3736bea3b3c..02494e1f20d 100644 --- a/src/backend/executor/execJunk.c +++ b/src/backend/executor/execJunk.c @@ -93,7 +93,7 @@ ExecInitJunkFilter(List *targetList, TupleTableSlot *slot) AttrNumber cleanResno; ListCell *t; - cleanMap = (AttrNumber *) palloc(cleanLength * sizeof(AttrNumber)); + cleanMap = palloc_array(AttrNumber, cleanLength); cleanResno = 0; foreach(t, targetList) { @@ -165,7 +165,7 @@ ExecInitJunkFilterConversion(List *targetList, cleanLength = cleanTupType->natts; if (cleanLength > 0) { - cleanMap = (AttrNumber *) palloc0(cleanLength * sizeof(AttrNumber)); + cleanMap = palloc0_array(AttrNumber, cleanLength); t = list_head(targetList); for (i = 0; i < cleanLength; i++) { diff --git a/src/backend/executor/execParallel.c b/src/backend/executor/execParallel.c index 81b87d82fab..6b85508a696 100644 --- a/src/backend/executor/execParallel.c +++ b/src/backend/executor/execParallel.c @@ -609,8 +609,7 @@ ExecParallelSetupTupleQueues(ParallelContext *pcxt, bool reinitialize) return NULL; /* Allocate memory for shared memory queue handles. */ - responseq = (shm_mq_handle **) - palloc(pcxt->nworkers * sizeof(shm_mq_handle *)); + responseq = palloc_array(shm_mq_handle *, pcxt->nworkers); /* * If not reinitializing, allocate space from the DSM for the queues; @@ -950,8 +949,7 @@ ExecParallelCreateReaders(ParallelExecutorInfo *pei) if (nworkers > 0) { - pei->reader = (TupleQueueReader **) - palloc(nworkers * sizeof(TupleQueueReader *)); + pei->reader = palloc_array(TupleQueueReader *, nworkers); for (i = 0; i < nworkers; i++) { diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c index 9b4738884af..0e938cfea1f 100644 --- a/src/backend/executor/execPartition.c +++ b/src/backend/executor/execPartition.c @@ -1246,12 +1246,10 @@ ExecInitRoutingInfo(ModifyTableState *mtstate, else { proute->max_partitions *= 2; - proute->partitions = (ResultRelInfo **) - repalloc(proute->partitions, sizeof(ResultRelInfo *) * - proute->max_partitions); - proute->is_borrowed_rel = (bool *) - repalloc(proute->is_borrowed_rel, sizeof(bool) * - proute->max_partitions); + proute->partitions = repalloc_array(proute->partitions, + ResultRelInfo *, proute->max_partitions); + proute->is_borrowed_rel = repalloc_array(proute->is_borrowed_rel, + bool, proute->max_partitions); } } @@ -1362,12 +1360,12 @@ ExecInitPartitionDispatchInfo(EState *estate, else { proute->max_dispatch *= 2; - proute->partition_dispatch_info = (PartitionDispatch *) - repalloc(proute->partition_dispatch_info, - sizeof(PartitionDispatch) * proute->max_dispatch); - proute->nonleaf_partitions = (ResultRelInfo **) - repalloc(proute->nonleaf_partitions, - sizeof(ResultRelInfo *) * proute->max_dispatch); + proute->partition_dispatch_info = repalloc_array(proute->partition_dispatch_info, + PartitionDispatch, + proute->max_dispatch); + proute->nonleaf_partitions = repalloc_array(proute->nonleaf_partitions, + ResultRelInfo *, + proute->max_dispatch); } } proute->partition_dispatch_info[dispatchidx] = pd; diff --git a/src/backend/executor/execSRF.c b/src/backend/executor/execSRF.c index 8aedcc6a459..f839f3bbde7 100644 --- a/src/backend/executor/execSRF.c +++ b/src/backend/executor/execSRF.c @@ -339,7 +339,7 @@ ExecMakeTableFunctionResult(SetExprState *setexpr, int natts = expectedDesc->natts; bool *nullflags; - nullflags = (bool *) palloc(natts * sizeof(bool)); + nullflags = palloc_array(bool, natts); memset(nullflags, true, natts * sizeof(bool)); tuplestore_putvalues(tupstore, expectedDesc, NULL, nullflags); } @@ -407,7 +407,7 @@ no_function_result: int natts = expectedDesc->natts; bool *nullflags; - nullflags = (bool *) palloc(natts * sizeof(bool)); + nullflags = palloc_array(bool, natts); memset(nullflags, true, natts * sizeof(bool)); tuplestore_putvalues(tupstore, expectedDesc, NULL, nullflags); } diff --git a/src/backend/executor/execTuples.c b/src/backend/executor/execTuples.c index 3ad983c7fa5..b8e8f52c64c 100644 --- a/src/backend/executor/execTuples.c +++ b/src/backend/executor/execTuples.c @@ -2389,9 +2389,9 @@ TupleDescGetAttInMetadata(TupleDesc tupdesc) /* * Gather info needed later to call the "in" function for each attribute */ - attinfuncinfo = (FmgrInfo *) palloc0(natts * sizeof(FmgrInfo)); - attioparams = (Oid *) palloc0(natts * sizeof(Oid)); - atttypmods = (int32 *) palloc0(natts * sizeof(int32)); + attinfuncinfo = palloc0_array(FmgrInfo, natts); + attioparams = palloc0_array(Oid, natts); + atttypmods = palloc0_array(int32, natts); for (i = 0; i < natts; i++) { @@ -2428,8 +2428,8 @@ BuildTupleFromCStrings(AttInMetadata *attinmeta, char **values) int i; HeapTuple tuple; - dvalues = (Datum *) palloc(natts * sizeof(Datum)); - nulls = (bool *) palloc(natts * sizeof(bool)); + dvalues = palloc_array(Datum, natts); + nulls = palloc_array(bool, natts); /* * Call the "in" function for each non-dropped attribute, even for nulls, diff --git a/src/backend/executor/execUtils.c b/src/backend/executor/execUtils.c index 1eb6b9f1f40..c0c4276acbf 100644 --- a/src/backend/executor/execUtils.c +++ b/src/backend/executor/execUtils.c @@ -822,8 +822,7 @@ ExecInitRangeTable(EState *estate, List *rangeTable, List *permInfos, * rangetable entry, and initialize entries to NULL. Relations are opened * and stored here as needed. */ - estate->es_relations = (Relation *) - palloc0(estate->es_range_table_size * sizeof(Relation)); + estate->es_relations = palloc0_array(Relation, estate->es_range_table_size); /* * es_result_relations and es_rowmarks are also parallel to @@ -916,8 +915,8 @@ ExecInitResultRelation(EState *estate, ResultRelInfo *resultRelInfo, estate->es_instrument); if (estate->es_result_relations == NULL) - estate->es_result_relations = (ResultRelInfo **) - palloc0(estate->es_range_table_size * sizeof(ResultRelInfo *)); + estate->es_result_relations = palloc0_array(ResultRelInfo *, + estate->es_range_table_size); estate->es_result_relations[rti - 1] = resultRelInfo; /* diff --git a/src/backend/executor/functions.c b/src/backend/executor/functions.c index 88109348817..8fec79a2f76 100644 --- a/src/backend/executor/functions.c +++ b/src/backend/executor/functions.c @@ -275,7 +275,7 @@ prepare_sql_fn_parse_info(HeapTuple procedureTuple, Oid *argOidVect; int argnum; - argOidVect = (Oid *) palloc(nargs * sizeof(Oid)); + argOidVect = palloc_array(Oid, nargs); memcpy(argOidVect, procedureStruct->proargtypes.values, nargs * sizeof(Oid)); diff --git a/src/backend/executor/nodeAgg.c b/src/backend/executor/nodeAgg.c index 925caadd2ce..962cd9c8255 100644 --- a/src/backend/executor/nodeAgg.c +++ b/src/backend/executor/nodeAgg.c @@ -1633,10 +1633,8 @@ find_hash_columns(AggState *aggstate) */ maxCols = bms_num_members(colnos) + perhash->numCols; - perhash->hashGrpColIdxInput = - palloc(maxCols * sizeof(AttrNumber)); - perhash->hashGrpColIdxHash = - palloc(perhash->numCols * sizeof(AttrNumber)); + perhash->hashGrpColIdxInput = palloc_array(AttrNumber, maxCols); + perhash->hashGrpColIdxHash = palloc_array(AttrNumber, perhash->numCols); /* Add all the grouping columns to colnos */ for (i = 0; i < perhash->numCols; i++) @@ -3560,8 +3558,8 @@ ExecInitAgg(Agg *node, EState *estate, int eflags) if (num_sets) { - phasedata->gset_lengths = palloc(num_sets * sizeof(int)); - phasedata->grouped_cols = palloc(num_sets * sizeof(Bitmapset *)); + phasedata->gset_lengths = palloc_array(int, num_sets); + phasedata->grouped_cols = palloc_array(Bitmapset *, num_sets); i = 0; foreach(l, aggnode->groupingSets) @@ -4318,14 +4316,10 @@ build_pertrans_for_aggref(AggStatePerTrans pertrans, } /* Extract the sort information for use later */ - pertrans->sortColIdx = - (AttrNumber *) palloc(numSortCols * sizeof(AttrNumber)); - pertrans->sortOperators = - (Oid *) palloc(numSortCols * sizeof(Oid)); - pertrans->sortCollations = - (Oid *) palloc(numSortCols * sizeof(Oid)); - pertrans->sortNullsFirst = - (bool *) palloc(numSortCols * sizeof(bool)); + pertrans->sortColIdx = palloc_array(AttrNumber, numSortCols); + pertrans->sortOperators = palloc_array(Oid, numSortCols); + pertrans->sortCollations = palloc_array(Oid, numSortCols); + pertrans->sortNullsFirst = palloc_array(bool, numSortCols); i = 0; foreach(lc, sortlist) @@ -4352,7 +4346,7 @@ build_pertrans_for_aggref(AggStatePerTrans pertrans, Assert(numArguments > 0); Assert(list_length(aggref->aggdistinct) == numDistinctCols); - ops = palloc(numDistinctCols * sizeof(Oid)); + ops = palloc_array(Oid, numDistinctCols); i = 0; foreach(lc, aggref->aggdistinct) diff --git a/src/backend/executor/nodeAppend.c b/src/backend/executor/nodeAppend.c index 51654b31ad1..06f46fe6501 100644 --- a/src/backend/executor/nodeAppend.c +++ b/src/backend/executor/nodeAppend.c @@ -182,8 +182,7 @@ ExecInitAppend(Append *node, EState *estate, int eflags) appendstate->as_prune_state = NULL; } - appendplanstates = (PlanState **) palloc(nplans * - sizeof(PlanState *)); + appendplanstates = palloc_array(PlanState *, nplans); /* * call ExecInitNode on each of the valid plans to be executed and save @@ -259,8 +258,7 @@ ExecInitAppend(Append *node, EState *estate, int eflags) if (nasyncplans > 0) { - appendstate->as_asyncrequests = (AsyncRequest **) - palloc0(nplans * sizeof(AsyncRequest *)); + appendstate->as_asyncrequests = palloc0_array(AsyncRequest *, nplans); i = -1; while ((i = bms_next_member(asyncplans, i)) >= 0) @@ -278,8 +276,7 @@ ExecInitAppend(Append *node, EState *estate, int eflags) appendstate->as_asyncrequests[i] = areq; } - appendstate->as_asyncresults = (TupleTableSlot **) - palloc0(nasyncplans * sizeof(TupleTableSlot *)); + appendstate->as_asyncresults = palloc0_array(TupleTableSlot *, nasyncplans); if (appendstate->as_valid_subplans_identified) classify_matching_subplans(appendstate); diff --git a/src/backend/executor/nodeBitmapAnd.c b/src/backend/executor/nodeBitmapAnd.c index 64092fa8065..36ad0a7f85c 100644 --- a/src/backend/executor/nodeBitmapAnd.c +++ b/src/backend/executor/nodeBitmapAnd.c @@ -72,7 +72,7 @@ ExecInitBitmapAnd(BitmapAnd *node, EState *estate, int eflags) */ nplans = list_length(node->bitmapplans); - bitmapplanstates = (PlanState **) palloc0(nplans * sizeof(PlanState *)); + bitmapplanstates = palloc0_array(PlanState *, nplans); /* * create new BitmapAndState for our BitmapAnd node diff --git a/src/backend/executor/nodeBitmapOr.c b/src/backend/executor/nodeBitmapOr.c index b98b96172fe..e84f97eebd4 100644 --- a/src/backend/executor/nodeBitmapOr.c +++ b/src/backend/executor/nodeBitmapOr.c @@ -73,7 +73,7 @@ ExecInitBitmapOr(BitmapOr *node, EState *estate, int eflags) */ nplans = list_length(node->bitmapplans); - bitmapplanstates = (PlanState **) palloc0(nplans * sizeof(PlanState *)); + bitmapplanstates = palloc0_array(PlanState *, nplans); /* * create new BitmapOrState for our BitmapOr node diff --git a/src/backend/executor/nodeGather.c b/src/backend/executor/nodeGather.c index 114693abb32..31cd95adee7 100644 --- a/src/backend/executor/nodeGather.c +++ b/src/backend/executor/nodeGather.c @@ -196,8 +196,7 @@ ExecGather(PlanState *pstate) ExecParallelCreateReaders(node->pei); /* Make a working array showing the active readers */ node->nreaders = pcxt->nworkers_launched; - node->reader = (TupleQueueReader **) - palloc(node->nreaders * sizeof(TupleQueueReader *)); + node->reader = palloc_array(TupleQueueReader *, node->nreaders); memcpy(node->reader, node->pei->reader, node->nreaders * sizeof(TupleQueueReader *)); } diff --git a/src/backend/executor/nodeGatherMerge.c b/src/backend/executor/nodeGatherMerge.c index c2ac5e0792c..352a89ab53f 100644 --- a/src/backend/executor/nodeGatherMerge.c +++ b/src/backend/executor/nodeGatherMerge.c @@ -237,8 +237,7 @@ ExecGatherMerge(PlanState *pstate) ExecParallelCreateReaders(node->pei); /* Make a working array showing the active readers */ node->nreaders = pcxt->nworkers_launched; - node->reader = (TupleQueueReader **) - palloc(node->nreaders * sizeof(TupleQueueReader *)); + node->reader = palloc_array(TupleQueueReader *, node->nreaders); memcpy(node->reader, node->pei->reader, node->nreaders * sizeof(TupleQueueReader *)); } @@ -408,12 +407,10 @@ gather_merge_setup(GatherMergeState *gm_state) * scan, we might have fewer than num_workers available workers, in which * case the extra array entries go unused. */ - gm_state->gm_slots = (TupleTableSlot **) - palloc0((nreaders + 1) * sizeof(TupleTableSlot *)); + gm_state->gm_slots = palloc0_array(TupleTableSlot *, nreaders + 1); /* Allocate the tuple slot and tuple array for each worker */ - gm_state->gm_tuple_buffers = (GMReaderTupleBuffer *) - palloc0(nreaders * sizeof(GMReaderTupleBuffer)); + gm_state->gm_tuple_buffers = palloc0_array(GMReaderTupleBuffer, nreaders); for (i = 0; i < nreaders; i++) { diff --git a/src/backend/executor/nodeIncrementalSort.c b/src/backend/executor/nodeIncrementalSort.c index 1d831049b65..f2e92d7cf0b 100644 --- a/src/backend/executor/nodeIncrementalSort.c +++ b/src/backend/executor/nodeIncrementalSort.c @@ -165,9 +165,7 @@ preparePresortedCols(IncrementalSortState *node) { IncrementalSort *plannode = castNode(IncrementalSort, node->ss.ps.plan); - node->presorted_keys = - (PresortedKeyData *) palloc(plannode->nPresortedCols * - sizeof(PresortedKeyData)); + node->presorted_keys = palloc_array(PresortedKeyData, plannode->nPresortedCols); /* Pre-cache comparison functions for each pre-sorted key. */ for (int i = 0; i < plannode->nPresortedCols; i++) diff --git a/src/backend/executor/nodeIndexscan.c b/src/backend/executor/nodeIndexscan.c index 39f6691ee35..6566150cddc 100644 --- a/src/backend/executor/nodeIndexscan.c +++ b/src/backend/executor/nodeIndexscan.c @@ -1035,12 +1035,9 @@ ExecInitIndexScan(IndexScan *node, EState *estate, int eflags) */ Assert(numOrderByKeys == list_length(node->indexorderbyops)); Assert(numOrderByKeys == list_length(node->indexorderbyorig)); - indexstate->iss_SortSupport = (SortSupportData *) - palloc0(numOrderByKeys * sizeof(SortSupportData)); - indexstate->iss_OrderByTypByVals = (bool *) - palloc(numOrderByKeys * sizeof(bool)); - indexstate->iss_OrderByTypLens = (int16 *) - palloc(numOrderByKeys * sizeof(int16)); + indexstate->iss_SortSupport = palloc0_array(SortSupportData, numOrderByKeys); + indexstate->iss_OrderByTypByVals = palloc_array(bool, numOrderByKeys); + indexstate->iss_OrderByTypLens = palloc_array(int16, numOrderByKeys); i = 0; forboth(lco, node->indexorderbyops, lcx, node->indexorderbyorig) { @@ -1068,10 +1065,8 @@ ExecInitIndexScan(IndexScan *node, EState *estate, int eflags) } /* allocate arrays to hold the re-calculated distances */ - indexstate->iss_OrderByValues = (Datum *) - palloc(numOrderByKeys * sizeof(Datum)); - indexstate->iss_OrderByNulls = (bool *) - palloc(numOrderByKeys * sizeof(bool)); + indexstate->iss_OrderByValues = palloc_array(Datum, numOrderByKeys); + indexstate->iss_OrderByNulls = palloc_array(bool, numOrderByKeys); /* and initialize the reorder queue */ indexstate->iss_ReorderQueue = pairingheap_allocate(reorderqueue_cmp, @@ -1182,7 +1177,7 @@ ExecIndexBuildScanKeys(PlanState *planstate, Relation index, /* Allocate array for ScanKey structs: one per qual */ n_scan_keys = list_length(quals); - scan_keys = (ScanKey) palloc(n_scan_keys * sizeof(ScanKeyData)); + scan_keys = palloc_array(ScanKeyData, n_scan_keys); /* * runtime_keys array is dynamically resized as needed. We handle it this @@ -1195,8 +1190,7 @@ ExecIndexBuildScanKeys(PlanState *planstate, Relation index, n_runtime_keys = max_runtime_keys = *numRuntimeKeys; /* Allocate array_keys as large as it could possibly need to be */ - array_keys = (IndexArrayKeyInfo *) - palloc0(n_scan_keys * sizeof(IndexArrayKeyInfo)); + array_keys = palloc0_array(IndexArrayKeyInfo, n_scan_keys); n_array_keys = 0; /* @@ -1286,14 +1280,13 @@ ExecIndexBuildScanKeys(PlanState *planstate, Relation index, if (max_runtime_keys == 0) { max_runtime_keys = 8; - runtime_keys = (IndexRuntimeKeyInfo *) - palloc(max_runtime_keys * sizeof(IndexRuntimeKeyInfo)); + runtime_keys = palloc_array(IndexRuntimeKeyInfo, max_runtime_keys); } else { max_runtime_keys *= 2; - runtime_keys = (IndexRuntimeKeyInfo *) - repalloc(runtime_keys, max_runtime_keys * sizeof(IndexRuntimeKeyInfo)); + runtime_keys = repalloc_array(runtime_keys, + IndexRuntimeKeyInfo, max_runtime_keys); } } runtime_keys[n_runtime_keys].scan_key = this_scan_key; @@ -1330,8 +1323,7 @@ ExecIndexBuildScanKeys(PlanState *planstate, Relation index, Assert(!isorderby); - first_sub_key = (ScanKey) - palloc(list_length(rc->opnos) * sizeof(ScanKeyData)); + first_sub_key = palloc_array(ScanKeyData, list_length(rc->opnos)); n_sub_key = 0; /* Scan RowCompare columns and generate subsidiary ScanKey items */ @@ -1410,14 +1402,13 @@ ExecIndexBuildScanKeys(PlanState *planstate, Relation index, if (max_runtime_keys == 0) { max_runtime_keys = 8; - runtime_keys = (IndexRuntimeKeyInfo *) - palloc(max_runtime_keys * sizeof(IndexRuntimeKeyInfo)); + runtime_keys = palloc_array(IndexRuntimeKeyInfo, max_runtime_keys); } else { max_runtime_keys *= 2; - runtime_keys = (IndexRuntimeKeyInfo *) - repalloc(runtime_keys, max_runtime_keys * sizeof(IndexRuntimeKeyInfo)); + runtime_keys = repalloc_array(runtime_keys, + IndexRuntimeKeyInfo, max_runtime_keys); } } runtime_keys[n_runtime_keys].scan_key = this_sub_key; @@ -1528,14 +1519,13 @@ ExecIndexBuildScanKeys(PlanState *planstate, Relation index, if (max_runtime_keys == 0) { max_runtime_keys = 8; - runtime_keys = (IndexRuntimeKeyInfo *) - palloc(max_runtime_keys * sizeof(IndexRuntimeKeyInfo)); + runtime_keys = palloc_array(IndexRuntimeKeyInfo, max_runtime_keys); } else { max_runtime_keys *= 2; - runtime_keys = (IndexRuntimeKeyInfo *) - repalloc(runtime_keys, max_runtime_keys * sizeof(IndexRuntimeKeyInfo)); + runtime_keys = repalloc_array(runtime_keys, + IndexRuntimeKeyInfo, max_runtime_keys); } } runtime_keys[n_runtime_keys].scan_key = this_scan_key; diff --git a/src/backend/executor/nodeMemoize.c b/src/backend/executor/nodeMemoize.c index fdca97d7426..49330168a75 100644 --- a/src/backend/executor/nodeMemoize.c +++ b/src/backend/executor/nodeMemoize.c @@ -1001,12 +1001,12 @@ ExecInitMemoize(Memoize *node, EState *estate, int eflags) mstate->probeslot = MakeSingleTupleTableSlot(mstate->hashkeydesc, &TTSOpsVirtual); - mstate->param_exprs = (ExprState **) palloc(nkeys * sizeof(ExprState *)); + mstate->param_exprs = palloc_array(ExprState *, nkeys); mstate->collations = node->collations; /* Just point directly to the plan * data */ - mstate->hashfunctions = (FmgrInfo *) palloc(nkeys * sizeof(FmgrInfo)); + mstate->hashfunctions = palloc_array(FmgrInfo, nkeys); - eqfuncoids = palloc(nkeys * sizeof(Oid)); + eqfuncoids = palloc_array(Oid, nkeys); for (i = 0; i < nkeys; i++) { diff --git a/src/backend/executor/nodeMergejoin.c b/src/backend/executor/nodeMergejoin.c index f8421a74c75..4d7e5729ca4 100644 --- a/src/backend/executor/nodeMergejoin.c +++ b/src/backend/executor/nodeMergejoin.c @@ -186,7 +186,7 @@ MJExamineQuals(List *mergeclauses, int iClause; ListCell *cl; - clauses = (MergeJoinClause) palloc0(nClauses * sizeof(MergeJoinClauseData)); + clauses = palloc0_array(MergeJoinClauseData, nClauses); iClause = 0; foreach(cl, mergeclauses) diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index 9a1c0992bfe..ca954729f1e 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -485,7 +485,7 @@ ExecInitGenerated(ResultRelInfo *resultRelInfo, */ oldContext = MemoryContextSwitchTo(estate->es_query_cxt); - ri_GeneratedExprs = (ExprState **) palloc0(natts * sizeof(ExprState *)); + ri_GeneratedExprs = palloc0_array(ExprState *, natts); ri_NumGeneratedNeeded = 0; for (int i = 0; i < natts; i++) diff --git a/src/backend/executor/nodeSetOp.c b/src/backend/executor/nodeSetOp.c index 24709778384..88815259b34 100644 --- a/src/backend/executor/nodeSetOp.c +++ b/src/backend/executor/nodeSetOp.c @@ -654,8 +654,7 @@ ExecInitSetOp(SetOp *node, EState *estate, int eflags) { int nkeys = node->numCols; - setopstate->sortKeys = (SortSupport) - palloc0(nkeys * sizeof(SortSupportData)); + setopstate->sortKeys = palloc0_array(SortSupportData, nkeys); for (int i = 0; i < nkeys; i++) { SortSupport sortKey = setopstate->sortKeys + i; diff --git a/src/backend/executor/nodeSubplan.c b/src/backend/executor/nodeSubplan.c index 8285c7101c2..c6dd463c118 100644 --- a/src/backend/executor/nodeSubplan.c +++ b/src/backend/executor/nodeSubplan.c @@ -974,14 +974,14 @@ ExecInitSubPlan(SubPlan *subplan, PlanState *parent) lefttlist = righttlist = NIL; sstate->numCols = ncols; - sstate->keyColIdx = (AttrNumber *) palloc(ncols * sizeof(AttrNumber)); - sstate->tab_eq_funcoids = (Oid *) palloc(ncols * sizeof(Oid)); - sstate->tab_collations = (Oid *) palloc(ncols * sizeof(Oid)); - sstate->tab_hash_funcs = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo)); - lhs_hash_funcs = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo)); - sstate->cur_eq_funcs = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo)); + sstate->keyColIdx = palloc_array(AttrNumber, ncols); + sstate->tab_eq_funcoids = palloc_array(Oid, ncols); + sstate->tab_collations = palloc_array(Oid, ncols); + sstate->tab_hash_funcs = palloc_array(FmgrInfo, ncols); + lhs_hash_funcs = palloc_array(FmgrInfo, ncols); + sstate->cur_eq_funcs = palloc_array(FmgrInfo, ncols); /* we'll need the cross-type equality fns below, but not in sstate */ - cross_eq_funcoids = (Oid *) palloc(ncols * sizeof(Oid)); + cross_eq_funcoids = palloc_array(Oid, ncols); i = 1; foreach(l, oplist) diff --git a/src/backend/executor/nodeTidscan.c b/src/backend/executor/nodeTidscan.c index 6641df10999..b63329de330 100644 --- a/src/backend/executor/nodeTidscan.c +++ b/src/backend/executor/nodeTidscan.c @@ -157,8 +157,7 @@ TidListEval(TidScanState *tidstate) * ScalarArrayOpExprs, we may have to enlarge the array. */ numAllocTids = list_length(tidstate->tss_tidexprs); - tidList = (ItemPointerData *) - palloc(numAllocTids * sizeof(ItemPointerData)); + tidList = palloc_array(ItemPointerData, numAllocTids); numTids = 0; foreach(l, tidstate->tss_tidexprs) @@ -189,9 +188,7 @@ TidListEval(TidScanState *tidstate) if (numTids >= numAllocTids) { numAllocTids *= 2; - tidList = (ItemPointerData *) - repalloc(tidList, - numAllocTids * sizeof(ItemPointerData)); + tidList = repalloc_array(tidList, ItemPointerData, numAllocTids); } tidList[numTids++] = *itemptr; } @@ -214,9 +211,7 @@ TidListEval(TidScanState *tidstate) if (numTids + ndatums > numAllocTids) { numAllocTids = numTids + ndatums; - tidList = (ItemPointerData *) - repalloc(tidList, - numAllocTids * sizeof(ItemPointerData)); + tidList = repalloc_array(tidList, ItemPointerData, numAllocTids); } for (i = 0; i < ndatums; i++) { @@ -245,9 +240,7 @@ TidListEval(TidScanState *tidstate) if (numTids >= numAllocTids) { numAllocTids *= 2; - tidList = (ItemPointerData *) - repalloc(tidList, - numAllocTids * sizeof(ItemPointerData)); + tidList = repalloc_array(tidList, ItemPointerData, numAllocTids); } tidList[numTids++] = cursor_tid; } diff --git a/src/backend/executor/nodeValuesscan.c b/src/backend/executor/nodeValuesscan.c index effc896ea1c..51c32979481 100644 --- a/src/backend/executor/nodeValuesscan.c +++ b/src/backend/executor/nodeValuesscan.c @@ -277,10 +277,8 @@ ExecInitValuesScan(ValuesScan *node, EState *estate, int eflags) * and/or leaked resources if we try to handle SubPlans the same as * simpler expressions.) */ - scanstate->exprlists = (List **) - palloc(scanstate->array_len * sizeof(List *)); - scanstate->exprstatelists = (List **) - palloc0(scanstate->array_len * sizeof(List *)); + scanstate->exprlists = palloc_array(List *, scanstate->array_len); + scanstate->exprstatelists = palloc0_array(List *, scanstate->array_len); i = 0; foreach(vtl, node->values_lists) { diff --git a/src/backend/executor/spi.c b/src/backend/executor/spi.c index 23a8395766c..196b998dd7f 100644 --- a/src/backend/executor/spi.c +++ b/src/backend/executor/spi.c @@ -120,9 +120,7 @@ SPI_connect_ext(int options) if (_SPI_stack_depth == _SPI_connected + 1) { newdepth = _SPI_stack_depth * 2; - _SPI_stack = (_SPI_connection *) - repalloc(_SPI_stack, - newdepth * sizeof(_SPI_connection)); + _SPI_stack = repalloc_array(_SPI_stack, _SPI_connection, newdepth); _SPI_stack_depth = newdepth; } } diff --git a/src/backend/jit/llvm/llvmjit_expr.c b/src/backend/jit/llvm/llvmjit_expr.c index 29617437477..09a52a18921 100644 --- a/src/backend/jit/llvm/llvmjit_expr.c +++ b/src/backend/jit/llvm/llvmjit_expr.c @@ -700,8 +700,7 @@ llvm_compile_expr(ExprState *state) LLVMBuildStore(b, l_sbool_const(1), v_resnullp); /* create blocks for checking args, one for each */ - b_checkargnulls = (LLVMBasicBlockRef *) - palloc(sizeof(LLVMBasicBlockRef) * op->d.func.nargs); + b_checkargnulls = palloc_array(LLVMBasicBlockRef, op->d.func.nargs); for (int argno = 0; argno < op->d.func.nargs; argno++) b_checkargnulls[argno] = l_bb_before_v(b_nonull, "b.%d.isnull.%d", opno, diff --git a/src/backend/lib/bipartite_match.c b/src/backend/lib/bipartite_match.c index 12520dc91b4..cf470275f48 100644 --- a/src/backend/lib/bipartite_match.c +++ b/src/backend/lib/bipartite_match.c @@ -48,10 +48,10 @@ BipartiteMatch(int u_size, int v_size, short **adjacency) state->v_size = v_size; state->adjacency = adjacency; state->matching = 0; - state->pair_uv = (short *) palloc0((u_size + 1) * sizeof(short)); - state->pair_vu = (short *) palloc0((v_size + 1) * sizeof(short)); - state->distance = (short *) palloc((u_size + 1) * sizeof(short)); - state->queue = (short *) palloc((u_size + 2) * sizeof(short)); + state->pair_uv = palloc0_array(short, u_size + 1); + state->pair_vu = palloc0_array(short, v_size + 1); + state->distance = palloc_array(short, u_size + 1); + state->queue = palloc_array(short, u_size + 2); while (hk_breadth_search(state)) { diff --git a/src/backend/lib/knapsack.c b/src/backend/lib/knapsack.c index 586f1881fd5..23743f233ac 100644 --- a/src/backend/lib/knapsack.c +++ b/src/backend/lib/knapsack.c @@ -64,8 +64,8 @@ DiscreteKnapsack(int max_weight, int num_items, Assert(max_weight >= 0); Assert(num_items > 0 && item_weights); - values = palloc((1 + max_weight) * sizeof(double)); - sets = palloc((1 + max_weight) * sizeof(Bitmapset *)); + values = palloc_array(double, 1 + max_weight); + sets = palloc_array(Bitmapset *, 1 + max_weight); for (i = 0; i <= max_weight; ++i) { diff --git a/src/backend/libpq/be-secure-common.c b/src/backend/libpq/be-secure-common.c index 6ec887b8a47..64fd9364b79 100644 --- a/src/backend/libpq/be-secure-common.c +++ b/src/backend/libpq/be-secure-common.c @@ -199,7 +199,7 @@ parse_hosts_line(TokenizedAuthLine *tok_line, int elevel) ListCell *field; AuthToken *token; - parsedline = palloc0(sizeof(HostsLine)); + parsedline = palloc0_object(HostsLine); parsedline->sourcefile = pstrdup(tok_line->file_name); parsedline->linenumber = tok_line->line_num; parsedline->rawline = pstrdup(tok_line->raw_line); diff --git a/src/backend/libpq/be-secure-openssl.c b/src/backend/libpq/be-secure-openssl.c index 87467662220..675bf2de5b2 100644 --- a/src/backend/libpq/be-secure-openssl.c +++ b/src/backend/libpq/be-secure-openssl.c @@ -333,7 +333,7 @@ be_tls_init(bool isServerStart) */ else if (res == HOSTSFILE_DISABLED || res == HOSTSFILE_EMPTY || res == HOSTSFILE_MISSING) { - HostsLine *pgconf = palloc0(sizeof(HostsLine)); + HostsLine *pgconf = palloc0_object(HostsLine); #ifdef USE_ASSERT_CHECKING if (res == HOSTSFILE_DISABLED) diff --git a/src/backend/libpq/hba.c b/src/backend/libpq/hba.c index d47eab2cba0..c0d8a9d8a00 100644 --- a/src/backend/libpq/hba.c +++ b/src/backend/libpq/hba.c @@ -309,7 +309,7 @@ regcomp_auth_token(AuthToken *token, char *filename, int line_num, return 0; /* nothing to compile */ token->regex = palloc0_object(regex_t); - wstr = palloc((strlen(token->string + 1) + 1) * sizeof(pg_wchar)); + wstr = palloc_array(pg_wchar, strlen(token->string + 1) + 1); wlen = pg_mb2wchar_with_len(token->string + 1, wstr, strlen(token->string + 1)); @@ -350,7 +350,7 @@ regexec_auth_token(const char *match, AuthToken *token, size_t nmatch, Assert(token->string[0] == '/' && token->regex); - wmatchstr = palloc((strlen(match) + 1) * sizeof(pg_wchar)); + wmatchstr = palloc_array(pg_wchar, strlen(match) + 1); wmatchlen = pg_mb2wchar_with_len(match, wmatchstr, strlen(match)); r = pg_regexec(token->regex, wmatchstr, wmatchlen, 0, NULL, nmatch, pmatch, 0); diff --git a/src/backend/nodes/list.c b/src/backend/nodes/list.c index 98fc2b44b50..51de24eb460 100644 --- a/src/backend/nodes/list.c +++ b/src/backend/nodes/list.c @@ -206,8 +206,7 @@ enlarge_list(List *list, int min_size) { #ifndef DEBUG_LIST_MEMORY_USAGE /* Normally, let repalloc deal with enlargement */ - list->elements = (ListCell *) repalloc(list->elements, - new_max_len * sizeof(ListCell)); + list->elements = repalloc_array(list->elements, ListCell, new_max_len); #else /* * repalloc() might enlarge the space in-place, which we don't want diff --git a/src/backend/nodes/queryjumblefuncs.c b/src/backend/nodes/queryjumblefuncs.c index 2ce27b9e552..094d2872644 100644 --- a/src/backend/nodes/queryjumblefuncs.c +++ b/src/backend/nodes/queryjumblefuncs.c @@ -189,8 +189,7 @@ InitJumble(void) jstate->jumble = (unsigned char *) palloc(JUMBLE_SIZE); jstate->jumble_len = 0; jstate->clocations_buf_size = 32; - jstate->clocations = (LocationLen *) palloc(jstate->clocations_buf_size * - sizeof(LocationLen)); + jstate->clocations = palloc_array(LocationLen, jstate->clocations_buf_size); jstate->clocations_count = 0; jstate->highest_extern_param_id = 0; jstate->pending_nulls = 0; @@ -406,10 +405,9 @@ RecordConstLocation(JumbleState *jstate, bool extern_param, int location, int le if (jstate->clocations_count >= jstate->clocations_buf_size) { jstate->clocations_buf_size *= 2; - jstate->clocations = (LocationLen *) - repalloc(jstate->clocations, - jstate->clocations_buf_size * - sizeof(LocationLen)); + jstate->clocations = repalloc_array(jstate->clocations, + LocationLen, + jstate->clocations_buf_size); } jstate->clocations[jstate->clocations_count].location = location; diff --git a/src/backend/nodes/readfuncs.c b/src/backend/nodes/readfuncs.c index b6b2ce6c792..49d7f750a09 100644 --- a/src/backend/nodes/readfuncs.c +++ b/src/backend/nodes/readfuncs.c @@ -677,7 +677,7 @@ fnname(int numCols) \ return NULL; /* it was "<>", so return NULL pointer */ \ if (length != 1 || token[0] != '(') \ elog(ERROR, "unrecognized token: \"%.*s\"", length, token); \ - vals = (datatype *) palloc(numCols * sizeof(datatype)); \ + vals = palloc_array(datatype, numCols); \ for (int i = 0; i < numCols; i++) \ { \ token = pg_strtok(&length); \ diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c index 9c040ecefc8..24a6a8d11dd 100644 --- a/src/backend/optimizer/path/allpaths.c +++ b/src/backend/optimizer/path/allpaths.c @@ -1079,7 +1079,7 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel, parent_rows = 0; parent_size = 0; nattrs = rel->max_attr - rel->min_attr + 1; - parent_attrsizes = (double *) palloc0(nattrs * sizeof(double)); + parent_attrsizes = palloc0_array(double, nattrs); foreach(l, root->append_rel_list) { @@ -2717,8 +2717,8 @@ set_subquery_pathlist(PlannerInfo *root, RelOptInfo *rel, * a pushed-down qual. */ memset(&safetyInfo, 0, sizeof(safetyInfo)); - safetyInfo.unsafeFlags = (unsigned char *) - palloc0((list_length(subquery->targetList) + 1) * sizeof(unsigned char)); + safetyInfo.unsafeFlags = palloc0_array(unsigned char, + list_length(subquery->targetList) + 1); /* * If the subquery has the "security_barrier" flag, it means the subquery @@ -3971,7 +3971,7 @@ standard_join_search(PlannerInfo *root, int levels_needed, List *initial_rels) * set root->join_rel_level[1] to represent all the single-jointree-item * relations. */ - root->join_rel_level = (List **) palloc0((levels_needed + 1) * sizeof(List *)); + root->join_rel_level = palloc0_array(List *, levels_needed + 1); root->join_rel_level[1] = initial_rels; diff --git a/src/backend/optimizer/path/equivclass.c b/src/backend/optimizer/path/equivclass.c index e3697df51a2..0dcc2ed4266 100644 --- a/src/backend/optimizer/path/equivclass.c +++ b/src/backend/optimizer/path/equivclass.c @@ -1381,8 +1381,7 @@ generate_base_implied_equalities_no_const(PlannerInfo *root, * ordering would succeed. XXX FIXME: use a UNION-FIND algorithm similar * to the way we build merged ECs. (Use a list-of-lists for each rel.) */ - prev_ems = (EquivalenceMember **) - palloc0(root->simple_rel_array_size * sizeof(EquivalenceMember *)); + prev_ems = palloc0_array(EquivalenceMember *, root->simple_rel_array_size); /* We don't expect any children yet */ Assert(ec->ec_childmembers == NULL); diff --git a/src/backend/optimizer/path/pathkeys.c b/src/backend/optimizer/path/pathkeys.c index 5eb71635d15..d6a305aedac 100644 --- a/src/backend/optimizer/path/pathkeys.c +++ b/src/backend/optimizer/path/pathkeys.c @@ -1676,8 +1676,8 @@ select_outer_pathkeys_for_merge(PlannerInfo *root, * Make arrays of the ECs used by the mergeclauses (dropping any * duplicates) and their "popularity" scores. */ - ecs = (EquivalenceClass **) palloc(nClauses * sizeof(EquivalenceClass *)); - scores = (int *) palloc(nClauses * sizeof(int)); + ecs = palloc_array(EquivalenceClass *, nClauses); + scores = palloc_array(int, nClauses); necs = 0; foreach(lc, mergeclauses) diff --git a/src/backend/optimizer/plan/analyzejoins.c b/src/backend/optimizer/plan/analyzejoins.c index 881950e5264..87a5d9d58b8 100644 --- a/src/backend/optimizer/plan/analyzejoins.c +++ b/src/backend/optimizer/plan/analyzejoins.c @@ -1252,7 +1252,7 @@ rel_is_distinct_for(PlannerInfo *root, RelOptInfo *rel, List *clause_list, var->varno != relid || var->varlevelsup != 0) continue; - dcinfo = palloc(sizeof(DistinctColInfo)); + dcinfo = palloc_object(DistinctColInfo); dcinfo->colno = var->varattno; dcinfo->opid = opexpr->opno; dcinfo->collid = opexpr->inputcollid; diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c index 79b83a4d305..02a888c5996 100644 --- a/src/backend/optimizer/plan/createplan.c +++ b/src/backend/optimizer/plan/createplan.c @@ -1736,8 +1736,8 @@ create_memoize_plan(PlannerInfo *root, MemoizePath *best_path, int flags) nkeys = list_length(param_exprs); Assert(nkeys > 0); - operators = palloc(nkeys * sizeof(Oid)); - collations = palloc(nkeys * sizeof(Oid)); + operators = palloc_array(Oid, nkeys); + collations = palloc_array(Oid, nkeys); i = 0; forboth(lc, param_exprs, lc2, best_path->hash_operators) @@ -2279,7 +2279,7 @@ create_groupingsets_plan(PlannerInfo *root, GroupingSetsPath *best_path) maxref = gc->tleSortGroupRef; } - grouping_map = (AttrNumber *) palloc0((maxref + 1) * sizeof(AttrNumber)); + grouping_map = palloc0_array(AttrNumber, maxref + 1); /* Now look up the column numbers in the child's tlist */ foreach(lc, root->processed_groupClause) @@ -2718,9 +2718,9 @@ create_limit_plan(PlannerInfo *root, LimitPath *best_path, int flags) ListCell *l; numUniqkeys = list_length(parse->sortClause); - uniqColIdx = (AttrNumber *) palloc(numUniqkeys * sizeof(AttrNumber)); - uniqOperators = (Oid *) palloc(numUniqkeys * sizeof(Oid)); - uniqCollations = (Oid *) palloc(numUniqkeys * sizeof(Oid)); + uniqColIdx = palloc_array(AttrNumber, numUniqkeys); + uniqOperators = palloc_array(Oid, numUniqkeys); + uniqCollations = palloc_array(Oid, numUniqkeys); numUniqkeys = 0; foreach(l, parse->sortClause) @@ -4547,10 +4547,10 @@ create_mergejoin_plan(PlannerInfo *root, */ nClauses = list_length(mergeclauses); Assert(nClauses == list_length(best_path->path_mergeclauses)); - mergefamilies = (Oid *) palloc(nClauses * sizeof(Oid)); - mergecollations = (Oid *) palloc(nClauses * sizeof(Oid)); - mergereversals = (bool *) palloc(nClauses * sizeof(bool)); - mergenullsfirst = (bool *) palloc(nClauses * sizeof(bool)); + mergefamilies = palloc_array(Oid, nClauses); + mergecollations = palloc_array(Oid, nClauses); + mergereversals = palloc_array(bool, nClauses); + mergenullsfirst = palloc_array(bool, nClauses); opathkey = NULL; opeclass = NULL; @@ -5314,7 +5314,7 @@ order_qual_clauses(PlannerInfo *root, List *clauses) * Collect the items and costs into an array. This is to avoid repeated * cost_qual_eval work if the inputs aren't RestrictInfos. */ - items = (QualItem *) palloc(nitems * sizeof(QualItem)); + items = palloc_array(QualItem, nitems); i = 0; foreach(lc, clauses) { @@ -6201,10 +6201,10 @@ prepare_sort_from_pathkeys(Plan *lefttree, List *pathkeys, * We will need at most list_length(pathkeys) sort columns; possibly less */ numsortkeys = list_length(pathkeys); - sortColIdx = (AttrNumber *) palloc(numsortkeys * sizeof(AttrNumber)); - sortOperators = (Oid *) palloc(numsortkeys * sizeof(Oid)); - collations = (Oid *) palloc(numsortkeys * sizeof(Oid)); - nullsFirst = (bool *) palloc(numsortkeys * sizeof(bool)); + sortColIdx = palloc_array(AttrNumber, numsortkeys); + sortOperators = palloc_array(Oid, numsortkeys); + collations = palloc_array(Oid, numsortkeys); + nullsFirst = palloc_array(bool, numsortkeys); numsortkeys = 0; @@ -6442,10 +6442,10 @@ make_sort_from_sortclauses(List *sortcls, Plan *lefttree) /* Convert list-ish representation to arrays wanted by executor */ numsortkeys = list_length(sortcls); - sortColIdx = (AttrNumber *) palloc(numsortkeys * sizeof(AttrNumber)); - sortOperators = (Oid *) palloc(numsortkeys * sizeof(Oid)); - collations = (Oid *) palloc(numsortkeys * sizeof(Oid)); - nullsFirst = (bool *) palloc(numsortkeys * sizeof(bool)); + sortColIdx = palloc_array(AttrNumber, numsortkeys); + sortOperators = palloc_array(Oid, numsortkeys); + collations = palloc_array(Oid, numsortkeys); + nullsFirst = palloc_array(bool, numsortkeys); numsortkeys = 0; foreach(l, sortcls) @@ -6493,10 +6493,10 @@ make_sort_from_groupcols(List *groupcls, /* Convert list-ish representation to arrays wanted by executor */ numsortkeys = list_length(groupcls); - sortColIdx = (AttrNumber *) palloc(numsortkeys * sizeof(AttrNumber)); - sortOperators = (Oid *) palloc(numsortkeys * sizeof(Oid)); - collations = (Oid *) palloc(numsortkeys * sizeof(Oid)); - nullsFirst = (bool *) palloc(numsortkeys * sizeof(bool)); + sortColIdx = palloc_array(AttrNumber, numsortkeys); + sortOperators = palloc_array(Oid, numsortkeys); + collations = palloc_array(Oid, numsortkeys); + nullsFirst = palloc_array(bool, numsortkeys); numsortkeys = 0; foreach(l, groupcls) diff --git a/src/backend/optimizer/plan/initsplan.c b/src/backend/optimizer/plan/initsplan.c index b38422c47a4..f08a918146c 100644 --- a/src/backend/optimizer/plan/initsplan.c +++ b/src/backend/optimizer/plan/initsplan.c @@ -490,7 +490,7 @@ remove_useless_groupby_columns(PlannerInfo *root) groupbyattnos[relid] = bms_add_member(groupbyattnos[relid], var->varattno - FirstLowInvalidHeapAttributeNumber); - info = palloc(sizeof(GroupByColInfo)); + info = palloc_object(GroupByColInfo); info->attno = var->varattno; info->eq_opfamilies = get_mergejoin_opfamilies(sgc->eqop); info->coll = var->varcollid; diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c index a0ff9159ae0..a605387dcaa 100644 --- a/src/backend/optimizer/plan/planner.c +++ b/src/backend/optimizer/plan/planner.c @@ -2492,7 +2492,7 @@ preprocess_grouping_sets(PlannerInfo *root) } /* Allocate workspace array for remapping */ - gd->tleref_to_colnum_map = (int *) palloc((maxref + 1) * sizeof(int)); + gd->tleref_to_colnum_map = palloc_array(int, maxref + 1); /* * If we have any unsortable sets, we must extract them before trying to @@ -3246,10 +3246,10 @@ extract_rollup_sets(List *groupingSets) * to leave 0 free for the NIL node in the graph algorithm. *---------- */ - orig_sets = palloc0((num_sets_raw + 1) * sizeof(List *)); - set_masks = palloc0((num_sets_raw + 1) * sizeof(Bitmapset *)); - adjacency = palloc0((num_sets_raw + 1) * sizeof(short *)); - adjacency_buf = palloc((num_sets_raw + 1) * sizeof(short)); + orig_sets = palloc0_array(List *, num_sets_raw + 1); + set_masks = palloc0_array(Bitmapset *, num_sets_raw + 1); + adjacency = palloc0_array(short *, num_sets_raw + 1); + adjacency_buf = palloc_array(short, num_sets_raw + 1); j_size = 0; j = 0; @@ -3311,7 +3311,7 @@ extract_rollup_sets(List *groupingSets) if (n_adj > 0) { adjacency_buf[0] = n_adj; - adjacency[i] = palloc((n_adj + 1) * sizeof(short)); + adjacency[i] = palloc_array(short, n_adj + 1); memcpy(adjacency[i], adjacency_buf, (n_adj + 1) * sizeof(short)); } else @@ -3334,7 +3334,7 @@ extract_rollup_sets(List *groupingSets) * pair_vu[v] = u (both will be true, but we check both so that we can do * it in one pass) */ - chains = palloc0((num_sets + 1) * sizeof(int)); + chains = palloc0_array(int, num_sets + 1); for (i = 1; i <= num_sets; ++i) { @@ -3350,7 +3350,7 @@ extract_rollup_sets(List *groupingSets) } /* build result lists. */ - results = palloc0((num_chains + 1) * sizeof(List *)); + results = palloc0_array(List *, num_chains + 1); for (i = 1; i <= num_sets; ++i) { @@ -4643,7 +4643,7 @@ consider_groupingsets_paths(PlannerInfo *root, double scale; int num_rollups = list_length(gd->rollups); int k_capacity; - int *k_weights = palloc(num_rollups * sizeof(int)); + int *k_weights = palloc_array(int, num_rollups); Bitmapset *hash_items = NULL; int i; @@ -6697,8 +6697,8 @@ make_sort_input_target(PlannerInfo *root, /* Inspect tlist and collect per-column information */ ncols = list_length(final_target->exprs); - col_is_srf = (bool *) palloc0(ncols * sizeof(bool)); - postpone_col = (bool *) palloc0(ncols * sizeof(bool)); + col_is_srf = palloc0_array(bool, ncols); + postpone_col = palloc0_array(bool, ncols); have_srf = have_volatile = have_expensive = have_srf_sortcols = false; i = 0; diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c index e1182255055..8a641402a96 100644 --- a/src/backend/optimizer/plan/setrefs.c +++ b/src/backend/optimizer/plan/setrefs.c @@ -347,10 +347,8 @@ set_plan_references(PlannerInfo *root, Plan *plan) /* If needed, create workspace for processing AlternativeSubPlans */ if (root->hasAlternativeSubPlans) { - root->isAltSubplan = (bool *) - palloc0(list_length(glob->subplans) * sizeof(bool)); - root->isUsedSubplan = (bool *) - palloc0(list_length(glob->subplans) * sizeof(bool)); + root->isAltSubplan = palloc0_array(bool, list_length(glob->subplans)); + root->isUsedSubplan = palloc0_array(bool, list_length(glob->subplans)); } /* Now fix the Plan tree */ diff --git a/src/backend/optimizer/prep/prepjointree.c b/src/backend/optimizer/prep/prepjointree.c index 72d39ba30fd..0b3d2571048 100644 --- a/src/backend/optimizer/prep/prepjointree.c +++ b/src/backend/optimizer/prep/prepjointree.c @@ -558,8 +558,7 @@ expand_virtual_generated_columns(PlannerInfo *root, Query *parse, /* this flag will be set below, if needed */ rvcontext.wrap_option = REPLACE_WRAP_NONE; /* initialize cache array with indexes 0 .. length(tlist) */ - rvcontext.rv_cache = palloc0((list_length(tlist) + 1) * - sizeof(Node *)); + rvcontext.rv_cache = palloc0_array(Node *, list_length(tlist) + 1); /* * If the query uses grouping sets, we need a PlaceHolderVar for each @@ -1598,8 +1597,7 @@ pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte, /* this flag will be set below, if needed */ rvcontext.wrap_option = REPLACE_WRAP_NONE; /* initialize cache array with indexes 0 .. length(tlist) */ - rvcontext.rv_cache = palloc0((list_length(subquery->targetList) + 1) * - sizeof(Node *)); + rvcontext.rv_cache = palloc0_array(Node *, list_length(subquery->targetList) + 1); /* * If the parent query uses grouping sets, we need a PlaceHolderVar for @@ -1925,8 +1923,7 @@ make_setop_translation_list(Query *query, int newvarno, /* Initialize reverse-translation array with all entries zero */ /* (entries for resjunk columns will stay that way) */ appinfo->num_child_cols = list_length(query->targetList); - appinfo->parent_colnos = pcolnos = - (AttrNumber *) palloc0(appinfo->num_child_cols * sizeof(AttrNumber)); + appinfo->parent_colnos = pcolnos = palloc0_array(AttrNumber, appinfo->num_child_cols); foreach(l, query->targetList) { @@ -2143,8 +2140,7 @@ pull_up_simple_values(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte) rvcontext.varno = varno; rvcontext.wrap_option = REPLACE_WRAP_NONE; /* initialize cache array with indexes 0 .. length(tlist) */ - rvcontext.rv_cache = palloc0((list_length(tlist) + 1) * - sizeof(Node *)); + rvcontext.rv_cache = palloc0_array(Node *, list_length(tlist) + 1); /* * Replace all of the top query's references to the RTE's outputs with @@ -2311,8 +2307,7 @@ pull_up_constant_function(PlannerInfo *root, Node *jtnode, /* this flag will be set below, if needed */ rvcontext.wrap_option = REPLACE_WRAP_NONE; /* initialize cache array with indexes 0 .. length(tlist) */ - rvcontext.rv_cache = palloc0((list_length(rvcontext.targetlist) + 1) * - sizeof(Node *)); + rvcontext.rv_cache = palloc0_array(Node *, list_length(rvcontext.targetlist) + 1); /* * If the parent query uses grouping sets, we need a PlaceHolderVar for diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c index 778e4662f6e..ebb74c53d3b 100644 --- a/src/backend/optimizer/util/appendinfo.c +++ b/src/backend/optimizer/util/appendinfo.c @@ -94,8 +94,7 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation, /* Initialize reverse-translation array with all entries zero */ appinfo->num_child_cols = newnatts; - appinfo->parent_colnos = pcolnos = - (AttrNumber *) palloc0(newnatts * sizeof(AttrNumber)); + appinfo->parent_colnos = pcolnos = palloc0_array(AttrNumber, newnatts); for (old_attno = 0; old_attno < oldnatts; old_attno++) { diff --git a/src/backend/optimizer/util/clauses.c b/src/backend/optimizer/util/clauses.c index 337fc27262e..c92b0f3dbb4 100644 --- a/src/backend/optimizer/util/clauses.c +++ b/src/backend/optimizer/util/clauses.c @@ -263,7 +263,7 @@ find_window_functions(Node *clause, Index maxWinRef) lists->numWindowFuncs = 0; lists->maxWinRef = maxWinRef; - lists->windowFuncs = (List **) palloc0((maxWinRef + 1) * sizeof(List *)); + lists->windowFuncs = palloc0_array(List *, (maxWinRef + 1)); (void) find_window_functions_walker(clause, lists); return lists; } @@ -5576,7 +5576,7 @@ inline_function(Oid funcid, Oid result_type, Oid result_collid, * substitution of the inputs. So start building expression with inputs * substituted. */ - usecounts = (int *) palloc0(funcform->pronargs * sizeof(int)); + usecounts = palloc0_array(int, funcform->pronargs); newexpr = substitute_actual_parameters(newexpr, funcform->pronargs, args, usecounts); diff --git a/src/backend/optimizer/util/extendplan.c b/src/backend/optimizer/util/extendplan.c index 40f37f0c8de..e2d077b7b02 100644 --- a/src/backend/optimizer/util/extendplan.c +++ b/src/backend/optimizer/util/extendplan.c @@ -60,8 +60,7 @@ GetPlannerExtensionId(const char *extension_name) { int i = pg_nextpower2_32(PlannerExtensionNamesAssigned + 1); - PlannerExtensionNameArray = (const char **) - repalloc(PlannerExtensionNameArray, i * sizeof(char *)); + PlannerExtensionNameArray = repalloc_array(PlannerExtensionNameArray, const char *, i); PlannerExtensionNamesAllocated = i; } diff --git a/src/backend/optimizer/util/inherit.c b/src/backend/optimizer/util/inherit.c index 6a7b9edff3f..6e1d2b14bc4 100644 --- a/src/backend/optimizer/util/inherit.c +++ b/src/backend/optimizer/util/inherit.c @@ -360,8 +360,7 @@ expand_partitioned_rtentry(PlannerInfo *root, RelOptInfo *relinfo, * contain NULL. */ Assert(relinfo->part_rels == NULL); - relinfo->part_rels = (RelOptInfo **) - palloc0(relinfo->nparts * sizeof(RelOptInfo *)); + relinfo->part_rels = palloc0_array(RelOptInfo *, relinfo->nparts); /* * Create a child RTE for each live partition. Note that unlike diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c index 7c4be174869..4c9c5e9fc33 100644 --- a/src/backend/optimizer/util/plancat.c +++ b/src/backend/optimizer/util/plancat.c @@ -162,10 +162,8 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent, rel->reltablespace = RelationGetForm(relation)->reltablespace; Assert(rel->max_attr >= rel->min_attr); - rel->attr_needed = (Relids *) - palloc0((rel->max_attr - rel->min_attr + 1) * sizeof(Relids)); - rel->attr_widths = (int32 *) - palloc0((rel->max_attr - rel->min_attr + 1) * sizeof(int32)); + rel->attr_needed = palloc0_array(Relids, rel->max_attr - rel->min_attr + 1); + rel->attr_widths = palloc0_array(int32, rel->max_attr - rel->min_attr + 1); /* * Record which columns are defined as NOT NULL. We leave this diff --git a/src/backend/optimizer/util/tlist.c b/src/backend/optimizer/util/tlist.c index 752ea9222f6..ae652f25e14 100644 --- a/src/backend/optimizer/util/tlist.c +++ b/src/backend/optimizer/util/tlist.c @@ -603,7 +603,7 @@ make_pathtarget_from_tlist(List *tlist) int i; ListCell *lc; - target->sortgrouprefs = (Index *) palloc(list_length(tlist) * sizeof(Index)); + target->sortgrouprefs = palloc_array(Index, list_length(tlist)); i = 0; foreach(lc, tlist) @@ -711,8 +711,7 @@ add_column_to_pathtarget(PathTarget *target, Expr *expr, Index sortgroupref) int nexprs = list_length(target->exprs); /* This might look inefficient, but actually it's usually cheap */ - target->sortgrouprefs = (Index *) - repalloc(target->sortgrouprefs, nexprs * sizeof(Index)); + target->sortgrouprefs = repalloc_array(target->sortgrouprefs, Index, nexprs); target->sortgrouprefs[nexprs - 1] = sortgroupref; } else if (sortgroupref) @@ -720,7 +719,7 @@ add_column_to_pathtarget(PathTarget *target, Expr *expr, Index sortgroupref) /* Adding sortgroupref labeling to a previously unlabeled target */ int nexprs = list_length(target->exprs); - target->sortgrouprefs = (Index *) palloc0(nexprs * sizeof(Index)); + target->sortgrouprefs = palloc0_array(Index, nexprs); target->sortgrouprefs[nexprs - 1] = sortgroupref; } @@ -1307,8 +1306,8 @@ add_sp_item_to_pathtarget(PathTarget *target, split_pathtarget_item *item) { if (target->sortgrouprefs == NULL) { - target->sortgrouprefs = (Index *) - palloc0(list_length(target->exprs) * sizeof(Index)); + target->sortgrouprefs = palloc0_array(Index, + list_length(target->exprs)); } target->sortgrouprefs[lci] = item->sortgroupref; } diff --git a/src/backend/parser/analyze.c b/src/backend/parser/analyze.c index 581457c69c9..263d1b6e1cc 100644 --- a/src/backend/parser/analyze.c +++ b/src/backend/parser/analyze.c @@ -1955,7 +1955,7 @@ transformValuesClause(ParseState *pstate, SelectStmt *stmt) /* Remember post-transformation length of first sublist */ sublist_length = list_length(sublist); /* and allocate array for per-column lists */ - colexprs = (List **) palloc0(sublist_length * sizeof(List *)); + colexprs = palloc0_array(List *, sublist_length); } else if (sublist_length != list_length(sublist)) { @@ -2227,8 +2227,7 @@ transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt) qry->targetList = NIL; targetvars = NIL; targetnames = NIL; - sortnscolumns = (ParseNamespaceColumn *) - palloc0(list_length(sostmt->colTypes) * sizeof(ParseNamespaceColumn)); + sortnscolumns = palloc0_array(ParseNamespaceColumn, list_length(sostmt->colTypes)); sortcolindex = 0; forfour(lct, sostmt->colTypes, diff --git a/src/backend/parser/parse_clause.c b/src/backend/parser/parse_clause.c index 68b525ffdcc..67de2733d8a 100644 --- a/src/backend/parser/parse_clause.c +++ b/src/backend/parser/parse_clause.c @@ -1466,9 +1466,8 @@ transformFromClauseItem(ParseState *pstate, Node *n, res_colvars = NIL; /* this may be larger than needed, but it's not worth being exact */ - res_nscolumns = (ParseNamespaceColumn *) - palloc0((list_length(l_colnames) + list_length(r_colnames)) * - sizeof(ParseNamespaceColumn)); + res_nscolumns = palloc0_array(ParseNamespaceColumn, + list_length(l_colnames) + list_length(r_colnames)); res_colindex = 0; if (j->usingClause) diff --git a/src/backend/parser/parse_cte.c b/src/backend/parser/parse_cte.c index ccde199319a..73e86b7422f 100644 --- a/src/backend/parser/parse_cte.c +++ b/src/backend/parser/parse_cte.c @@ -166,7 +166,7 @@ transformWithClause(ParseState *pstate, WithClause *withClause) cstate.pstate = pstate; cstate.numitems = list_length(withClause->ctes); - cstate.items = (CteItem *) palloc0(cstate.numitems * sizeof(CteItem)); + cstate.items = palloc0_array(CteItem, cstate.numitems); i = 0; foreach(lc, withClause->ctes) { diff --git a/src/backend/parser/parse_relation.c b/src/backend/parser/parse_relation.c index 66f501aaf49..4cbba861851 100644 --- a/src/backend/parser/parse_relation.c +++ b/src/backend/parser/parse_relation.c @@ -1347,8 +1347,7 @@ buildNSItemFromTupleDesc(RangeTblEntry *rte, Index rtindex, Assert(maxattrs == list_length(rte->eref->colnames)); /* extract per-column data from the tupdesc */ - nscolumns = (ParseNamespaceColumn *) - palloc0(maxattrs * sizeof(ParseNamespaceColumn)); + nscolumns = palloc0_array(ParseNamespaceColumn, maxattrs); for (varattno = 0; varattno < maxattrs; varattno++) { @@ -1413,8 +1412,7 @@ buildNSItemFromLists(RangeTblEntry *rte, Index rtindex, Assert(maxattrs == list_length(colcollations)); /* extract per-column data from the lists */ - nscolumns = (ParseNamespaceColumn *) - palloc0(maxattrs * sizeof(ParseNamespaceColumn)); + nscolumns = palloc0_array(ParseNamespaceColumn, maxattrs); varattno = 0; forthree(lct, coltypes, diff --git a/src/backend/partitioning/partbounds.c b/src/backend/partitioning/partbounds.c index a7822a4192b..865a92c8561 100644 --- a/src/backend/partitioning/partbounds.c +++ b/src/backend/partitioning/partbounds.c @@ -387,7 +387,7 @@ create_hash_bounds(PartitionBoundSpec **boundspecs, int nparts, boundinfo->kind = NULL; boundinfo->interleaved_parts = NULL; boundinfo->nindexes = greatest_modulus; - boundinfo->indexes = (int *) palloc(greatest_modulus * sizeof(int)); + boundinfo->indexes = palloc_array(int, greatest_modulus); for (i = 0; i < greatest_modulus; i++) boundinfo->indexes[i] = -1; @@ -396,7 +396,7 @@ create_hash_bounds(PartitionBoundSpec **boundspecs, int nparts, * arrays, here we just allocate a single array and below we'll just * assign a portion of this array per partition. */ - boundDatums = (Datum *) palloc(nparts * 2 * sizeof(Datum)); + boundDatums = palloc_array(Datum, nparts * 2); /* * For hash partitioning, there are as many datums (modulus and remainder @@ -478,8 +478,7 @@ create_list_bounds(PartitionBoundSpec **boundspecs, int nparts, boundinfo->default_index = -1; ndatums = get_non_null_list_datum_count(boundspecs, nparts); - all_values = (PartitionListValue *) - palloc(ndatums * sizeof(PartitionListValue)); + all_values = palloc_array(PartitionListValue, ndatums); /* Create a unified list of non-null values across all partitions. */ for (j = 0, i = 0; i < nparts; i++) @@ -535,14 +534,14 @@ create_list_bounds(PartitionBoundSpec **boundspecs, int nparts, boundinfo->kind = NULL; boundinfo->interleaved_parts = NULL; boundinfo->nindexes = ndatums; - boundinfo->indexes = (int *) palloc(ndatums * sizeof(int)); + boundinfo->indexes = palloc_array(int, ndatums); /* * In the loop below, to save from allocating a series of small datum * arrays, here we just allocate a single array and below we'll just * assign a portion of this array per datum. */ - boundDatums = (Datum *) palloc(ndatums * sizeof(Datum)); + boundDatums = palloc_array(Datum, ndatums); /* * Copy values. Canonical indexes are values ranging from 0 to (nparts - @@ -735,8 +734,7 @@ create_range_bounds(PartitionBoundSpec **boundspecs, int nparts, key); /* Save distinct bounds from all_bounds into rbounds. */ - rbounds = (PartitionRangeBound **) - palloc(ndatums * sizeof(PartitionRangeBound *)); + rbounds = palloc_array(PartitionRangeBound *, ndatums); k = 0; prev = NULL; for (i = 0; i < ndatums; i++) @@ -817,7 +815,7 @@ create_range_bounds(PartitionBoundSpec **boundspecs, int nparts, * arrays in each loop. */ partnatts = key->partnatts; - boundDatums = (Datum *) palloc(ndatums * partnatts * sizeof(Datum)); + boundDatums = palloc_array(Datum, ndatums * partnatts); boundKinds = palloc_array(PartitionRangeDatumKind, ndatums * partnatts); for (i = 0; i < ndatums; i++) @@ -1020,16 +1018,14 @@ partition_bounds_copy(PartitionBoundInfo src, /* only RANGE partition should have a non-NULL kind */ Assert(key->strategy == PARTITION_STRATEGY_RANGE); - dest->kind = (PartitionRangeDatumKind **) palloc(ndatums * - sizeof(PartitionRangeDatumKind *)); + dest->kind = palloc_array(PartitionRangeDatumKind *, ndatums); /* * In the loop below, to save from allocating a series of small arrays * for storing the PartitionRangeDatumKind, we allocate a single chunk * here and use a smaller portion of it for each datum. */ - boundKinds = (PartitionRangeDatumKind *) palloc(ndatums * partnatts * - sizeof(PartitionRangeDatumKind)); + boundKinds = palloc_array(PartitionRangeDatumKind, ndatums * partnatts); for (i = 0; i < ndatums; i++) { @@ -1052,7 +1048,7 @@ partition_bounds_copy(PartitionBoundInfo src, { bool hash_part = (key->strategy == PARTITION_STRATEGY_HASH); int natts = hash_part ? 2 : partnatts; - Datum *boundDatums = palloc(ndatums * natts * sizeof(Datum)); + Datum *boundDatums = palloc_array(Datum, ndatums * natts); for (i = 0; i < ndatums; i++) { diff --git a/src/backend/partitioning/partdesc.c b/src/backend/partitioning/partdesc.c index 5a8987bb3c5..f29e5a323a1 100644 --- a/src/backend/partitioning/partdesc.c +++ b/src/backend/partitioning/partdesc.c @@ -171,9 +171,9 @@ retry: /* Allocate working arrays for OIDs, leaf flags, and boundspecs. */ if (nparts > 0) { - oids = (Oid *) palloc(nparts * sizeof(Oid)); - is_leaf = (bool *) palloc(nparts * sizeof(bool)); - boundspecs = palloc(nparts * sizeof(PartitionBoundSpec *)); + oids = palloc_array(Oid, nparts); + is_leaf = palloc_array(bool, nparts); + boundspecs = palloc_array(PartitionBoundSpec *, nparts); } /* Collect bound spec nodes for each partition. */ @@ -335,8 +335,8 @@ retry: partdesc->last_found_datum_index = -1; partdesc->last_found_count = 0; - partdesc->oids = (Oid *) palloc(nparts * sizeof(Oid)); - partdesc->is_leaf = (bool *) palloc(nparts * sizeof(bool)); + partdesc->oids = palloc_array(Oid, nparts); + partdesc->is_leaf = palloc_array(bool, nparts); /* * Assign OIDs from the original array into mapped indexes of the diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c index afe57ac297d..06566c8ce8a 100644 --- a/src/backend/partitioning/partprune.c +++ b/src/backend/partitioning/partprune.c @@ -654,12 +654,12 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel, * Also construct a Bitmapset of all partitions that are present (that * is, not pruned already). */ - subplan_map = (int *) palloc(nparts * sizeof(int)); + subplan_map = palloc_array(int, nparts); memset(subplan_map, -1, nparts * sizeof(int)); - subpart_map = (int *) palloc(nparts * sizeof(int)); + subpart_map = palloc_array(int, nparts); memset(subpart_map, -1, nparts * sizeof(int)); - relid_map = (Oid *) palloc0(nparts * sizeof(Oid)); - leafpart_rti_map = (int *) palloc0(nparts * sizeof(int)); + relid_map = palloc0_array(Oid, nparts); + leafpart_rti_map = palloc0_array(int, nparts); present_parts = NULL; i = -1; @@ -867,8 +867,7 @@ get_matching_partitions(PartitionPruneContext *context, List *pruning_steps) * result of applying all pruning steps is the value contained in the slot * of the last pruning step. */ - results = (PruneStepResult **) - palloc0(num_steps * sizeof(PruneStepResult *)); + results = palloc0_array(PruneStepResult *, num_steps); foreach(lc, pruning_steps) { PartitionPruneStep *step = lfirst(lc); diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c index ee202a4b47e..b877d8fd2de 100644 --- a/src/backend/postmaster/autovacuum.c +++ b/src/backend/postmaster/autovacuum.c @@ -1057,7 +1057,7 @@ rebuild_database_list(Oid newdb) int i; /* put all the hash elements into an array */ - dbary = palloc(nelems * sizeof(avl_dbase)); + dbary = palloc_array(avl_dbase, nelems); /* keep Valgrind quiet */ #ifdef USE_VALGRIND avl_dbase_array = dbary; diff --git a/src/backend/postmaster/checkpointer.c b/src/backend/postmaster/checkpointer.c index f6351f1eb10..580c7944119 100644 --- a/src/backend/postmaster/checkpointer.c +++ b/src/backend/postmaster/checkpointer.c @@ -1459,7 +1459,7 @@ AbsorbSyncRequests(void) if (n > 0) { if (!requests) - requests = (CheckpointerRequest *) palloc(n * sizeof(CheckpointerRequest)); + requests = palloc_array(CheckpointerRequest, n); for (i = 0; i < n; i++) { diff --git a/src/backend/postmaster/datachecksum_state.c b/src/backend/postmaster/datachecksum_state.c index be308a282d5..3406f352357 100644 --- a/src/backend/postmaster/datachecksum_state.c +++ b/src/backend/postmaster/datachecksum_state.c @@ -1528,7 +1528,7 @@ BuildDatabaseList(void) oldctx = MemoryContextSwitchTo(ctx); - db = (DataChecksumsWorkerDatabase *) palloc0(sizeof(DataChecksumsWorkerDatabase)); + db = palloc0_object(DataChecksumsWorkerDatabase); db->dboid = pgdb->oid; db->dbname = pstrdup(NameStr(pgdb->datname)); diff --git a/src/backend/postmaster/pmchild.c b/src/backend/postmaster/pmchild.c index 5c4c66fe76f..312cb2d8aba 100644 --- a/src/backend/postmaster/pmchild.c +++ b/src/backend/postmaster/pmchild.c @@ -137,7 +137,7 @@ InitPostmasterChildSlots(void) num_pmchild_slots += pmchild_pools[i].size; /* Allocate enough slots, and make sure Valgrind doesn't complain */ - slots = palloc(num_pmchild_slots * sizeof(PMChild)); + slots = palloc_array(PMChild, num_pmchild_slots); #ifdef USE_VALGRIND pmchild_array = slots; #endif diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c index 90c7c4528e8..1711743f1ac 100644 --- a/src/backend/postmaster/postmaster.c +++ b/src/backend/postmaster/postmaster.c @@ -1123,7 +1123,7 @@ PostmasterMain(int argc, char *argv[]) * First set up an on_proc_exit function that's charged with closing the * sockets again at postmaster shutdown. */ - ListenSockets = palloc(MAXLISTEN * sizeof(pgsocket)); + ListenSockets = palloc_array(pgsocket, MAXLISTEN); on_proc_exit(CloseServerPorts, 0); if (ListenAddresses) diff --git a/src/backend/replication/pgoutput/pgoutput.c b/src/backend/replication/pgoutput/pgoutput.c index 0afdb1432ca..484ffbe2cee 100644 --- a/src/backend/replication/pgoutput/pgoutput.c +++ b/src/backend/replication/pgoutput/pgoutput.c @@ -1672,7 +1672,7 @@ pgoutput_truncate(LogicalDecodingContext *ctx, ReorderBufferTXN *txn, old = MemoryContextSwitchTo(data->context); - relids = palloc0(nrelations * sizeof(Oid)); + relids = palloc0_array(Oid, nrelations); nrelids = 0; for (i = 0; i < nrelations; i++) diff --git a/src/backend/rewrite/rewriteHandler.c b/src/backend/rewrite/rewriteHandler.c index 3e43418e996..36a724042c6 100644 --- a/src/backend/rewrite/rewriteHandler.c +++ b/src/backend/rewrite/rewriteHandler.c @@ -848,7 +848,7 @@ rewriteTargetListIU(List *targetList, * scan, then appended to the reconstructed tlist. */ numattrs = RelationGetNumberOfAttributes(target_relation); - new_tles = (TargetEntry **) palloc0(numattrs * sizeof(TargetEntry *)); + new_tles = palloc0_array(TargetEntry *, numattrs); next_junk_attrno = numattrs + 1; foreach(temp, targetList) @@ -1492,7 +1492,7 @@ rewriteValuesRTE(Query *parsetree, RangeTblEntry *rte, int rti, * columns), and we complain if such a thing does occur. */ numattrs = list_length(linitial(rte->values_lists)); - attrnos = (int *) palloc0(numattrs * sizeof(int)); + attrnos = palloc0_array(int, numattrs); foreach(lc, parsetree->targetList) { diff --git a/src/backend/statistics/dependencies.c b/src/backend/statistics/dependencies.c index 628526ebff6..81bcf76cc1c 100644 --- a/src/backend/statistics/dependencies.c +++ b/src/backend/statistics/dependencies.c @@ -136,8 +136,9 @@ generate_dependencies_recurse(DependencyGenerator state, int index, */ if (!match) { - state->dependencies = (AttrNumber *) repalloc(state->dependencies, - state->k * (state->ndependencies + 1) * sizeof(AttrNumber)); + state->dependencies = repalloc_array(state->dependencies, + AttrNumber, + state->k * (state->ndependencies + 1)); memcpy(&state->dependencies[(state->k * state->ndependencies)], current, state->k * sizeof(AttrNumber)); state->ndependencies++; diff --git a/src/backend/statistics/extended_stats.c b/src/backend/statistics/extended_stats.c index 332e7423bd8..f0d90f09b07 100644 --- a/src/backend/statistics/extended_stats.c +++ b/src/backend/statistics/extended_stats.c @@ -737,7 +737,7 @@ lookup_var_attr_stats(Bitmapset *attrs, List *exprs, natts = bms_num_members(attrs) + list_length(exprs); - stats = (VacAttrStats **) palloc(natts * sizeof(VacAttrStats *)); + stats = palloc_array(VacAttrStats *, natts); /* lookup VacAttrStats info for the requested columns (same attnum) */ while ((x = bms_next_member(attrs, x)) >= 0) @@ -2175,8 +2175,8 @@ compute_expr_stats(Relation onerel, AnlExprData *exprdata, int nexprs, econtext->ecxt_scantuple = slot; /* Compute and save expression values */ - exprvals = (Datum *) palloc(numrows * sizeof(Datum)); - exprnulls = (bool *) palloc(numrows * sizeof(bool)); + exprvals = palloc_array(Datum, numrows); + exprnulls = palloc_array(bool, numrows); tcnt = 0; for (i = 0; i < numrows; i++) @@ -2293,7 +2293,7 @@ build_expr_data(List *exprs, int stattarget) AnlExprData *exprdata; ListCell *lc; - exprdata = (AnlExprData *) palloc0(nexprs * sizeof(AnlExprData)); + exprdata = palloc0_array(AnlExprData, nexprs); idx = 0; foreach(lc, exprs) @@ -2386,7 +2386,7 @@ serialize_expr_stats(AnlExprData *exprdata, int nexprs) if (nnum > 0) { int n; - Datum *numdatums = (Datum *) palloc(nnum * sizeof(Datum)); + Datum *numdatums = palloc_array(Datum, nnum); ArrayType *arry; for (n = 0; n < nnum; n++) diff --git a/src/backend/statistics/mcv.c b/src/backend/statistics/mcv.c index 3e90f600ebe..10a91c97aeb 100644 --- a/src/backend/statistics/mcv.c +++ b/src/backend/statistics/mcv.c @@ -426,7 +426,7 @@ build_distinct_groups(int numrows, SortItem *items, MultiSortSupport mss, j; int ngroups = count_distinct_groups(numrows, items, mss); - SortItem *groups = (SortItem *) palloc(ngroups * sizeof(SortItem)); + SortItem *groups = palloc_array(SortItem, ngroups); j = 0; groups[0] = items[0]; @@ -1094,7 +1094,7 @@ statext_mcv_deserialize(bytea *data) ptr += (sizeof(Oid) * ndims); /* Now it's safe to access the dimension info. */ - info = palloc(ndims * sizeof(DimensionInfo)); + info = palloc_array(DimensionInfo, ndims); memcpy(info, ptr, ndims * sizeof(DimensionInfo)); ptr += (ndims * sizeof(DimensionInfo)); diff --git a/src/backend/statistics/mvdistinct.c b/src/backend/statistics/mvdistinct.c index a6a904039e5..601f108a2b4 100644 --- a/src/backend/statistics/mvdistinct.c +++ b/src/backend/statistics/mvdistinct.c @@ -307,8 +307,7 @@ statext_ndistinct_deserialize(bytea *data) tmp += sizeof(int); Assert((item->nattributes >= 2) && (item->nattributes <= STATS_MAX_DIMENSIONS)); - item->attributes - = (AttrNumber *) palloc(item->nattributes * sizeof(AttrNumber)); + item->attributes = palloc_array(AttrNumber, item->nattributes); memcpy(item->attributes, tmp, sizeof(AttrNumber) * item->nattributes); tmp += sizeof(AttrNumber) * item->nattributes; diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c index 169829eb020..17f142e4c5b 100644 --- a/src/backend/storage/buffer/bufmgr.c +++ b/src/backend/storage/buffer/bufmgr.c @@ -4948,7 +4948,7 @@ DropRelationsAllBuffers(SMgrRelation *smgr_reln, int nlocators) * forks. */ block = (BlockNumber (*)[MAX_FORKNUM + 1]) - palloc(sizeof(BlockNumber) * n * (MAX_FORKNUM + 1)); + palloc_array(BlockNumber, n * (MAX_FORKNUM + 1)); /* * We can avoid scanning the entire buffer pool if we know the exact size diff --git a/src/backend/storage/ipc/shmem.c b/src/backend/storage/ipc/shmem.c index a3d56cf55dd..228871d2525 100644 --- a/src/backend/storage/ipc/shmem.c +++ b/src/backend/storage/ipc/shmem.c @@ -374,7 +374,7 @@ ShmemRequestInternal(ShmemStructOpts *options, ShmemRequestKind kind) } /* Request looks valid, remember it */ - request = palloc(sizeof(ShmemRequest)); + request = palloc_object(ShmemRequest); request->options = options; request->kind = kind; pending_shmem_requests = lappend(pending_shmem_requests, request); diff --git a/src/backend/storage/lmgr/deadlock.c b/src/backend/storage/lmgr/deadlock.c index b8962d875b6..b6356f72a4e 100644 --- a/src/backend/storage/lmgr/deadlock.c +++ b/src/backend/storage/lmgr/deadlock.c @@ -151,16 +151,16 @@ InitDeadLockChecking(void) * FindLockCycle needs at most MaxBackends entries in visitedProcs[] and * deadlockDetails[]. */ - visitedProcs = (PGPROC **) palloc(MaxBackends * sizeof(PGPROC *)); - deadlockDetails = (DEADLOCK_INFO *) palloc(MaxBackends * sizeof(DEADLOCK_INFO)); + visitedProcs = palloc_array(PGPROC *, MaxBackends); + deadlockDetails = palloc_array(DEADLOCK_INFO, MaxBackends); /* * TopoSort needs to consider at most MaxBackends wait-queue entries, and * it needn't run concurrently with FindLockCycle. */ topoProcs = visitedProcs; /* re-use this space */ - beforeConstraints = (int *) palloc(MaxBackends * sizeof(int)); - afterConstraints = (int *) palloc(MaxBackends * sizeof(int)); + beforeConstraints = palloc_array(int, MaxBackends); + afterConstraints = palloc_array(int, MaxBackends); /* * We need to consider rearranging at most MaxBackends/2 wait queues @@ -168,9 +168,8 @@ InitDeadLockChecking(void) * and the expanded form of the wait queues can't involve more than * MaxBackends total waiters. */ - waitOrders = (WAIT_ORDER *) - palloc((MaxBackends / 2) * sizeof(WAIT_ORDER)); - waitOrderProcs = (PGPROC **) palloc(MaxBackends * sizeof(PGPROC *)); + waitOrders = palloc_array(WAIT_ORDER, MaxBackends / 2); + waitOrderProcs = palloc_array(PGPROC *, MaxBackends); /* * Allow at most MaxBackends distinct constraints in a configuration. (Is @@ -181,7 +180,7 @@ InitDeadLockChecking(void) * really big might potentially allow a stack-overflow problem. */ maxCurConstraints = MaxBackends; - curConstraints = (EDGE *) palloc(maxCurConstraints * sizeof(EDGE)); + curConstraints = palloc_array(EDGE, maxCurConstraints); /* * Allow up to 3*MaxBackends constraints to be saved without having to @@ -195,8 +194,7 @@ InitDeadLockChecking(void) StaticAssertDecl(MAX_BACKENDS_BITS <= (32 - 3), "MAX_BACKENDS_BITS too big for * 4"); maxPossibleConstraints = MaxBackends * 4; - possibleConstraints = - (EDGE *) palloc(maxPossibleConstraints * sizeof(EDGE)); + possibleConstraints = palloc_array(EDGE, maxPossibleConstraints); } MemoryContextSwitchTo(oldcxt); diff --git a/src/backend/storage/lmgr/lock.c b/src/backend/storage/lmgr/lock.c index f2b976d0049..cf5c98c8176 100644 --- a/src/backend/storage/lmgr/lock.c +++ b/src/backend/storage/lmgr/lock.c @@ -928,9 +928,8 @@ LockAcquireExtended(const LOCKTAG *locktag, { int newsize = locallock->maxLockOwners * 2; - locallock->lockOwners = (LOCALLOCKOWNER *) - repalloc(locallock->lockOwners, - newsize * sizeof(LOCALLOCKOWNER)); + locallock->lockOwners = repalloc_array(locallock->lockOwners, + LOCALLOCKOWNER, newsize); locallock->maxLockOwners = newsize; } } @@ -3839,8 +3838,7 @@ GetLockStatusData(void) if (el >= els) { els += MaxBackends; - data->locks = (LockInstanceData *) - repalloc(data->locks, sizeof(LockInstanceData) * els); + data->locks = repalloc_array(data->locks, LockInstanceData, els); } instance = &data->locks[el]; @@ -3872,8 +3870,7 @@ GetLockStatusData(void) if (el >= els) { els += MaxBackends; - data->locks = (LockInstanceData *) - repalloc(data->locks, sizeof(LockInstanceData) * els); + data->locks = repalloc_array(data->locks, LockInstanceData, els); } vxid.procNumber = proc->vxid.procNumber; @@ -3917,8 +3914,7 @@ GetLockStatusData(void) if (data->nelements > els) { els = data->nelements; - data->locks = (LockInstanceData *) - repalloc(data->locks, sizeof(LockInstanceData) * els); + data->locks = repalloc_array(data->locks, LockInstanceData, els); } /* Now scan the tables to copy the data */ @@ -4101,8 +4097,7 @@ GetSingleProcBlockerStatusData(PGPROC *blocked_proc, BlockedProcsData *data) if (data->nlocks >= data->maxlocks) { data->maxlocks += MaxBackends; - data->locks = (LockInstanceData *) - repalloc(data->locks, sizeof(LockInstanceData) * data->maxlocks); + data->locks = repalloc_array(data->locks, LockInstanceData, data->maxlocks); } instance = &data->locks[data->nlocks]; @@ -4128,8 +4123,7 @@ GetSingleProcBlockerStatusData(PGPROC *blocked_proc, BlockedProcsData *data) { data->maxpids = Max(data->maxpids + MaxBackends, data->npids + queue_size); - data->waiter_pids = (int *) repalloc(data->waiter_pids, - sizeof(int) * data->maxpids); + data->waiter_pids = repalloc_array(data->waiter_pids, int, data->maxpids); } /* Collect PIDs from the lock's wait queue, stopping at blocked_proc */ @@ -4183,7 +4177,7 @@ GetRunningTransactionLocks(int *nlocks) * Allocating enough space for all locks in the lock table is overkill, * but it's more convenient and faster than having to enlarge the array. */ - accessExclusiveLocks = palloc(els * sizeof(xl_standby_lock)); + accessExclusiveLocks = palloc_array(xl_standby_lock, els); /* Now scan the tables to copy the data */ hash_seq_init(&seqstat, LockMethodProcLockHash); diff --git a/src/backend/storage/lmgr/lwlock.c b/src/backend/storage/lmgr/lwlock.c index b1ad396ba79..82a1d4d2e26 100644 --- a/src/backend/storage/lmgr/lwlock.c +++ b/src/backend/storage/lmgr/lwlock.c @@ -655,7 +655,7 @@ RequestNamedLWLockTranche(const char *tranche_name, int num_lwlocks) else oldcontext = MemoryContextSwitchTo(TopMemoryContext); - request = palloc0(sizeof(NamedLWLockTrancheRequest)); + request = palloc0_object(NamedLWLockTrancheRequest); strlcpy(request->tranche_name, tranche_name, NAMEDATALEN); request->num_lwlocks = num_lwlocks; NamedLWLockTrancheRequests = lappend(NamedLWLockTrancheRequests, request); diff --git a/src/backend/storage/smgr/md.c b/src/backend/storage/smgr/md.c index 9f96d9cbbfc..780c88c0630 100644 --- a/src/backend/storage/smgr/md.c +++ b/src/backend/storage/smgr/md.c @@ -1668,9 +1668,7 @@ _fdvec_resize(SMgrRelation reln, * FileClose(), and the memory context internally will sometimes avoid * doing an actual reallocation. */ - reln->md_seg_fds[forknum] = - repalloc(reln->md_seg_fds[forknum], - sizeof(MdfdVec) * nseg); + reln->md_seg_fds[forknum] = repalloc_array(reln->md_seg_fds[forknum], MdfdVec, nseg); } else { diff --git a/src/backend/tcop/fastpath.c b/src/backend/tcop/fastpath.c index 365a45bcba9..89300d09cd9 100644 --- a/src/backend/tcop/fastpath.c +++ b/src/backend/tcop/fastpath.c @@ -341,7 +341,7 @@ parse_fcall_arguments(StringInfo msgBuf, struct fp_info *fip, numAFormats = pq_getmsgint(msgBuf, 2); if (numAFormats > 0) { - aformats = (int16 *) palloc(numAFormats * sizeof(int16)); + aformats = palloc_array(int16, numAFormats); for (i = 0; i < numAFormats; i++) aformats[i] = pq_getmsgint(msgBuf, 2); } diff --git a/src/backend/tsearch/dict_thesaurus.c b/src/backend/tsearch/dict_thesaurus.c index 0fd4cf3dfa8..c4c223133a5 100644 --- a/src/backend/tsearch/dict_thesaurus.c +++ b/src/backend/tsearch/dict_thesaurus.c @@ -306,7 +306,7 @@ addCompiledLexeme(TheLexeme *newwrds, int *nnw, int *tnm, TSLexeme *lexeme, Lexe if (*nnw >= *tnm) { *tnm *= 2; - newwrds = (TheLexeme *) repalloc(newwrds, sizeof(TheLexeme) * *tnm); + newwrds = repalloc_array(newwrds, TheLexeme, *tnm); } newwrds[*nnw].entries = palloc_object(LexemeInfo); @@ -495,7 +495,7 @@ compileTheLexeme(DictThesaurus *d) } d->nwrds = newwrds - d->wrds + 1; - d->wrds = (TheLexeme *) repalloc(d->wrds, sizeof(TheLexeme) * d->nwrds); + d->wrds = repalloc_array(d->wrds, TheLexeme, d->nwrds); } } @@ -547,7 +547,7 @@ compileTheSubstitute(DictThesaurus *d) int diff = outptr - d->subst[i].res; n *= 2; - d->subst[i].res = (TSLexeme *) repalloc(d->subst[i].res, sizeof(TSLexeme) * n); + d->subst[i].res = repalloc_array(d->subst[i].res, TSLexeme, n); outptr = d->subst[i].res + diff; } diff --git a/src/backend/tsearch/spell.c b/src/backend/tsearch/spell.c index 06c90cc0b9f..ceea8ead65a 100644 --- a/src/backend/tsearch/spell.c +++ b/src/backend/tsearch/spell.c @@ -493,7 +493,7 @@ NIAddSpell(IspellDict *Conf, const char *word, const char *flag) if (Conf->mspell) { Conf->mspell *= 2; - Conf->Spell = (SPELL **) repalloc(Conf->Spell, Conf->mspell * sizeof(SPELL *)); + Conf->Spell = repalloc_array(Conf->Spell, SPELL *, Conf->mspell); } else { @@ -687,7 +687,7 @@ NIAddAffix(IspellDict *Conf, const char *flag, char flagflags, const char *mask, if (Conf->maffixes) { Conf->maffixes *= 2; - Conf->Affix = (AFFIX *) repalloc(Conf->Affix, Conf->maffixes * sizeof(AFFIX)); + Conf->Affix = repalloc_array(Conf->Affix, AFFIX, Conf->maffixes); } else { @@ -1106,9 +1106,9 @@ addCompoundAffixFlagValue(IspellDict *Conf, const char *s, uint32 val) if (Conf->mCompoundAffixFlag) { Conf->mCompoundAffixFlag *= 2; - Conf->CompoundAffixFlags = (CompoundAffixFlag *) - repalloc(Conf->CompoundAffixFlags, - Conf->mCompoundAffixFlag * sizeof(CompoundAffixFlag)); + Conf->CompoundAffixFlags = repalloc_array(Conf->CompoundAffixFlags, + CompoundAffixFlag, + Conf->mCompoundAffixFlag); } else { @@ -1611,8 +1611,7 @@ MergeAffix(IspellDict *Conf, int a1, int a2) if (Conf->nAffixData + 1 >= Conf->lenAffixData) { Conf->lenAffixData *= 2; - Conf->AffixData = (const char **) repalloc(Conf->AffixData, - sizeof(char *) * Conf->lenAffixData); + Conf->AffixData = repalloc_array(Conf->AffixData, const char *, Conf->lenAffixData); } ptr = Conf->AffixData + Conf->nAffixData; @@ -2042,7 +2041,8 @@ NISortAffixes(IspellDict *Conf) } } ptr->affix = NULL; - Conf->CompoundAffix = (CMPDAffix *) repalloc(Conf->CompoundAffix, sizeof(CMPDAffix) * (ptr - Conf->CompoundAffix + 1)); + Conf->CompoundAffix = repalloc_array(Conf->CompoundAffix, + CMPDAffix, ptr - Conf->CompoundAffix + 1); /* Start build a prefix tree */ Conf->Prefix = mkANode(Conf, 0, firstsuffix, 0, FF_PREFIX); @@ -2425,7 +2425,7 @@ AddStem(SplitVar *v, char *word) if (v->nstem >= v->lenstem) { v->lenstem *= 2; - v->stem = (char **) repalloc(v->stem, sizeof(char *) * v->lenstem); + v->stem = repalloc_array(v->stem, char *, v->lenstem); } v->stem[v->nstem] = word; diff --git a/src/backend/tsearch/ts_parse.c b/src/backend/tsearch/ts_parse.c index 93d46f1d642..affc3d84bfe 100644 --- a/src/backend/tsearch/ts_parse.c +++ b/src/backend/tsearch/ts_parse.c @@ -428,7 +428,7 @@ parsetext(Oid cfgId, ParsedText *prs, char *buf, int buflen) if (prs->curwords == prs->lenwords) { prs->lenwords *= 2; - prs->words = (ParsedWord *) repalloc(prs->words, prs->lenwords * sizeof(ParsedWord)); + prs->words = repalloc_array(prs->words, ParsedWord, prs->lenwords); } if (ptr->flags & TSL_ADDPOS) @@ -459,7 +459,7 @@ hladdword(HeadlineParsedText *prs, char *buf, int buflen, int type) if (prs->curwords >= prs->lenwords) { prs->lenwords *= 2; - prs->words = (HeadlineWordEntry *) repalloc(prs->words, prs->lenwords * sizeof(HeadlineWordEntry)); + prs->words = repalloc_array(prs->words, HeadlineWordEntry, prs->lenwords); } memset(&(prs->words[prs->curwords]), 0, sizeof(HeadlineWordEntry)); prs->words[prs->curwords].type = (uint8) type; @@ -487,7 +487,7 @@ hlfinditem(HeadlineParsedText *prs, TSQuery query, int32 pos, char *buf, int buf while (prs->curwords + query->size >= prs->lenwords) { prs->lenwords *= 2; - prs->words = (HeadlineWordEntry *) repalloc(prs->words, prs->lenwords * sizeof(HeadlineWordEntry)); + prs->words = repalloc_array(prs->words, HeadlineWordEntry, prs->lenwords); } word = &(prs->words[prs->curwords - 1]); diff --git a/src/backend/tsearch/wparser.c b/src/backend/tsearch/wparser.c index 8a782b66030..50c1887bdf6 100644 --- a/src/backend/tsearch/wparser.c +++ b/src/backend/tsearch/wparser.c @@ -190,7 +190,7 @@ prs_setup_firstcall(FuncCallContext *funcctx, FunctionCallInfo fcinfo, if (st->cur >= st->len) { st->len = 2 * st->len; - st->list = (LexemeEntry *) repalloc(st->list, sizeof(LexemeEntry) * st->len); + st->list = repalloc_array(st->list, LexemeEntry, st->len); } st->list[st->cur].lexeme = palloc(llen + 1); memcpy(st->list[st->cur].lexeme, lex, llen); diff --git a/src/backend/tsearch/wparser_def.c b/src/backend/tsearch/wparser_def.c index 480915030df..f1ed8a71c52 100644 --- a/src/backend/tsearch/wparser_def.c +++ b/src/backend/tsearch/wparser_def.c @@ -2252,7 +2252,7 @@ mark_hl_fragments(HeadlineParsedText *prs, TSQuery query, List *locations, maxitems; CoverPos *covers; - covers = palloc(maxcovers * sizeof(CoverPos)); + covers = palloc_array(CoverPos, maxcovers); /* get all covers */ while (hlCover(prs, query, locations, &nextpos, &p, &q)) @@ -2273,7 +2273,7 @@ mark_hl_fragments(HeadlineParsedText *prs, TSQuery query, List *locations, if (numcovers >= maxcovers) { maxcovers *= 2; - covers = repalloc(covers, sizeof(CoverPos) * maxcovers); + covers = repalloc_array(covers, CoverPos, maxcovers); } covers[numcovers].startpos = startpos; covers[numcovers].endpos = endpos; diff --git a/src/backend/utils/activity/pgstat_xact.c b/src/backend/utils/activity/pgstat_xact.c index 3e1978775e1..820cf97de87 100644 --- a/src/backend/utils/activity/pgstat_xact.c +++ b/src/backend/utils/activity/pgstat_xact.c @@ -285,8 +285,7 @@ pgstat_get_transactional_drops(bool isCommit, xl_xact_stats_item **items) Assert(!isCommit || xact_state->nest_level == 1); Assert(!isCommit || xact_state->prev == NULL); - *items = palloc(dclist_count(&xact_state->pending_drops) - * sizeof(xl_xact_stats_item)); + *items = palloc_array(xl_xact_stats_item, dclist_count(&xact_state->pending_drops)); dclist_foreach(iter, &xact_state->pending_drops) { diff --git a/src/backend/utils/adt/acl.c b/src/backend/utils/adt/acl.c index 090a69be071..25cd5d0296b 100644 --- a/src/backend/utils/adt/acl.c +++ b/src/backend/utils/adt/acl.c @@ -1584,7 +1584,7 @@ aclmembers(const Acl *acl, Oid **roleids) check_acl(acl); /* Allocate the worst-case space requirement */ - list = palloc(ACL_NUM(acl) * 2 * sizeof(Oid)); + list = palloc_array(Oid, ACL_NUM(acl) * 2); acldat = ACL_DAT(acl); /* diff --git a/src/backend/utils/adt/array_typanalyze.c b/src/backend/utils/adt/array_typanalyze.c index 7bb000ddbd3..bcc58c5832e 100644 --- a/src/backend/utils/adt/array_typanalyze.c +++ b/src/backend/utils/adt/array_typanalyze.c @@ -549,8 +549,8 @@ compute_array_stats(VacAttrStats *stats, AnalyzeAttrFetchFunc fetchfunc, * through all the values. We also want the frequency of null * elements. Store these three values at the end of mcelem_freqs. */ - mcelem_values = (Datum *) palloc(num_mcelem * sizeof(Datum)); - mcelem_freqs = (float4 *) palloc((num_mcelem + 3) * sizeof(float4)); + mcelem_values = palloc_array(Datum, num_mcelem); + mcelem_freqs = palloc_array(float4, num_mcelem + 3); /* * See comments above about use of nonnull_cnt as the divisor for diff --git a/src/backend/utils/adt/array_userfuncs.c b/src/backend/utils/adt/array_userfuncs.c index 9d7f67cc188..d830b065bd1 100644 --- a/src/backend/utils/adt/array_userfuncs.c +++ b/src/backend/utils/adt/array_userfuncs.c @@ -662,10 +662,8 @@ array_agg_combine(PG_FUNCTION_ARGS) { /* Use a power of 2 size rather than allocating just reqsize */ state1->alen = pg_nextpower2_32(reqsize); - state1->dvalues = (Datum *) repalloc(state1->dvalues, - state1->alen * sizeof(Datum)); - state1->dnulls = (bool *) repalloc(state1->dnulls, - state1->alen * sizeof(bool)); + state1->dvalues = repalloc_array(state1->dvalues, Datum, state1->alen); + state1->dnulls = repalloc_array(state1->dnulls, bool, state1->alen); } /* Copy in the state2 elements to the end of the state1 arrays */ @@ -1096,7 +1094,7 @@ array_agg_array_combine(PG_FUNCTION_ARGS) * previous inputs by marking all their items non-null. */ state1->aitems = pg_nextpower2_32(Max(256, newnitems)); - state1->nullbitmap = (uint8 *) palloc((state1->aitems + 7) / 8); + state1->nullbitmap = palloc_array(uint8, (state1->aitems + 7) / 8); array_bitmap_copy(state1->nullbitmap, 0, NULL, 0, state1->nitems); @@ -1104,8 +1102,8 @@ array_agg_array_combine(PG_FUNCTION_ARGS) else if (newnitems > state1->aitems) { state1->aitems = pg_nextpower2_32(newnitems); - state1->nullbitmap = (uint8 *) - repalloc(state1->nullbitmap, (state1->aitems + 7) / 8); + state1->nullbitmap = repalloc_array(state1->nullbitmap, + uint8, (state1->aitems + 7) / 8); } /* This will do the right thing if state2->nullbitmap is NULL: */ array_bitmap_copy(state1->nullbitmap, state1->nitems, diff --git a/src/backend/utils/adt/arrayfuncs.c b/src/backend/utils/adt/arrayfuncs.c index 13eed22dd6a..ef66182b047 100644 --- a/src/backend/utils/adt/arrayfuncs.c +++ b/src/backend/utils/adt/arrayfuncs.c @@ -1112,8 +1112,8 @@ array_out(PG_FUNCTION_ARGS) * any overhead such as escaping backslashes), and detect whether each * item needs double quotes. */ - values = (char **) palloc(nitems * sizeof(char *)); - needquotes = (bool *) palloc(nitems * sizeof(bool)); + values = palloc_array(char *, nitems); + needquotes = palloc_array(bool, nitems); overall_length = 0; array_iter_setup(&iter, v, typlen, typbyval, typalign); @@ -1397,8 +1397,8 @@ array_recv(PG_FUNCTION_ARGS) typalign = my_extra->typalign; typioparam = my_extra->typioparam; - dataPtr = (Datum *) palloc(nitems * sizeof(Datum)); - nullsPtr = (bool *) palloc(nitems * sizeof(bool)); + dataPtr = palloc_array(Datum, nitems); + nullsPtr = palloc_array(bool, nitems); ReadArrayBinary(buf, nitems, &my_extra->proc, typioparam, typmod, typlen, typbyval, typalign, @@ -2676,11 +2676,9 @@ array_set_element_expanded(Datum arraydatum, int newlen = dim[0] + dim[0] / 8; newlen = Max(newlen, dim[0]); /* integer overflow guard */ - eah->dvalues = dvalues = (Datum *) - repalloc(dvalues, newlen * sizeof(Datum)); + eah->dvalues = dvalues = repalloc_array(dvalues, Datum, newlen); if (dnulls) - eah->dnulls = dnulls = (bool *) - repalloc(dnulls, newlen * sizeof(bool)); + eah->dnulls = dnulls = repalloc_array(dnulls, bool, newlen); eah->dvalueslen = newlen; } @@ -3278,8 +3276,8 @@ array_map(Datum arrayd, typalignby = typalign_to_alignby(typalign); /* Allocate temporary arrays for new values */ - values = (Datum *) palloc(nitems * sizeof(Datum)); - nulls = (bool *) palloc(nitems * sizeof(bool)); + values = palloc_array(Datum, nitems); + nulls = palloc_array(bool, nitems); /* Loop over source data */ array_iter_setup(&iter, v, inp_typlen, inp_typbyval, inp_typalign); @@ -4663,10 +4661,8 @@ array_create_iterator(ArrayType *arr, int slice_ndim, ArrayMetaState *mstate) /* * Create workspace for building sub-arrays. */ - iterator->slice_values = (Datum *) - palloc(iterator->slice_len * sizeof(Datum)); - iterator->slice_nulls = (bool *) - palloc(iterator->slice_len * sizeof(bool)); + iterator->slice_values = palloc_array(Datum, iterator->slice_len); + iterator->slice_nulls = palloc_array(bool, iterator->slice_len); } /* @@ -5391,10 +5387,8 @@ accumArrayResult(ArrayBuildState *astate, (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED), errmsg("array size exceeds the maximum allowed (%zu)", MaxAllocSize))); - astate->dvalues = (Datum *) - repalloc(astate->dvalues, astate->alen * sizeof(Datum)); - astate->dnulls = (bool *) - repalloc(astate->dnulls, astate->alen * sizeof(bool)); + astate->dvalues = repalloc_array(astate->dvalues, Datum, astate->alen); + astate->dnulls = repalloc_array(astate->dnulls, bool, astate->alen); } /* @@ -5686,7 +5680,7 @@ accumArrayResultArr(ArrayBuildStateArr *astate, * previous inputs by marking all their items non-null. */ astate->aitems = pg_nextpower2_32(Max(256, newnitems + 1)); - astate->nullbitmap = (uint8 *) palloc((astate->aitems + 7) / 8); + astate->nullbitmap = palloc_array(uint8, (astate->aitems + 7) / 8); array_bitmap_copy(astate->nullbitmap, 0, NULL, 0, astate->nitems); @@ -5694,8 +5688,8 @@ accumArrayResultArr(ArrayBuildStateArr *astate, else if (newnitems > astate->aitems) { astate->aitems = Max(astate->aitems * 2, newnitems); - astate->nullbitmap = (uint8 *) - repalloc(astate->nullbitmap, (astate->aitems + 7) / 8); + astate->nullbitmap = repalloc_array(astate->nullbitmap, + uint8, (astate->aitems + 7) / 8); } array_bitmap_copy(astate->nullbitmap, astate->nitems, ARR_NULLBITMAP(arg), 0, @@ -6489,8 +6483,8 @@ array_replace_internal(ArrayType *array, collation, NULL, NULL); /* Allocate temporary arrays for new values */ - values = (Datum *) palloc(nitems * sizeof(Datum)); - nulls = (bool *) palloc(nitems * sizeof(bool)); + values = palloc_array(Datum, nitems); + nulls = palloc_array(bool, nitems); /* Loop over source data */ arraydataptr = ARR_DATA_PTR(array); diff --git a/src/backend/utils/adt/arrayutils.c b/src/backend/utils/adt/arrayutils.c index ca861a42037..2ad26f9b381 100644 --- a/src/backend/utils/adt/arrayutils.c +++ b/src/backend/utils/adt/arrayutils.c @@ -253,7 +253,7 @@ ArrayGetIntegerTypmods(ArrayType *arr, int *n) deconstruct_array_builtin(arr, CSTRINGOID, &elem_values, NULL, n); - result = (int32 *) palloc(*n * sizeof(int32)); + result = palloc_array(int32, *n); for (i = 0; i < *n; i++) result[i] = pg_strtoint32(DatumGetCString(elem_values[i])); diff --git a/src/backend/utils/adt/enum.c b/src/backend/utils/adt/enum.c index 286d4311ed5..9b87373e0e9 100644 --- a/src/backend/utils/adt/enum.c +++ b/src/backend/utils/adt/enum.c @@ -572,7 +572,7 @@ enum_range_internal(Oid enumtypoid, Oid lower, Oid upper) enum_scan = systable_beginscan_ordered(enum_rel, enum_idx, NULL, 1, &skey); max = 64; - elems = (Datum *) palloc(max * sizeof(Datum)); + elems = palloc_array(Datum, max); cnt = 0; left_found = !OidIsValid(lower); @@ -591,7 +591,7 @@ enum_range_internal(Oid enumtypoid, Oid lower, Oid upper) if (cnt >= max) { max *= 2; - elems = (Datum *) repalloc(elems, max * sizeof(Datum)); + elems = repalloc_array(elems, Datum, max); } elems[cnt++] = ObjectIdGetDatum(enum_oid); diff --git a/src/backend/utils/adt/jsonb_util.c b/src/backend/utils/adt/jsonb_util.c index 91fb9ea09bf..b23facb6dac 100644 --- a/src/backend/utils/adt/jsonb_util.c +++ b/src/backend/utils/adt/jsonb_util.c @@ -799,8 +799,8 @@ appendKey(JsonbInState *pstate, JsonbValue *string, bool needCopy) errmsg("number of jsonb object pairs exceeds the maximum allowed (%zu)", JSONB_MAX_PAIRS))); ppstate->size = Min(ppstate->size * 2, JSONB_MAX_PAIRS); - object->val.object.pairs = repalloc(object->val.object.pairs, - sizeof(JsonbPair) * ppstate->size); + object->val.object.pairs = repalloc_array(object->val.object.pairs, + JsonbPair, ppstate->size); } pair = &object->val.object.pairs[object->val.object.nPairs]; @@ -850,8 +850,8 @@ appendElement(JsonbInState *pstate, JsonbValue *scalarVal, bool needCopy) errmsg("number of jsonb array elements exceeds the maximum allowed (%zu)", JSONB_MAX_ELEMS))); ppstate->size = Min(ppstate->size * 2, JSONB_MAX_ELEMS); - array->val.array.elems = repalloc(array->val.array.elems, - sizeof(JsonbValue) * ppstate->size); + array->val.array.elems = repalloc_array(array->val.array.elems, + JsonbValue, ppstate->size); } elem = &array->val.array.elems[array->val.array.nElems]; diff --git a/src/backend/utils/adt/jsonfuncs.c b/src/backend/utils/adt/jsonfuncs.c index 97cc3d60340..bc7b556e22e 100644 --- a/src/backend/utils/adt/jsonfuncs.c +++ b/src/backend/utils/adt/jsonfuncs.c @@ -613,7 +613,7 @@ jsonb_object_keys(PG_FUNCTION_ARGS) { char *cstr; - cstr = palloc(v.val.string.len + 1 * sizeof(char)); + cstr = palloc_array(char, v.val.string.len + 1); memcpy(cstr, v.val.string.val, v.val.string.len); cstr[v.val.string.len] = '\0'; state->result[state->result_count++] = cstr; @@ -798,8 +798,7 @@ okeys_object_field_start(void *state, char *fname, bool isnull) if (_state->result_count >= _state->result_size) { _state->result_size *= 2; - _state->result = (char **) - repalloc(_state->result, sizeof(char *) * _state->result_size); + _state->result = repalloc_array(_state->result, char *, _state->result_size); } /* save a copy of the field name */ @@ -3555,8 +3554,8 @@ populate_record(TupleDesc tupdesc, record->ncolumns = ncolumns; } - values = (Datum *) palloc(ncolumns * sizeof(Datum)); - nulls = (bool *) palloc(ncolumns * sizeof(bool)); + values = palloc_array(Datum, ncolumns); + nulls = palloc_array(bool, ncolumns); if (defaultval) { @@ -3911,7 +3910,7 @@ hash_object_field_end(void *state, char *fname, bool isnull) if (_state->save_json_start != NULL) { int len = _state->lex->prev_token_terminator - _state->save_json_start; - char *val = palloc((len + 1) * sizeof(char)); + char *val = palloc_array(char, len + 1); memcpy(val, _state->save_json_start, len); val[len] = '\0'; @@ -4362,7 +4361,7 @@ populate_recordset_object_field_end(void *state, char *fname, bool isnull) if (_state->save_json_start != NULL) { int len = _state->lex->prev_token_terminator - _state->save_json_start; - char *val = palloc((len + 1) * sizeof(char)); + char *val = palloc_array(char, len + 1); memcpy(val, _state->save_json_start, len); val[len] = '\0'; diff --git a/src/backend/utils/adt/levenshtein.c b/src/backend/utils/adt/levenshtein.c index 9b676165a70..db54ab9f6b4 100644 --- a/src/backend/utils/adt/levenshtein.c +++ b/src/backend/utils/adt/levenshtein.c @@ -200,7 +200,7 @@ varstr_levenshtein(const char *source, int slen, int i; const char *cp = source; - s_char_len = (int *) palloc((m + 1) * sizeof(int)); + s_char_len = palloc_array(int, m + 1); for (i = 0; i < m; ++i) { s_char_len[i] = pg_mblen_range(cp, send); diff --git a/src/backend/utils/adt/like_support.c b/src/backend/utils/adt/like_support.c index e354360a8e6..588425b3812 100644 --- a/src/backend/utils/adt/like_support.c +++ b/src/backend/utils/adt/like_support.c @@ -1109,10 +1109,10 @@ like_fixed_prefix_ci(Const *patt_const, Oid collation, Const **prefix_const, locale = pg_newlocale_from_collation(collation); - wpatt = palloc((nbytes + 1) * sizeof(pg_wchar)); + wpatt = palloc_array(pg_wchar, nbytes + 1); wpattlen = pg_mb2wchar_with_len(VARDATA_ANY(val), wpatt, nbytes); - wmatch = palloc((nbytes + 1) * sizeof(pg_wchar)); + wmatch = palloc_array(pg_wchar, nbytes + 1); for (wpos = 0; wpos < wpattlen; wpos++) { /* % and _ are wildcard characters in LIKE */ diff --git a/src/backend/utils/adt/lockfuncs.c b/src/backend/utils/adt/lockfuncs.c index 8e9f160db97..3eb9a5b4215 100644 --- a/src/backend/utils/adt/lockfuncs.c +++ b/src/backend/utils/adt/lockfuncs.c @@ -477,7 +477,7 @@ pg_blocking_pids(PG_FUNCTION_ARGS) lockData = GetBlockerStatusData(blocked_pid); /* We can't need more output entries than there are reported PROCLOCKs */ - arrayelems = (Datum *) palloc(lockData->nlocks * sizeof(Datum)); + arrayelems = palloc_array(Datum, lockData->nlocks); narrayelems = 0; /* For each blocked proc in the lock group ... */ @@ -579,7 +579,7 @@ pg_safe_snapshot_blocking_pids(PG_FUNCTION_ARGS) Datum *blocker_datums; /* A buffer big enough for any possible blocker list without truncation */ - blockers = (int *) palloc(MaxBackends * sizeof(int)); + blockers = palloc_array(int, MaxBackends); /* Collect a snapshot of processes waited for by GetSafeSnapshot */ num_blockers = @@ -590,7 +590,7 @@ pg_safe_snapshot_blocking_pids(PG_FUNCTION_ARGS) { int i; - blocker_datums = (Datum *) palloc(num_blockers * sizeof(Datum)); + blocker_datums = palloc_array(Datum, num_blockers); for (i = 0; i < num_blockers; ++i) blocker_datums[i] = Int32GetDatum(blockers[i]); } diff --git a/src/backend/utils/adt/multirangetypes.c b/src/backend/utils/adt/multirangetypes.c index c62a5e755ea..e72a2efadcd 100644 --- a/src/backend/utils/adt/multirangetypes.c +++ b/src/backend/utils/adt/multirangetypes.c @@ -201,8 +201,7 @@ multirange_in(PG_FUNCTION_ARGS) if (range_capacity == range_count) { range_capacity *= 2; - ranges = (RangeType **) - repalloc(ranges, range_capacity * sizeof(RangeType *)); + ranges = repalloc_array(ranges, RangeType *, range_capacity); } ranges_seen++; if (!InputFunctionCallSafe(&cache->typioproc, @@ -1004,7 +1003,7 @@ multirange_constructor2(PG_FUNCTION_ARGS) deconstruct_array(rangeArray, rngtypid, rangetyp->typlen, rangetyp->typbyval, rangetyp->typalign, &elements, &nulls, &range_count); - ranges = palloc0(range_count * sizeof(RangeType *)); + ranges = palloc0_array(RangeType *, range_count); for (i = 0; i < range_count; i++) { if (nulls[i]) @@ -1108,7 +1107,7 @@ multirange_union(PG_FUNCTION_ARGS) multirange_deserialize(typcache->rngtype, mr2, &range_count2, &ranges2); range_count3 = range_count1 + range_count2; - ranges3 = palloc0(range_count3 * sizeof(RangeType *)); + ranges3 = palloc0_array(RangeType *, range_count3); memcpy(ranges3, ranges1, range_count1 * sizeof(RangeType *)); memcpy(ranges3 + range_count1, ranges2, range_count2 * sizeof(RangeType *)); PG_RETURN_MULTIRANGE_P(make_multirange(typcache->type_id, typcache->rngtype, @@ -1162,7 +1161,7 @@ multirange_minus_internal(Oid mltrngtypoid, TypeCacheEntry *rangetyp, * Worst case: every range in ranges1 makes a different cut to some range * in ranges2. */ - ranges3 = palloc0((range_count1 + range_count2) * sizeof(RangeType *)); + ranges3 = palloc0_array(RangeType *, range_count1 + range_count2); range_count3 = 0; /* @@ -1359,7 +1358,7 @@ multirange_intersect_internal(Oid mltrngtypoid, TypeCacheEntry *rangetyp, * but one extra won't hurt. *----------------------------------------------- */ - ranges3 = palloc0((range_count1 + range_count2) * sizeof(RangeType *)); + ranges3 = palloc0_array(RangeType *, range_count1 + range_count2); range_count3 = 0; /* @@ -1472,7 +1471,7 @@ range_agg_finalfn(PG_FUNCTION_ARGS) mltrngtypoid = get_fn_expr_rettype(fcinfo->flinfo); typcache = multirange_get_typcache(fcinfo, mltrngtypoid); - ranges = palloc0(range_count * sizeof(RangeType *)); + ranges = palloc0_array(RangeType *, range_count); for (i = 0; i < range_count; i++) ranges[i] = DatumGetRangeTypeP(state->dvalues[i]); diff --git a/src/backend/utils/adt/name.c b/src/backend/utils/adt/name.c index 4e9131a0b20..cbd1808bb5c 100644 --- a/src/backend/utils/adt/name.c +++ b/src/backend/utils/adt/name.c @@ -299,7 +299,7 @@ current_schemas(PG_FUNCTION_ARGS) int i; ArrayType *array; - names = (Datum *) palloc(list_length(search_path) * sizeof(Datum)); + names = palloc_array(Datum, list_length(search_path)); i = 0; foreach(l, search_path) { diff --git a/src/backend/utils/adt/numeric.c b/src/backend/utils/adt/numeric.c index 90d278e0b38..523cd3cd608 100644 --- a/src/backend/utils/adt/numeric.c +++ b/src/backend/utils/adt/numeric.c @@ -476,7 +476,7 @@ static void dump_var(const char *str, NumericVar *var); #endif #define digitbuf_alloc(ndigits) \ - ((NumericDigit *) palloc((ndigits) * sizeof(NumericDigit))) + (palloc_array(NumericDigit, (ndigits))) #define digitbuf_free(buf) \ do { \ if ((buf) != NULL) \ @@ -12084,8 +12084,8 @@ accum_sum_rescale(NumericSumAccum *accum, const NumericVar *val) weightdiff = accum_weight - old_weight; - new_pos_digits = palloc0(accum_ndigits * sizeof(int32)); - new_neg_digits = palloc0(accum_ndigits * sizeof(int32)); + new_pos_digits = palloc0_array(int32, accum_ndigits); + new_neg_digits = palloc0_array(int32, accum_ndigits); if (accum->pos_digits) { @@ -12173,8 +12173,8 @@ accum_sum_final(NumericSumAccum *accum, NumericVar *result) static void accum_sum_copy(NumericSumAccum *dst, NumericSumAccum *src) { - dst->pos_digits = palloc(src->ndigits * sizeof(int32)); - dst->neg_digits = palloc(src->ndigits * sizeof(int32)); + dst->pos_digits = palloc_array(int32, src->ndigits); + dst->neg_digits = palloc_array(int32, src->ndigits); memcpy(dst->pos_digits, src->pos_digits, src->ndigits * sizeof(int32)); memcpy(dst->neg_digits, src->neg_digits, src->ndigits * sizeof(int32)); diff --git a/src/backend/utils/adt/oracle_compat.c b/src/backend/utils/adt/oracle_compat.c index 17880f937ac..7422a454397 100644 --- a/src/backend/utils/adt/oracle_compat.c +++ b/src/backend/utils/adt/oracle_compat.c @@ -424,8 +424,8 @@ dotrim(const char *string, int stringlen, const char *str_pos; int str_len; - stringchars = (const char **) palloc(stringlen * sizeof(char *)); - stringmblen = (int *) palloc(stringlen * sizeof(int)); + stringchars = palloc_array(const char *, stringlen); + stringmblen = palloc_array(int, stringlen); stringnchars = 0; p = string; len = stringlen; @@ -439,8 +439,8 @@ dotrim(const char *string, int stringlen, len -= mblen; } - setchars = (const char **) palloc(setlen * sizeof(char *)); - setmblen = (int *) palloc(setlen * sizeof(int)); + setchars = palloc_array(const char *, setlen); + setmblen = palloc_array(int, setlen); setnchars = 0; p = set; len = setlen; diff --git a/src/backend/utils/adt/orderedsetaggs.c b/src/backend/utils/adt/orderedsetaggs.c index fd8b8676470..657fc4969a1 100644 --- a/src/backend/utils/adt/orderedsetaggs.c +++ b/src/backend/utils/adt/orderedsetaggs.c @@ -173,11 +173,11 @@ ordered_set_startup(FunctionCallInfo fcinfo, bool use_tuples) if (ishypothetical) numSortCols++; /* make space for flag column */ qstate->numSortCols = numSortCols; - qstate->sortColIdx = (AttrNumber *) palloc(numSortCols * sizeof(AttrNumber)); - qstate->sortOperators = (Oid *) palloc(numSortCols * sizeof(Oid)); - qstate->eqOperators = (Oid *) palloc(numSortCols * sizeof(Oid)); - qstate->sortCollations = (Oid *) palloc(numSortCols * sizeof(Oid)); - qstate->sortNullsFirsts = (bool *) palloc(numSortCols * sizeof(bool)); + qstate->sortColIdx = palloc_array(AttrNumber, numSortCols); + qstate->sortOperators = palloc_array(Oid, numSortCols); + qstate->eqOperators = palloc_array(Oid, numSortCols); + qstate->sortCollations = palloc_array(Oid, numSortCols); + qstate->sortNullsFirsts = palloc_array(bool, numSortCols); i = 0; foreach(lc, sortlist) @@ -669,7 +669,7 @@ setup_pct_info(int num_percentiles, struct pct_info *pct_info; int i; - pct_info = (struct pct_info *) palloc(num_percentiles * sizeof(struct pct_info)); + pct_info = palloc_array(struct pct_info, num_percentiles); for (i = 0; i < num_percentiles; i++) { @@ -775,8 +775,8 @@ percentile_disc_multi_final(PG_FUNCTION_ARGS) osastate->number_of_rows, false); - result_datum = (Datum *) palloc(num_percentiles * sizeof(Datum)); - result_isnull = (bool *) palloc(num_percentiles * sizeof(bool)); + result_datum = palloc_array(Datum, num_percentiles); + result_isnull = palloc_array(bool, num_percentiles); /* * Start by dealing with any nulls in the param array - those are sorted @@ -898,8 +898,8 @@ percentile_cont_multi_final_common(FunctionCallInfo fcinfo, osastate->number_of_rows, true); - result_datum = (Datum *) palloc(num_percentiles * sizeof(Datum)); - result_isnull = (bool *) palloc(num_percentiles * sizeof(bool)); + result_datum = palloc_array(Datum, num_percentiles); + result_isnull = palloc_array(bool, num_percentiles); /* * Start by dealing with any nulls in the param array - those are sorted diff --git a/src/backend/utils/adt/pg_ndistinct.c b/src/backend/utils/adt/pg_ndistinct.c index 2cdc8ebb912..52a9eea6a59 100644 --- a/src/backend/utils/adt/pg_ndistinct.c +++ b/src/backend/utils/adt/pg_ndistinct.c @@ -177,7 +177,7 @@ ndistinct_object_end(void *state) /* Create the MVNDistinctItem */ item = palloc_object(MVNDistinctItem); item->nattributes = natts; - item->attributes = palloc0(natts * sizeof(AttrNumber)); + item->attributes = palloc0_array(AttrNumber, natts); item->ndistinct = (double) parse->ndistinct; for (int i = 0; i < natts; i++) diff --git a/src/backend/utils/adt/rangetypes_typanalyze.c b/src/backend/utils/adt/rangetypes_typanalyze.c index 278d4e6941a..b152b1e86ae 100644 --- a/src/backend/utils/adt/rangetypes_typanalyze.c +++ b/src/backend/utils/adt/rangetypes_typanalyze.c @@ -288,7 +288,7 @@ compute_range_stats(VacAttrStats *stats, AnalyzeAttrFetchFunc fetchfunc, if (num_hist > num_bins) num_hist = num_bins + 1; - bound_hist_values = (Datum *) palloc(num_hist * sizeof(Datum)); + bound_hist_values = palloc_array(Datum, num_hist); /* * The object of this loop is to construct ranges from first and @@ -352,7 +352,7 @@ compute_range_stats(VacAttrStats *stats, AnalyzeAttrFetchFunc fetchfunc, if (num_hist > num_bins) num_hist = num_bins + 1; - length_hist_values = (Datum *) palloc(num_hist * sizeof(Datum)); + length_hist_values = palloc_array(Datum, num_hist); /* * The object of this loop is to copy the first and last lengths[] diff --git a/src/backend/utils/adt/regexp.c b/src/backend/utils/adt/regexp.c index 0768b5c7389..f157f83da7e 100644 --- a/src/backend/utils/adt/regexp.c +++ b/src/backend/utils/adt/regexp.c @@ -1570,8 +1570,7 @@ setup_regexp_matches(text *orig_str, text *pattern, pg_re_flags *re_flags, ereport(ERROR, (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED), errmsg("too many regular expression matches"))); - matchctx->match_locs = (int *) repalloc(matchctx->match_locs, - sizeof(int) * array_len); + matchctx->match_locs = repalloc_array(matchctx->match_locs, int, array_len); } /* save this match's locations */ diff --git a/src/backend/utils/adt/rowtypes.c b/src/backend/utils/adt/rowtypes.c index d6126d431d9..d94989ad116 100644 --- a/src/backend/utils/adt/rowtypes.c +++ b/src/backend/utils/adt/rowtypes.c @@ -901,11 +901,11 @@ record_cmp(FunctionCallInfo fcinfo) } /* Break down the tuples into fields */ - values1 = (Datum *) palloc(ncolumns1 * sizeof(Datum)); - nulls1 = (bool *) palloc(ncolumns1 * sizeof(bool)); + values1 = palloc_array(Datum, ncolumns1); + nulls1 = palloc_array(bool, ncolumns1); heap_deform_tuple(&tuple1, tupdesc1, values1, nulls1); - values2 = (Datum *) palloc(ncolumns2 * sizeof(Datum)); - nulls2 = (bool *) palloc(ncolumns2 * sizeof(bool)); + values2 = palloc_array(Datum, ncolumns2); + nulls2 = palloc_array(bool, ncolumns2); heap_deform_tuple(&tuple2, tupdesc2, values2, nulls2); /* @@ -1145,11 +1145,11 @@ record_eq(PG_FUNCTION_ARGS) } /* Break down the tuples into fields */ - values1 = (Datum *) palloc(ncolumns1 * sizeof(Datum)); - nulls1 = (bool *) palloc(ncolumns1 * sizeof(bool)); + values1 = palloc_array(Datum, ncolumns1); + nulls1 = palloc_array(bool, ncolumns1); heap_deform_tuple(&tuple1, tupdesc1, values1, nulls1); - values2 = (Datum *) palloc(ncolumns2 * sizeof(Datum)); - nulls2 = (bool *) palloc(ncolumns2 * sizeof(bool)); + values2 = palloc_array(Datum, ncolumns2); + nulls2 = palloc_array(bool, ncolumns2); heap_deform_tuple(&tuple2, tupdesc2, values2, nulls2); /* @@ -1425,11 +1425,11 @@ record_image_cmp(FunctionCallInfo fcinfo) } /* Break down the tuples into fields */ - values1 = (Datum *) palloc(ncolumns1 * sizeof(Datum)); - nulls1 = (bool *) palloc(ncolumns1 * sizeof(bool)); + values1 = palloc_array(Datum, ncolumns1); + nulls1 = palloc_array(bool, ncolumns1); heap_deform_tuple(&tuple1, tupdesc1, values1, nulls1); - values2 = (Datum *) palloc(ncolumns2 * sizeof(Datum)); - nulls2 = (bool *) palloc(ncolumns2 * sizeof(bool)); + values2 = palloc_array(Datum, ncolumns2); + nulls2 = palloc_array(bool, ncolumns2); heap_deform_tuple(&tuple2, tupdesc2, values2, nulls2); /* @@ -1671,11 +1671,11 @@ record_image_eq(PG_FUNCTION_ARGS) } /* Break down the tuples into fields */ - values1 = (Datum *) palloc(ncolumns1 * sizeof(Datum)); - nulls1 = (bool *) palloc(ncolumns1 * sizeof(bool)); + values1 = palloc_array(Datum, ncolumns1); + nulls1 = palloc_array(bool, ncolumns1); heap_deform_tuple(&tuple1, tupdesc1, values1, nulls1); - values2 = (Datum *) palloc(ncolumns2 * sizeof(Datum)); - nulls2 = (bool *) palloc(ncolumns2 * sizeof(bool)); + values2 = palloc_array(Datum, ncolumns2); + nulls2 = palloc_array(bool, ncolumns2); heap_deform_tuple(&tuple2, tupdesc2, values2, nulls2); /* diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c index e95dd1b11eb..6506bf12e3c 100644 --- a/src/backend/utils/adt/ruleutils.c +++ b/src/backend/utils/adt/ruleutils.c @@ -2931,7 +2931,7 @@ pg_get_constraintdef_worker(Oid constraintId, bool fullCommand, deconstruct_array_builtin(DatumGetArrayTypeP(val), OIDOID, &elems, NULL, &nElems); - operators = (Oid *) palloc(nElems * sizeof(Oid)); + operators = palloc_array(Oid, nElems); for (i = 0; i < nElems; i++) operators[i] = DatumGetObjectId(elems[i]); @@ -4132,8 +4132,7 @@ deparse_context_for_plan_tree(PlannedStmt *pstmt, List *rtable_names) int ntables = list_length(dpns->rtable); ListCell *lc; - dpns->appendrels = (AppendRelInfo **) - palloc0((ntables + 1) * sizeof(AppendRelInfo *)); + dpns->appendrels = palloc0_array(AppendRelInfo *, ntables + 1); foreach(lc, pstmt->appendRelations) { AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc); @@ -4413,7 +4412,7 @@ set_deparse_for_query(deparse_namespace *dpns, Query *query, dpns->rtable_columns = NIL; while (list_length(dpns->rtable_columns) < list_length(dpns->rtable)) dpns->rtable_columns = lappend(dpns->rtable_columns, - palloc0(sizeof(deparse_columns))); + palloc0_object(deparse_columns)); /* If it's a utility query, it won't have a jointree */ if (query->jointree) @@ -4469,7 +4468,7 @@ set_simple_column_names(deparse_namespace *dpns) dpns->rtable_columns = NIL; while (list_length(dpns->rtable_columns) < list_length(dpns->rtable)) dpns->rtable_columns = lappend(dpns->rtable_columns, - palloc0(sizeof(deparse_columns))); + palloc0_object(deparse_columns)); /* Assign unique column aliases within each non-join RTE */ forboth(lc, dpns->rtable, lc2, dpns->rtable_columns) @@ -4762,7 +4761,7 @@ set_relation_column_names(deparse_namespace *dpns, RangeTblEntry *rte, tupdesc = RelationGetDescr(rel); ncolumns = tupdesc->natts; - real_colnames = (char **) palloc(ncolumns * sizeof(char *)); + real_colnames = palloc_array(char *, ncolumns); for (i = 0; i < ncolumns; i++) { @@ -4806,7 +4805,7 @@ set_relation_column_names(deparse_namespace *dpns, RangeTblEntry *rte, colnames = rte->eref->colnames; ncolumns = list_length(colnames); - real_colnames = (char **) palloc(ncolumns * sizeof(char *)); + real_colnames = palloc_array(char *, ncolumns); i = 0; foreach(lc, colnames) @@ -4842,8 +4841,8 @@ set_relation_column_names(deparse_namespace *dpns, RangeTblEntry *rte, * colname_is_unique will not consult that array, which is fine because it * would only be duplicate effort. */ - colinfo->new_colnames = (char **) palloc(ncolumns * sizeof(char *)); - colinfo->is_new_col = (bool *) palloc(ncolumns * sizeof(bool)); + colinfo->new_colnames = palloc_array(char *, ncolumns); + colinfo->is_new_col = palloc_array(bool, ncolumns); /* If the RTE is wide enough, use a hash table to avoid O(N^2) costs */ build_colinfo_names_hash(colinfo); @@ -5045,8 +5044,8 @@ set_join_column_names(deparse_namespace *dpns, RangeTblEntry *rte, nnewcolumns = leftcolinfo->num_new_cols + rightcolinfo->num_new_cols - list_length(colinfo->usingNames); colinfo->num_new_cols = nnewcolumns; - colinfo->new_colnames = (char **) palloc0(nnewcolumns * sizeof(char *)); - colinfo->is_new_col = (bool *) palloc0(nnewcolumns * sizeof(bool)); + colinfo->new_colnames = palloc0_array(char *, nnewcolumns); + colinfo->is_new_col = palloc0_array(bool, nnewcolumns); /* * Generating the new_colnames array is a bit tricky since any new columns @@ -5458,8 +5457,8 @@ identify_join_columns(JoinExpr *j, RangeTblEntry *jrte, /* Initialize result arrays with zeroes */ numjoincols = list_length(jrte->joinaliasvars); Assert(numjoincols == list_length(jrte->eref->colnames)); - colinfo->leftattnos = (int *) palloc0(numjoincols * sizeof(int)); - colinfo->rightattnos = (int *) palloc0(numjoincols * sizeof(int)); + colinfo->leftattnos = palloc0_array(int, numjoincols); + colinfo->rightattnos = palloc0_array(int, numjoincols); /* * Deconstruct RTE's joinleftcols/joinrightcols into desired format. diff --git a/src/backend/utils/adt/selfuncs.c b/src/backend/utils/adt/selfuncs.c index 41465769ef1..e27ec9e5c25 100644 --- a/src/backend/utils/adt/selfuncs.c +++ b/src/backend/utils/adt/selfuncs.c @@ -2471,8 +2471,8 @@ eqjoinsel(PG_FUNCTION_ARGS) if (have_mcvs1 && have_mcvs2) { fmgr_info(opfuncoid, &eqproc); - hasmatch1 = (bool *) palloc0(sslot1.nvalues * sizeof(bool)); - hasmatch2 = (bool *) palloc0(sslot2.nvalues * sizeof(bool)); + hasmatch1 = palloc0_array(bool, sslot1.nvalues); + hasmatch2 = palloc0_array(bool, sslot2.nvalues); /* * If the MCV lists are long enough to justify hashing, try to look up diff --git a/src/backend/utils/adt/tsquery_rewrite.c b/src/backend/utils/adt/tsquery_rewrite.c index aace2a4c7d6..ecff1035c3e 100644 --- a/src/backend/utils/adt/tsquery_rewrite.c +++ b/src/backend/utils/adt/tsquery_rewrite.c @@ -92,7 +92,7 @@ findeq(QTNode *node, QTNode *ex, QTNode *subs, bool *isfind) node->valnode->qoperator.oper == OP_OR); /* matched[] will record which children of node matched */ - matched = (bool *) palloc0(node->nchild * sizeof(bool)); + matched = palloc0_array(bool, node->nchild); nmatched = 0; i = j = 0; while (i < node->nchild && j < ex->nchild) diff --git a/src/backend/utils/adt/tsrank.c b/src/backend/utils/adt/tsrank.c index 3012ad437af..bd1c478e370 100644 --- a/src/backend/utils/adt/tsrank.c +++ b/src/backend/utils/adt/tsrank.c @@ -803,7 +803,7 @@ get_docrep(TSVector txt, QueryRepresentation *qr, int *doclen) while (cur + dimt >= len) { len *= 2; - doc = (DocRepresentation *) repalloc(doc, sizeof(DocRepresentation) * len); + doc = repalloc_array(doc, DocRepresentation, len); } /* iterations over entry's positions */ diff --git a/src/backend/utils/adt/tsvector.c b/src/backend/utils/adt/tsvector.c index b99878d0ca2..21d29a7e4f6 100644 --- a/src/backend/utils/adt/tsvector.c +++ b/src/backend/utils/adt/tsvector.c @@ -139,8 +139,7 @@ uniqueentry(WordEntryIN *a, int l, char *buf, int *outbuflen) /* append ptr's positions to res's positions */ int newlen = ptr->poslen + res->poslen; - res->pos = (WordEntryPos *) - repalloc(res->pos, newlen * sizeof(WordEntryPos)); + res->pos = repalloc_array(res->pos, WordEntryPos, newlen); memcpy(&res->pos[res->poslen], ptr->pos, ptr->poslen * sizeof(WordEntryPos)); res->poslen = newlen; @@ -226,8 +225,7 @@ tsvectorin(PG_FUNCTION_ARGS) if (len >= arrlen) { arrlen *= 2; - arr = (WordEntryIN *) - repalloc(arr, sizeof(WordEntryIN) * arrlen); + arr = repalloc_array(arr, WordEntryIN, arrlen); } while ((cur - tmpbuf) + toklen >= buflen) { diff --git a/src/backend/utils/adt/tsvector_op.c b/src/backend/utils/adt/tsvector_op.c index d5336774b22..0bd32a5619f 100644 --- a/src/backend/utils/adt/tsvector_op.c +++ b/src/backend/utils/adt/tsvector_op.c @@ -592,7 +592,7 @@ tsvector_delete_arr(PG_FUNCTION_ARGS) * here we optimize things for that scenario: iterate through lexarr * performing binary search of each lexeme from lexarr in tsvector. */ - skip_indices = palloc0(nlex * sizeof(int)); + skip_indices = palloc0_array(int, nlex); for (i = skip_count = 0; i < nlex; i++) { char *lex; @@ -685,8 +685,8 @@ tsvector_unnest(PG_FUNCTION_ARGS) * that in two separate arrays. */ posv = _POSVECPTR(tsin, arrin + i); - positions = palloc(posv->npos * sizeof(Datum)); - weights = palloc(posv->npos * sizeof(Datum)); + positions = palloc_array(Datum, posv->npos); + weights = palloc_array(Datum, posv->npos); for (j = 0; j < posv->npos; j++) { positions[j] = Int16GetDatum(WEP_GETPOS(posv->pos[j])); @@ -1542,8 +1542,7 @@ TS_phrase_output(ExecPhraseData *data, /* Store position, first allocating output array if needed */ if (data->pos == NULL) { - data->pos = (WordEntryPos *) - palloc(max_npos * sizeof(WordEntryPos)); + data->pos = palloc_array(WordEntryPos, max_npos); data->allocated = true; } data->pos[data->npos++] = output_pos; diff --git a/src/backend/utils/adt/xml.c b/src/backend/utils/adt/xml.c index 0953ad2becb..1f75ffcfd9d 100644 --- a/src/backend/utils/adt/xml.c +++ b/src/backend/utils/adt/xml.c @@ -1419,7 +1419,7 @@ xml_pnstrdup(const xmlChar *str, size_t len) { xmlChar *result; - result = (xmlChar *) palloc((len + 1) * sizeof(xmlChar)); + result = palloc_array(xmlChar, len + 1); memcpy(result, str, len * sizeof(xmlChar)); result[len] = 0; return result; @@ -1431,7 +1431,7 @@ pg_xmlCharStrndup(const char *str, size_t len) { xmlChar *result; - result = (xmlChar *) palloc((len + 1) * sizeof(xmlChar)); + result = palloc_array(xmlChar, len + 1); memcpy(result, str, len); result[len] = '\0'; diff --git a/src/backend/utils/cache/catcache.c b/src/backend/utils/cache/catcache.c index 0c8955fc61a..511270edfda 100644 --- a/src/backend/utils/cache/catcache.c +++ b/src/backend/utils/cache/catcache.c @@ -947,7 +947,7 @@ InitCatCache(int id, */ cp = (CatCache *) palloc_aligned(sizeof(CatCache), PG_CACHE_LINE_SIZE, MCXT_ALLOC_ZERO); - cp->cc_bucket = palloc0(nbuckets * sizeof(dlist_head)); + cp->cc_bucket = palloc0_array(dlist_head, nbuckets); /* * Many catcaches never receive any list searches. Therefore, we don't diff --git a/src/backend/utils/cache/inval.c b/src/backend/utils/cache/inval.c index 10c6820a3c1..a46b0ae70e2 100644 --- a/src/backend/utils/cache/inval.c +++ b/src/backend/utils/cache/inval.c @@ -341,9 +341,7 @@ AddInvalidationMessage(InvalidationMsgsGroup *group, int subgroup, /* Enlarge storage array */ int reqsize = 2 * ima->maxmsgs; - ima->msgs = (SharedInvalidationMessage *) - repalloc(ima->msgs, - reqsize * sizeof(SharedInvalidationMessage)); + ima->msgs = repalloc_array(ima->msgs, SharedInvalidationMessage, reqsize); ima->maxmsgs = reqsize; } } @@ -1102,8 +1100,7 @@ inplaceGetInvalidationMessages(SharedInvalidationMessage **msgs, *RelcacheInitFileInval = inplaceInvalInfo->RelcacheInitFileInval; nummsgs = NumMessagesInGroup(&inplaceInvalInfo->CurrentCmdInvalidMsgs); - *msgs = msgarray = (SharedInvalidationMessage *) - palloc(nummsgs * sizeof(SharedInvalidationMessage)); + *msgs = msgarray = palloc_array(SharedInvalidationMessage, nummsgs); nmsgs = 0; ProcessMessageSubGroupMulti(&inplaceInvalInfo->CurrentCmdInvalidMsgs, diff --git a/src/backend/utils/cache/lsyscache.c b/src/backend/utils/cache/lsyscache.c index cc6f05a0aa7..9ef3922d17c 100644 --- a/src/backend/utils/cache/lsyscache.c +++ b/src/backend/utils/cache/lsyscache.c @@ -2022,7 +2022,7 @@ get_func_signature(Oid funcid, Oid **argtypes, int *nargs) result = procstruct->prorettype; *nargs = (int) procstruct->pronargs; Assert(*nargs == procstruct->proargtypes.dim1); - *argtypes = (Oid *) palloc(*nargs * sizeof(Oid)); + *argtypes = palloc_array(Oid, *nargs); memcpy(*argtypes, procstruct->proargtypes.values, *nargs * sizeof(Oid)); ReleaseSysCache(tp); diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c index 9abbaeab4a9..f475d703977 100644 --- a/src/backend/utils/cache/relcache.c +++ b/src/backend/utils/cache/relcache.c @@ -881,8 +881,7 @@ RelationBuildRuleLock(Relation relation) if (numlocks >= maxlocks) { maxlocks *= 2; - rules = (RewriteRule **) - repalloc(rules, sizeof(RewriteRule *) * maxlocks); + rules = repalloc_array(rules, RewriteRule *, maxlocks); } rules[numlocks++] = rule; } @@ -1098,8 +1097,7 @@ RelationBuildDesc(Oid targetRelId, bool insertIt) int allocsize; allocsize = in_progress_list_maxlen * 2; - in_progress_list = repalloc(in_progress_list, - allocsize * sizeof(*in_progress_list)); + in_progress_list = repalloc_array(in_progress_list, InProgressEnt, allocsize); in_progress_list_maxlen = allocsize; } in_progress_offset = in_progress_list_len++; @@ -3113,7 +3111,7 @@ RememberToFreeTupleDescAtEOX(TupleDesc td) oldcxt = MemoryContextSwitchTo(CacheMemoryContext); - EOXactTupleDescArray = (TupleDesc *) palloc(16 * sizeof(TupleDesc)); + EOXactTupleDescArray = palloc_array(TupleDesc, 16); EOXactTupleDescArrayLen = 16; NextEOXactTupleDescNum = 0; MemoryContextSwitchTo(oldcxt); @@ -3124,8 +3122,7 @@ RememberToFreeTupleDescAtEOX(TupleDesc td) Assert(EOXactTupleDescArrayLen > 0); - EOXactTupleDescArray = (TupleDesc *) repalloc(EOXactTupleDescArray, - newlen * sizeof(TupleDesc)); + EOXactTupleDescArray = repalloc_array(EOXactTupleDescArray, TupleDesc, newlen); EOXactTupleDescArrayLen = newlen; } @@ -3175,7 +3172,7 @@ AssertPendingSyncs_RelationCache(void) */ PushActiveSnapshot(GetTransactionSnapshot()); maxrels = 1; - rels = palloc(maxrels * sizeof(*rels)); + rels = palloc_array(Relation, maxrels); nrels = 0; hash_seq_init(&status, GetLockMethodLocalHash()); while ((locallock = (LOCALLOCK *) hash_seq_search(&status)) != NULL) @@ -3195,7 +3192,7 @@ AssertPendingSyncs_RelationCache(void) if (nrels >= maxrels) { maxrels *= 2; - rels = repalloc(rels, maxrels * sizeof(*rels)); + rels = repalloc_array(rels, Relation, maxrels); } rels[nrels++] = r; } @@ -6229,7 +6226,7 @@ load_relcache_init_file(bool shared) * helps to guard against broken init files. */ max_rels = 100; - rels = (Relation *) palloc(max_rels * sizeof(Relation)); + rels = palloc_array(Relation, max_rels); num_rels = 0; nailed_rels = nailed_indexes = 0; @@ -6264,7 +6261,7 @@ load_relcache_init_file(bool shared) if (num_rels >= max_rels) { max_rels *= 2; - rels = (Relation *) repalloc(rels, max_rels * sizeof(Relation)); + rels = repalloc_array(rels, Relation, max_rels); } rel = rels[num_rels++] = (Relation) palloc(len); diff --git a/src/backend/utils/cache/typcache.c b/src/backend/utils/cache/typcache.c index 00133ba92ef..eca2d73231a 100644 --- a/src/backend/utils/cache/typcache.c +++ b/src/backend/utils/cache/typcache.c @@ -455,8 +455,7 @@ lookup_type_cache(Oid type_id, int flags) int allocsize; allocsize = in_progress_list_maxlen * 2; - in_progress_list = repalloc(in_progress_list, - allocsize * sizeof(*in_progress_list)); + in_progress_list = repalloc_array(in_progress_list, Oid, allocsize); in_progress_list_maxlen = allocsize; } @@ -1236,14 +1235,12 @@ load_domaintype_info(TypeCacheEntry *typentry) if (ccons == NULL) { cconslen = 8; - ccons = (DomainConstraintState **) - palloc(cconslen * sizeof(DomainConstraintState *)); + ccons = palloc_array(DomainConstraintState *, cconslen); } else if (nccons >= cconslen) { cconslen *= 2; - ccons = (DomainConstraintState **) - repalloc(ccons, cconslen * sizeof(DomainConstraintState *)); + ccons = repalloc_array(ccons, DomainConstraintState *, cconslen); } ccons[nccons++] = r; } @@ -2828,7 +2825,7 @@ load_enum_cache_data(TypeCacheEntry *tcache) if (numitems >= maxitems) { maxitems *= 2; - items = (EnumItem *) repalloc(items, sizeof(EnumItem) * maxitems); + items = repalloc_array(items, EnumItem, maxitems); } items[numitems].enum_oid = en->oid; items[numitems].sort_order = en->enumsortorder; diff --git a/src/backend/utils/misc/conffiles.c b/src/backend/utils/misc/conffiles.c index 3148aa2cc19..c77ff4d38d4 100644 --- a/src/backend/utils/misc/conffiles.c +++ b/src/backend/utils/misc/conffiles.c @@ -144,8 +144,7 @@ GetConfFilesInDir(const char *includedir, const char *calling_file, if (*num_filenames >= size_filenames) { size_filenames += 32; - filenames = (char **) repalloc(filenames, - size_filenames * sizeof(char *)); + filenames = repalloc_array(filenames, char *, size_filenames); } filenames[*num_filenames] = pstrdup(filename); (*num_filenames)++; diff --git a/src/backend/utils/misc/tzparser.c b/src/backend/utils/misc/tzparser.c index 8129cf44c4f..ace982cf8d7 100644 --- a/src/backend/utils/misc/tzparser.c +++ b/src/backend/utils/misc/tzparser.c @@ -250,7 +250,7 @@ addToArray(tzEntry **base, int *arraysize, int n, if (n >= *arraysize) { *arraysize *= 2; - *base = (tzEntry *) repalloc(*base, *arraysize * sizeof(tzEntry)); + *base = repalloc_array(*base, tzEntry, *arraysize); } arrayptr = *base + low; diff --git a/src/backend/utils/sort/logtape.c b/src/backend/utils/sort/logtape.c index ebe2861cf57..8e3edcdf1ab 100644 --- a/src/backend/utils/sort/logtape.c +++ b/src/backend/utils/sort/logtape.c @@ -445,8 +445,7 @@ ltsGetPreallocBlock(LogicalTapeSet *lts, LogicalTape *lt) lt->prealloc_size *= 2; if (lt->prealloc_size > TAPE_WRITE_PREALLOC_MAX) lt->prealloc_size = TAPE_WRITE_PREALLOC_MAX; - lt->prealloc = (int64 *) repalloc(lt->prealloc, - sizeof(int64) * lt->prealloc_size); + lt->prealloc = repalloc_array(lt->prealloc, int64, lt->prealloc_size); } /* refill preallocation list */ @@ -490,8 +489,7 @@ ltsReleaseBlock(LogicalTapeSet *lts, int64 blocknum) return; lts->freeBlocksLen *= 2; - lts->freeBlocks = (int64 *) repalloc(lts->freeBlocks, - lts->freeBlocksLen * sizeof(int64)); + lts->freeBlocks = repalloc_array(lts->freeBlocks, int64, lts->freeBlocksLen); } /* create a "hole" at end of minheap array */ @@ -566,7 +564,7 @@ LogicalTapeSetCreate(bool preallocate, SharedFileSet *fileset, int worker) lts->nHoleBlocks = 0L; lts->forgetFreeSpace = false; lts->freeBlocksLen = 32; /* reasonable initial guess */ - lts->freeBlocks = (int64 *) palloc(lts->freeBlocksLen * sizeof(int64)); + lts->freeBlocks = palloc_array(int64, lts->freeBlocksLen); lts->nFreeBlocks = 0; lts->enable_prealloc = preallocate; diff --git a/src/backend/utils/sort/tuplesort.c b/src/backend/utils/sort/tuplesort.c index 063cfe8a9f1..f67651483f8 100644 --- a/src/backend/utils/sort/tuplesort.c +++ b/src/backend/utils/sort/tuplesort.c @@ -699,7 +699,7 @@ tuplesort_begin_batch(Tuplesortstate *state) } if (state->memtuples == NULL) { - state->memtuples = (SortTuple *) palloc(state->memtupsize * sizeof(SortTuple)); + state->memtuples = palloc_array(SortTuple, state->memtupsize); USEMEM(state, GetMemoryChunkSpace(state->memtuples)); } @@ -1795,7 +1795,7 @@ inittapes(Tuplesortstate *state, bool mergeruns) state->nInputTapes = 0; state->nInputRuns = 0; - state->outputTapes = palloc0(state->maxTapes * sizeof(LogicalTape *)); + state->outputTapes = palloc0_array(LogicalTape *, state->maxTapes); state->nOutputTapes = 0; state->nOutputRuns = 0; @@ -2020,7 +2020,7 @@ mergeruns(Tuplesortstate *state) * created as needed, here we only allocate the array to hold * them. */ - state->outputTapes = palloc0(state->nInputTapes * sizeof(LogicalTape *)); + state->outputTapes = palloc0_array(LogicalTape *, state->nInputTapes); state->nOutputTapes = 0; state->nOutputRuns = 0; @@ -3422,7 +3422,7 @@ leader_takeover_tapes(Tuplesortstate *state) state->nInputTapes = 0; state->nInputRuns = 0; - state->outputTapes = palloc0(nParticipants * sizeof(LogicalTape *)); + state->outputTapes = palloc0_array(LogicalTape *, nParticipants); state->nOutputTapes = nParticipants; state->nOutputRuns = nParticipants; diff --git a/src/backend/utils/sort/tuplesortvariants.c b/src/backend/utils/sort/tuplesortvariants.c index 2509ac3e3a4..95b9ff9d39a 100644 --- a/src/backend/utils/sort/tuplesortvariants.c +++ b/src/backend/utils/sort/tuplesortvariants.c @@ -217,7 +217,7 @@ tuplesort_begin_heap(TupleDesc tupDesc, base->arg = tupDesc; /* assume we need not copy tupDesc */ /* Prepare SortSupport data for each column */ - base->sortKeys = (SortSupport) palloc0(nkeys * sizeof(SortSupportData)); + base->sortKeys = (SortSupport) palloc0_array(SortSupportData, nkeys); for (i = 0; i < nkeys; i++) { @@ -325,8 +325,7 @@ tuplesort_begin_cluster(TupleDesc tupDesc, } /* Prepare SortSupport data for each column */ - base->sortKeys = (SortSupport) palloc0(base->nKeys * - sizeof(SortSupportData)); + base->sortKeys = (SortSupport) palloc0_array(SortSupportData, base->nKeys); for (i = 0; i < base->nKeys; i++) { @@ -407,8 +406,7 @@ tuplesort_begin_index_btree(Relation heapRel, indexScanKey = _bt_mkscankey(indexRel, NULL); /* Prepare SortSupport data for each column */ - base->sortKeys = (SortSupport) palloc0(base->nKeys * - sizeof(SortSupportData)); + base->sortKeys = (SortSupport) palloc0_array(SortSupportData, base->nKeys); for (i = 0; i < base->nKeys; i++) { @@ -527,8 +525,7 @@ tuplesort_begin_index_gist(Relation heapRel, arg->uniqueNullsNotDistinct = false; /* Prepare SortSupport data for each column */ - base->sortKeys = (SortSupport) palloc0(base->nKeys * - sizeof(SortSupportData)); + base->sortKeys = (SortSupport) palloc0_array(SortSupportData, base->nKeys); for (i = 0; i < base->nKeys; i++) { @@ -610,8 +607,7 @@ tuplesort_begin_index_gin(Relation heapRel, base->nKeys = IndexRelationGetNumberOfKeyAttributes(indexRel); /* Prepare SortSupport data for each column */ - base->sortKeys = (SortSupport) palloc0(base->nKeys * - sizeof(SortSupportData)); + base->sortKeys = (SortSupport) palloc0_array(SortSupportData, base->nKeys); for (i = 0; i < base->nKeys; i++) { diff --git a/src/backend/utils/sort/tuplestore.c b/src/backend/utils/sort/tuplestore.c index f9e2d95186a..35e438ceaa6 100644 --- a/src/backend/utils/sort/tuplestore.c +++ b/src/backend/utils/sort/tuplestore.c @@ -291,15 +291,14 @@ tuplestore_begin_common(int eflags, bool interXact, int maxKBytes) ALLOCSET_SEPARATE_THRESHOLD / sizeof(void *) + 1); state->growmemtuples = true; - state->memtuples = (void **) palloc(state->memtupsize * sizeof(void *)); + state->memtuples = palloc_array(void *, state->memtupsize); USEMEM(state, GetMemoryChunkSpace(state->memtuples)); state->activeptr = 0; state->readptrcount = 1; state->readptrsize = 8; /* arbitrary */ - state->readptrs = (TSReadPointer *) - palloc(state->readptrsize * sizeof(TSReadPointer)); + state->readptrs = palloc_array(TSReadPointer, state->readptrsize); state->readptrs[0].eflags = eflags; state->readptrs[0].eof_reached = false; @@ -407,8 +406,7 @@ tuplestore_alloc_read_pointer(Tuplestorestate *state, int eflags) { int newcnt = state->readptrsize * 2; - state->readptrs = (TSReadPointer *) - repalloc(state->readptrs, newcnt * sizeof(TSReadPointer)); + state->readptrs = repalloc_array(state->readptrs, TSReadPointer, newcnt); state->readptrsize = newcnt; } diff --git a/src/backend/utils/time/combocid.c b/src/backend/utils/time/combocid.c index 614b7c1006b..5113cf809ba 100644 --- a/src/backend/utils/time/combocid.c +++ b/src/backend/utils/time/combocid.c @@ -242,8 +242,7 @@ GetComboCommandId(CommandId cmin, CommandId cmax) { int newsize = sizeComboCids * 2; - comboCids = (ComboCidKeyData *) - repalloc(comboCids, sizeof(ComboCidKeyData) * newsize); + comboCids = repalloc_array(comboCids, ComboCidKeyData, newsize); sizeComboCids = newsize; } diff --git a/src/backend/utils/time/snapmgr.c b/src/backend/utils/time/snapmgr.c index bc98a4361bf..70aed370aa0 100644 --- a/src/backend/utils/time/snapmgr.c +++ b/src/backend/utils/time/snapmgr.c @@ -1488,7 +1488,7 @@ ImportSnapshot(const char *idstr) (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), errmsg("invalid snapshot data in file \"%s\"", path))); - snapshot.xip = (TransactionId *) palloc(xcnt * sizeof(TransactionId)); + snapshot.xip = palloc_array(TransactionId, xcnt); for (i = 0; i < xcnt; i++) snapshot.xip[i] = parseXidFromText("xip:", &filebuf, path); @@ -1504,7 +1504,7 @@ ImportSnapshot(const char *idstr) (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), errmsg("invalid snapshot data in file \"%s\"", path))); - snapshot.subxip = (TransactionId *) palloc(xcnt * sizeof(TransactionId)); + snapshot.subxip = palloc_array(TransactionId, xcnt); for (i = 0; i < xcnt; i++) snapshot.subxip[i] = parseXidFromText("sxp:", &filebuf, path); } diff --git a/src/common/blkreftable.c b/src/common/blkreftable.c index 63e068a8f18..3dce09beb70 100644 --- a/src/common/blkreftable.c +++ b/src/common/blkreftable.c @@ -1039,16 +1039,13 @@ BlockRefTableEntryMarkBlockModified(BlockRefTableEntry *entry, } else { - entry->chunk_size = repalloc(entry->chunk_size, - sizeof(uint16) * max_chunks); + entry->chunk_size = repalloc_array(entry->chunk_size, uint16, max_chunks); memset(&entry->chunk_size[entry->nchunks], 0, extra_chunks * sizeof(uint16)); - entry->chunk_usage = repalloc(entry->chunk_usage, - sizeof(uint16) * max_chunks); + entry->chunk_usage = repalloc_array(entry->chunk_usage, uint16, max_chunks); memset(&entry->chunk_usage[entry->nchunks], 0, extra_chunks * sizeof(uint16)); - entry->chunk_data = repalloc(entry->chunk_data, - sizeof(BlockRefTableChunk) * max_chunks); + entry->chunk_data = repalloc_array(entry->chunk_data, BlockRefTableChunk, max_chunks); memset(&entry->chunk_data[entry->nchunks], 0, extra_chunks * sizeof(BlockRefTableChunk)); } @@ -1105,7 +1102,7 @@ BlockRefTableEntryMarkBlockModified(BlockRefTableEntry *entry, unsigned j; /* Allocate a new chunk. */ - newchunk = palloc0(MAX_ENTRIES_PER_CHUNK * sizeof(uint16)); + newchunk = palloc0_array(uint16, MAX_ENTRIES_PER_CHUNK); /* Set the bit for each existing entry. */ for (j = 0; j < entry->chunk_usage[chunkno]; ++j) @@ -1138,8 +1135,7 @@ BlockRefTableEntryMarkBlockModified(BlockRefTableEntry *entry, unsigned newsize = entry->chunk_size[chunkno] * 2; Assert(newsize <= MAX_ENTRIES_PER_CHUNK); - entry->chunk_data[chunkno] = repalloc(entry->chunk_data[chunkno], - newsize * sizeof(uint16)); + entry->chunk_data[chunkno] = repalloc_array(entry->chunk_data[chunkno], uint16, newsize); entry->chunk_size[chunkno] = newsize; } diff --git a/src/common/rmtree.c b/src/common/rmtree.c index e35b5e7ba73..86560417123 100644 --- a/src/common/rmtree.c +++ b/src/common/rmtree.c @@ -85,8 +85,7 @@ rmtree(const char *path, bool rmtopdir) */ if (dirnames_size == dirnames_capacity) { - dirnames = repalloc(dirnames, - sizeof(char *) * dirnames_capacity * 2); + dirnames = repalloc_array(dirnames, char *, dirnames_capacity * 2); dirnames_capacity *= 2; } dirnames[dirnames_size++] = pstrdup(pathbuf); diff --git a/src/include/lib/simplehash.h b/src/include/lib/simplehash.h index 15af488abfb..98572f12162 100644 --- a/src/include/lib/simplehash.h +++ b/src/include/lib/simplehash.h @@ -1127,7 +1127,7 @@ SH_STAT(SH_TYPE * tb) double fillfactor; uint32 i; - uint32 *collisions = (uint32 *) palloc0(tb->size * sizeof(uint32)); + uint32 *collisions = palloc0_array(uint32, tb->size); uint32 total_collisions = 0; uint32 max_collisions = 0; double avg_collisions; diff --git a/src/pl/plpgsql/src/pl_comp.c b/src/pl/plpgsql/src/pl_comp.c index b72c963b3be..75184b75707 100644 --- a/src/pl/plpgsql/src/pl_comp.c +++ b/src/pl/plpgsql/src/pl_comp.c @@ -2242,7 +2242,7 @@ plpgsql_adddatum(PLpgSQL_datum *newdatum) if (plpgsql_nDatums == datums_alloc) { datums_alloc *= 2; - plpgsql_Datums = repalloc(plpgsql_Datums, sizeof(PLpgSQL_datum *) * datums_alloc); + plpgsql_Datums = repalloc_array(plpgsql_Datums, PLpgSQL_datum *, datums_alloc); } newdatum->dno = plpgsql_nDatums; diff --git a/src/pl/plpgsql/src/pl_gram.y b/src/pl/plpgsql/src/pl_gram.y index 5009e59a78f..5e14a2d7302 100644 --- a/src/pl/plpgsql/src/pl_gram.y +++ b/src/pl/plpgsql/src/pl_gram.y @@ -3955,7 +3955,7 @@ read_cursor_args(PLpgSQL_var *cursor, int until, YYSTYPE *yylvalp, YYLTYPE *yyll * Read the arguments, one by one. */ row = (PLpgSQL_row *) plpgsql_Datums[cursor->cursor_explicit_argrow]; - argv = (char **) palloc0_array(char *, row->nfields); + argv = palloc0_array(char *, row->nfields); for (argc = 0; argc < row->nfields; argc++) { diff --git a/src/pl/plpython/plpy_cursorobject.c b/src/pl/plpython/plpy_cursorobject.c index 0725fbc19f2..054dc97db1b 100644 --- a/src/pl/plpython/plpy_cursorobject.c +++ b/src/pl/plpython/plpy_cursorobject.c @@ -243,8 +243,8 @@ PLy_cursor_plan(PyObject *ob, PyObject *args) if (nargs > 0) { - values = (Datum *) palloc(nargs * sizeof(Datum)); - nulls = (char *) palloc(nargs * sizeof(char)); + values = palloc_array(Datum, nargs); + nulls = palloc_array(char, nargs); } else { diff --git a/src/pl/plpython/plpy_exec.c b/src/pl/plpython/plpy_exec.c index de7f64113d6..14e63625070 100644 --- a/src/pl/plpython/plpy_exec.c +++ b/src/pl/plpython/plpy_exec.c @@ -1051,9 +1051,9 @@ PLy_modify_tuple(PLyProcedure *proc, PyObject *pltd, TriggerData *tdata, tupdesc = RelationGetDescr(tdata->tg_relation); - modvalues = (Datum *) palloc0(tupdesc->natts * sizeof(Datum)); - modnulls = (bool *) palloc0(tupdesc->natts * sizeof(bool)); - modrepls = (bool *) palloc0(tupdesc->natts * sizeof(bool)); + modvalues = palloc0_array(Datum, tupdesc->natts); + modnulls = palloc0_array(bool, tupdesc->natts); + modrepls = palloc0_array(bool, tupdesc->natts); for (i = 0; i < nkeys; i++) { diff --git a/src/pl/plpython/plpy_procedure.c b/src/pl/plpython/plpy_procedure.c index 688ebbbf6e2..acfc0d8f0f0 100644 --- a/src/pl/plpython/plpy_procedure.c +++ b/src/pl/plpython/plpy_procedure.c @@ -291,8 +291,8 @@ PLy_procedure_create(PLyProcedure *proc, } /* Allocate arrays for per-input-argument data */ - proc->argnames = (char **) palloc0_array(char *, proc->nargs); - proc->args = (PLyDatumToOb *) palloc0_array(PLyDatumToOb, proc->nargs); + proc->argnames = palloc0_array(char *, proc->nargs); + proc->args = palloc0_array(PLyDatumToOb, proc->nargs); for (i = pos = 0; i < total; i++) { diff --git a/src/pl/plpython/plpy_spi.c b/src/pl/plpython/plpy_spi.c index 4980873efcf..419e0a9b9ae 100644 --- a/src/pl/plpython/plpy_spi.c +++ b/src/pl/plpython/plpy_spi.c @@ -240,8 +240,8 @@ PLy_spi_execute_plan(PyObject *ob, PyObject *list, long limit) if (nargs > 0) { - values = (Datum *) palloc(nargs * sizeof(Datum)); - nulls = (char *) palloc(nargs * sizeof(char)); + values = palloc_array(Datum, nargs); + nulls = palloc_array(char, nargs); } else { diff --git a/src/test/modules/plsample/plsample.c b/src/test/modules/plsample/plsample.c index f294f5ca4ad..4c0b7d8ad66 100644 --- a/src/test/modules/plsample/plsample.c +++ b/src/test/modules/plsample/plsample.c @@ -142,7 +142,7 @@ plsample_func_handler(PG_FUNCTION_ARGS) "PL/Sample function", ALLOCSET_SMALL_SIZES); - arg_out_func = (FmgrInfo *) palloc0(fcinfo->nargs * sizeof(FmgrInfo)); + arg_out_func = palloc0_array(FmgrInfo, fcinfo->nargs); numargs = get_func_arg_info(pl_tuple, &argtypes, &argnames, &argmodes); /* diff --git a/src/test/modules/test_aio/test_aio.c b/src/test/modules/test_aio/test_aio.c index 6270775af7c..39d857557cf 100644 --- a/src/test/modules/test_aio/test_aio.c +++ b/src/test/modules/test_aio/test_aio.c @@ -715,11 +715,11 @@ read_buffers(PG_FUNCTION_ARGS) InitMaterializedSRF(fcinfo, 0); /* at worst each block gets its own IO */ - operations = palloc0(sizeof(ReadBuffersOperation) * nblocks); - buffers = palloc0(sizeof(Buffer) * nblocks); - buffers_datum = palloc0(sizeof(Datum) * nblocks); - io_reqds = palloc0(sizeof(bool) * nblocks); - nblocks_per_io = palloc0(sizeof(int) * nblocks); + operations = palloc0_array(ReadBuffersOperation, nblocks); + buffers = palloc0_array(Buffer, nblocks); + buffers_datum = palloc0_array(Datum, nblocks); + io_reqds = palloc0_array(bool, nblocks); + nblocks_per_io = palloc0_array(int, nblocks); rel = relation_open(relid, AccessShareLock); smgr = RelationGetSmgr(rel); diff --git a/src/test/modules/test_binaryheap/test_binaryheap.c b/src/test/modules/test_binaryheap/test_binaryheap.c index 8ae0f46a932..99f846bcf93 100644 --- a/src/test/modules/test_binaryheap/test_binaryheap.c +++ b/src/test/modules/test_binaryheap/test_binaryheap.c @@ -49,7 +49,7 @@ get_max_from_heap(binaryheap *heap) static int * get_permutation(int size) { - int *permutation = (int *) palloc(size * sizeof(int)); + int *permutation = palloc_array(int, size); permutation[0] = 0; diff --git a/src/test/modules/test_integerset/test_integerset.c b/src/test/modules/test_integerset/test_integerset.c index f24ee886eb0..dfbc90e5d05 100644 --- a/src/test/modules/test_integerset/test_integerset.c +++ b/src/test/modules/test_integerset/test_integerset.c @@ -147,7 +147,7 @@ test_pattern(const test_spec *spec) /* Pre-process the pattern, creating an array of integers from it. */ patternlen = strlen(spec->pattern_str); - pattern_values = palloc(patternlen * sizeof(uint64)); + pattern_values = palloc_array(uint64, patternlen); pattern_num_values = 0; for (int i = 0; i < patternlen; i++) { diff --git a/src/test/modules/test_radixtree/test_radixtree.c b/src/test/modules/test_radixtree/test_radixtree.c index da2a47d3aad..6ffd24cd0df 100644 --- a/src/test/modules/test_radixtree/test_radixtree.c +++ b/src/test/modules/test_radixtree/test_radixtree.c @@ -319,7 +319,7 @@ test_random(void) /* add some random values */ pg_prng_seed(&state, seed); - keys = (TestValueType *) palloc(sizeof(uint64) * num_keys); + keys = palloc_array(TestValueType, num_keys); for (int i = 0; i < num_keys; i++) { uint64 key = pg_prng_uint64(&state) & filter; diff --git a/src/test/modules/test_rbtree/test_rbtree.c b/src/test/modules/test_rbtree/test_rbtree.c index 39c199c6760..20a07900152 100644 --- a/src/test/modules/test_rbtree/test_rbtree.c +++ b/src/test/modules/test_rbtree/test_rbtree.c @@ -63,7 +63,7 @@ irbt_combine(RBTNode *existing, const RBTNode *newdata, void *arg) static RBTNode * irbt_alloc(void *arg) { - return (RBTNode *) palloc(sizeof(IntRBTreeNode)); + return (RBTNode *) palloc_object(IntRBTreeNode); } /* Node freer */ @@ -96,7 +96,7 @@ GetPermutation(int size) int *permutation; int i; - permutation = (int *) palloc(size * sizeof(int)); + permutation = palloc_array(int, size); permutation[0] = 0; @@ -417,8 +417,8 @@ testdelete(int size, int delsize) rbt_populate(tree, size, 1); /* Choose unique ids to delete */ - deleteIds = (int *) palloc(delsize * sizeof(int)); - chosen = (bool *) palloc0(size * sizeof(bool)); + deleteIds = palloc_array(int, delsize); + chosen = palloc0_array(bool, size); for (i = 0; i < delsize; i++) { diff --git a/src/test/modules/test_regex/test_regex.c b/src/test/modules/test_regex/test_regex.c index cfe569aa060..561f79c9460 100644 --- a/src/test/modules/test_regex/test_regex.c +++ b/src/test/modules/test_regex/test_regex.c @@ -167,7 +167,7 @@ test_re_compile(text *text_re, int cflags, Oid collation, char errMsg[100]; /* Convert pattern string to wide characters */ - pattern = (pg_wchar *) palloc((text_re_len + 1) * sizeof(pg_wchar)); + pattern = palloc_array(pg_wchar, text_re_len + 1); pattern_len = pg_mb2wchar_with_len(text_re_val, pattern, text_re_len); @@ -503,8 +503,7 @@ setup_test_matches(text *orig_str, ereport(ERROR, (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED), errmsg("too many regular expression matches"))); - matchctx->match_locs = (int *) repalloc(matchctx->match_locs, - sizeof(int) * array_len); + matchctx->match_locs = repalloc_array(matchctx->match_locs, int, array_len); } /* save this match's locations */ @@ -552,8 +551,7 @@ setup_test_matches(text *orig_str, ereport(ERROR, (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED), errmsg("too many regular expression matches"))); - matchctx->match_locs = (int *) repalloc(matchctx->match_locs, - sizeof(int) * array_len); + matchctx->match_locs = repalloc_array(matchctx->match_locs, int, array_len); } matchctx->match_locs[array_idx++] = matchctx->details.rm_extend.rm_so; diff --git a/src/test/modules/test_resowner/test_resowner_basic.c b/src/test/modules/test_resowner/test_resowner_basic.c index c05f5ca11f3..c0891f7e539 100644 --- a/src/test/modules/test_resowner/test_resowner_basic.c +++ b/src/test/modules/test_resowner/test_resowner_basic.c @@ -64,7 +64,7 @@ test_resowner_priorities(PG_FUNCTION_ARGS) parent = ResourceOwnerCreate(CurrentResourceOwner, "test parent"); child = ResourceOwnerCreate(parent, "test child"); - before_desc = palloc(nkinds * sizeof(ResourceOwnerDesc)); + before_desc = palloc_array(ResourceOwnerDesc, nkinds); for (int i = 0; i < nkinds; i++) { before_desc[i].name = psprintf("test resource before locks %d", i); @@ -73,7 +73,7 @@ test_resowner_priorities(PG_FUNCTION_ARGS) before_desc[i].ReleaseResource = ReleaseString; before_desc[i].DebugPrint = PrintString; } - after_desc = palloc(nkinds * sizeof(ResourceOwnerDesc)); + after_desc = palloc_array(ResourceOwnerDesc, nkinds); for (int i = 0; i < nkinds; i++) { after_desc[i].name = psprintf("test resource after locks %d", i); diff --git a/src/test/modules/test_resowner/test_resowner_many.c b/src/test/modules/test_resowner/test_resowner_many.c index 4962b371bdc..4bb34ca7e4c 100644 --- a/src/test/modules/test_resowner/test_resowner_many.c +++ b/src/test/modules/test_resowner/test_resowner_many.c @@ -226,7 +226,7 @@ test_resowner_many(PG_FUNCTION_ARGS) elog(ERROR, "nforget_al must between 0 and 'nremember_al'"); /* Initialize all the different resource kinds to use */ - before_kinds = palloc(nkinds * sizeof(ManyTestResourceKind)); + before_kinds = palloc_array(ManyTestResourceKind, nkinds); for (int i = 0; i < nkinds; i++) { InitManyTestResourceKind(&before_kinds[i], @@ -234,7 +234,7 @@ test_resowner_many(PG_FUNCTION_ARGS) RESOURCE_RELEASE_BEFORE_LOCKS, RELEASE_PRIO_FIRST + i); } - after_kinds = palloc(nkinds * sizeof(ManyTestResourceKind)); + after_kinds = palloc_array(ManyTestResourceKind, nkinds); for (int i = 0; i < nkinds; i++) { InitManyTestResourceKind(&after_kinds[i], diff --git a/src/test/modules/test_saslprep/test_saslprep.c b/src/test/modules/test_saslprep/test_saslprep.c index 121212d4fa2..c1b7a07786c 100644 --- a/src/test/modules/test_saslprep/test_saslprep.c +++ b/src/test/modules/test_saslprep/test_saslprep.c @@ -168,7 +168,7 @@ test_saslprep_ranges(PG_FUNCTION_ARGS) funcctx->tuple_desc = tupdesc; /* Allocate context with range setup */ - ctx = (pg_saslprep_test_context *) palloc(sizeof(pg_saslprep_test_context)); + ctx = palloc_object(pg_saslprep_test_context); ctx->current_range = 0; ctx->current_codepoint = pg_utf8_test_ranges[0].start_codepoint; funcctx->user_fctx = ctx; diff --git a/src/test/modules/test_tidstore/test_tidstore.c b/src/test/modules/test_tidstore/test_tidstore.c index 60446e484d3..0793cfa374a 100644 --- a/src/test/modules/test_tidstore/test_tidstore.c +++ b/src/test/modules/test_tidstore/test_tidstore.c @@ -134,9 +134,9 @@ test_create(PG_FUNCTION_ARGS) items.num_tids = 0; items.max_tids = array_init_size / sizeof(ItemPointerData); - items.insert_tids = (ItemPointerData *) palloc0(array_init_size); - items.lookup_tids = (ItemPointerData *) palloc0(array_init_size); - items.iter_tids = (ItemPointerData *) palloc0(array_init_size); + items.insert_tids = palloc0_array(ItemPointerData, items.max_tids); + items.lookup_tids = palloc0_array(ItemPointerData, items.max_tids); + items.iter_tids = palloc0_array(ItemPointerData, items.max_tids); MemoryContextSwitchTo(old_ctx); @@ -212,9 +212,9 @@ do_set_block_offsets(PG_FUNCTION_ARGS) if (idx >= items.max_tids) { items.max_tids *= 2; - items.insert_tids = repalloc(items.insert_tids, sizeof(ItemPointerData) * items.max_tids); - items.lookup_tids = repalloc(items.lookup_tids, sizeof(ItemPointerData) * items.max_tids); - items.iter_tids = repalloc(items.iter_tids, sizeof(ItemPointerData) * items.max_tids); + items.insert_tids = repalloc_array(items.insert_tids, ItemPointerData, items.max_tids); + items.lookup_tids = repalloc_array(items.lookup_tids, ItemPointerData, items.max_tids); + items.iter_tids = repalloc_array(items.iter_tids, ItemPointerData, items.max_tids); } tid = &(items.insert_tids[idx]); diff --git a/src/test/regress/regress.c b/src/test/regress/regress.c index 9801cdd1d8c..c2975ffc1b0 100644 --- a/src/test/regress/regress.c +++ b/src/test/regress/regress.c @@ -294,7 +294,7 @@ Datum int44in(PG_FUNCTION_ARGS) { char *input_string = PG_GETARG_CSTRING(0); - int32 *result = (int32 *) palloc(4 * sizeof(int32)); + int32 *result = palloc_array(int32, 4); int i; i = sscanf(input_string, @@ -371,8 +371,8 @@ make_tuple_indirect(PG_FUNCTION_ARGS) tuple.t_tableOid = InvalidOid; tuple.t_data = rec; - values = (Datum *) palloc(ncolumns * sizeof(Datum)); - nulls = (bool *) palloc(ncolumns * sizeof(bool)); + values = palloc_array(Datum, ncolumns); + nulls = palloc_array(bool, ncolumns); heap_deform_tuple(&tuple, tupdesc, values, nulls); @@ -452,7 +452,7 @@ get_environ(PG_FUNCTION_ARGS) for (char **s = environ; *s; s++) nvals++; - env = palloc(nvals * sizeof(Datum)); + env = palloc_array(Datum, nvals); for (int i = 0; i < nvals; i++) env[i] = CStringGetTextDatum(environ[i]); @@ -1183,7 +1183,7 @@ test_text_to_wchars(PG_FUNCTION_ARGS) text *string = PG_GETARG_TEXT_PP(1); const char *data = VARDATA_ANY(string); size_t size = VARSIZE_ANY_EXHDR(string); - pg_wchar *wchars = palloc(sizeof(pg_wchar) * (size + 1)); + pg_wchar *wchars = palloc_array(pg_wchar, size + 1); Datum *datums; int wlen; int encoding; @@ -1194,7 +1194,7 @@ test_text_to_wchars(PG_FUNCTION_ARGS) if (size > 0) { - datums = palloc(sizeof(Datum) * size); + datums = palloc_array(Datum, size); wlen = pg_encoding_mb2wchar_with_len(encoding, data, wchars, @@ -1237,7 +1237,7 @@ test_wchars_to_text(PG_FUNCTION_ARGS) if (wlen > 0) { - pg_wchar *wchars = palloc(sizeof(pg_wchar) * wlen); + pg_wchar *wchars = palloc_array(pg_wchar, wlen); for (int i = 0; i < wlen; ++i) {