From dff76c91c3b8c301985caa07d71e04b69501962a Mon Sep 17 00:00:00 2001 From: Bertrand Drouvot Date: Thu, 11 Dec 2025 09:50:08 +0000 Subject: [PATCH v1 2/2] Use sizeof(*var) for type safe allocation formulas It makes the code more maintainable (type changes automatically update allocation) and less error prone (as seen recently in 3f83de20ba2 and 06761b6096b). --- contrib/btree_gist/btree_utils_num.c | 2 +- contrib/btree_gist/btree_utils_var.c | 4 +- contrib/file_fdw/file_fdw.c | 4 +- contrib/hstore/hstore_gin.c | 4 +- contrib/hstore/hstore_io.c | 16 +- contrib/hstore/hstore_op.c | 14 +- contrib/hstore_plperl/hstore_plperl.c | 2 +- contrib/oid2name/oid2name.c | 10 +- contrib/pageinspect/btreefuncs.c | 2 +- contrib/pageinspect/ginfuncs.c | 2 +- contrib/pg_logicalinspect/pg_logicalinspect.c | 4 +- .../pg_stat_statements/pg_stat_statements.c | 2 +- contrib/pg_trgm/trgm_gist.c | 2 +- contrib/pg_trgm/trgm_regexp.c | 4 +- contrib/pgcrypto/pgp-armor.c | 4 +- contrib/pgrowlocks/pgrowlocks.c | 8 +- contrib/postgres_fdw/postgres_fdw.c | 8 +- contrib/seg/seg.c | 6 +- contrib/spi/autoinc.c | 6 +- contrib/spi/refint.c | 8 +- contrib/tablefunc/tablefunc.c | 8 +- contrib/xml2/xpath.c | 4 +- src/backend/access/brin/brin_minmax_multi.c | 4 +- src/backend/access/common/printtup.c | 2 +- src/backend/access/common/reloptions.c | 4 +- src/backend/access/common/tupdesc.c | 4 +- src/backend/access/gin/gindatapage.c | 4 +- src/backend/access/gin/ginget.c | 8 +- src/backend/access/gin/gininsert.c | 2 +- src/backend/access/gin/ginpostinglist.c | 2 +- src/backend/access/gin/ginscan.c | 4 +- src/backend/access/gin/ginutil.c | 4 +- src/backend/access/gist/gistget.c | 4 +- src/backend/access/gist/gistproc.c | 10 +- src/backend/access/gist/gistscan.c | 6 +- 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 | 2 +- src/backend/access/nbtree/nbtinsert.c | 4 +- src/backend/access/nbtree/nbtpreprocesskeys.c | 10 +- src/backend/access/transam/multixact.c | 2 +- src/backend/access/transam/twophase.c | 2 +- src/backend/access/transam/xact.c | 2 +- src/backend/backup/basebackup_incremental.c | 2 +- src/backend/catalog/aclchk.c | 2 +- src/backend/catalog/dependency.c | 2 +- src/backend/catalog/heap.c | 2 +- src/backend/catalog/namespace.c | 2 +- src/backend/catalog/pg_constraint.c | 6 +- src/backend/catalog/pg_inherits.c | 2 +- src/backend/catalog/pg_shdepend.c | 2 +- src/backend/commands/alter.c | 18 +- src/backend/commands/analyze.c | 44 ++--- src/backend/commands/async.c | 4 +- src/backend/commands/collationcmds.c | 2 +- src/backend/commands/copyfrom.c | 18 +- src/backend/commands/copyto.c | 4 +- src/backend/commands/dbcommands.c | 2 +- src/backend/commands/explain.c | 6 +- src/backend/commands/explain_dr.c | 2 +- src/backend/commands/explain_state.c | 2 +- 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 | 4 +- src/backend/commands/tablespace.c | 2 +- src/backend/commands/trigger.c | 14 +- src/backend/commands/vacuum.c | 2 +- src/backend/executor/execExprInterp.c | 12 +- src/backend/executor/execGrouping.c | 6 +- src/backend/executor/execJunk.c | 4 +- src/backend/executor/execParallel.c | 2 +- src/backend/executor/execSRF.c | 4 +- src/backend/executor/execTuples.c | 10 +- src/backend/executor/execUtils.c | 4 +- src/backend/executor/functions.c | 2 +- src/backend/executor/instrument.c | 2 +- src/backend/executor/nodeAgg.c | 18 +- src/backend/executor/nodeAppend.c | 6 +- src/backend/executor/nodeBitmapAnd.c | 2 +- src/backend/executor/nodeBitmapOr.c | 2 +- src/backend/executor/nodeGatherMerge.c | 2 +- src/backend/executor/nodeIncrementalSort.c | 2 +- src/backend/executor/nodeIndexscan.c | 16 +- src/backend/executor/nodeMemoize.c | 6 +- src/backend/executor/nodeModifyTable.c | 2 +- src/backend/executor/nodeSubplan.c | 14 +- src/backend/executor/nodeTidscan.c | 2 +- src/backend/executor/nodeValuesscan.c | 4 +- src/backend/jit/llvm/llvmjit_expr.c | 2 +- src/backend/lib/bipartite_match.c | 8 +- src/backend/lib/knapsack.c | 4 +- src/backend/libpq/auth.c | 2 +- src/backend/libpq/hba.c | 4 +- src/backend/nodes/queryjumblefuncs.c | 2 +- src/backend/nodes/readfuncs.c | 2 +- src/backend/optimizer/path/allpaths.c | 4 +- src/backend/optimizer/path/equivclass.c | 2 +- src/backend/optimizer/path/pathkeys.c | 4 +- src/backend/optimizer/plan/createplan.c | 46 ++--- src/backend/optimizer/plan/planner.c | 22 +-- src/backend/optimizer/prep/prepjointree.c | 10 +- src/backend/optimizer/util/appendinfo.c | 2 +- src/backend/optimizer/util/clauses.c | 4 +- src/backend/parser/analyze.c | 4 +- src/backend/parser/parse_clause.c | 2 +- src/backend/parser/parse_cte.c | 2 +- src/backend/parser/parse_relation.c | 4 +- src/backend/partitioning/partbounds.c | 20 +-- src/backend/partitioning/partdesc.c | 10 +- src/backend/partitioning/partprune.c | 10 +- src/backend/port/posix_sema.c | 2 +- src/backend/port/sysv_sema.c | 2 +- src/backend/port/win32_sema.c | 2 +- src/backend/postmaster/autovacuum.c | 2 +- src/backend/postmaster/checkpointer.c | 2 +- src/backend/postmaster/pmchild.c | 2 +- src/backend/postmaster/postmaster.c | 2 +- src/backend/regex/regc_pg_locale.c | 2 +- src/backend/replication/logical/proto.c | 2 +- .../replication/logical/reorderbuffer.c | 2 +- src/backend/replication/logical/snapbuild.c | 2 +- src/backend/replication/logical/tablesync.c | 4 +- src/backend/replication/logical/worker.c | 8 +- src/backend/replication/pgoutput/pgoutput.c | 2 +- src/backend/rewrite/rewriteHandler.c | 4 +- src/backend/statistics/extended_stats.c | 10 +- src/backend/statistics/mcv.c | 4 +- src/backend/statistics/mvdistinct.c | 2 +- src/backend/storage/file/fd.c | 6 +- src/backend/storage/ipc/procarray.c | 10 +- src/backend/storage/lmgr/deadlock.c | 16 +- src/backend/storage/lmgr/lock.c | 2 +- src/backend/tcop/fastpath.c | 2 +- src/backend/tsearch/wparser_def.c | 2 +- src/backend/utils/activity/pgstat_xact.c | 2 +- src/backend/utils/adt/acl.c | 2 +- src/backend/utils/adt/array_typanalyze.c | 4 +- src/backend/utils/adt/arrayfuncs.c | 20 +-- src/backend/utils/adt/arrayutils.c | 2 +- src/backend/utils/adt/enum.c | 2 +- src/backend/utils/adt/formatting.c | 8 +- src/backend/utils/adt/jsonfuncs.c | 8 +- src/backend/utils/adt/levenshtein.c | 4 +- src/backend/utils/adt/lockfuncs.c | 6 +- src/backend/utils/adt/multirangetypes.c | 10 +- src/backend/utils/adt/name.c | 2 +- src/backend/utils/adt/numeric.c | 8 +- src/backend/utils/adt/oracle_compat.c | 4 +- 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/rowtypes.c | 32 ++-- src/backend/utils/adt/ruleutils.c | 20 +-- src/backend/utils/adt/selfuncs.c | 4 +- src/backend/utils/adt/tsquery_cleanup.c | 2 +- src/backend/utils/adt/tsquery_rewrite.c | 2 +- src/backend/utils/adt/tsvector_op.c | 10 +- src/backend/utils/adt/varlena.c | 6 +- src/backend/utils/adt/xml.c | 4 +- src/backend/utils/cache/catcache.c | 2 +- src/backend/utils/cache/inval.c | 2 +- src/backend/utils/cache/lsyscache.c | 2 +- src/backend/utils/cache/relcache.c | 4 +- src/backend/utils/cache/typcache.c | 2 +- src/backend/utils/fmgr/funcapi.c | 22 +-- src/backend/utils/misc/ps_status.c | 4 +- src/backend/utils/sort/logtape.c | 2 +- src/backend/utils/sort/tuplesort.c | 8 +- src/backend/utils/sort/tuplestore.c | 4 +- src/backend/utils/time/snapmgr.c | 4 +- src/bin/initdb/initdb.c | 4 +- src/bin/pg_amcheck/pg_amcheck.c | 6 +- src/bin/pg_basebackup/pg_basebackup.c | 4 +- src/bin/pg_basebackup/walmethods.c | 12 +- src/bin/pg_combinebackup/load_manifest.c | 2 +- src/bin/pg_combinebackup/pg_combinebackup.c | 6 +- src/bin/pg_combinebackup/reconstruct.c | 10 +- src/bin/pg_combinebackup/write_manifest.c | 2 +- src/bin/pg_ctl/pg_ctl.c | 4 +- src/bin/pg_dump/compress_gzip.c | 2 +- src/bin/pg_dump/compress_io.c | 4 +- src/bin/pg_dump/compress_none.c | 2 +- src/bin/pg_dump/dumputils.c | 6 +- src/bin/pg_dump/parallel.c | 10 +- src/bin/pg_dump/pg_backup_archiver.c | 30 ++-- src/bin/pg_dump/pg_backup_custom.c | 6 +- src/bin/pg_dump/pg_backup_directory.c | 6 +- src/bin/pg_dump/pg_dump.c | 166 +++++++++--------- src/bin/pg_dump/pg_dump_sort.c | 12 +- src/bin/pg_dump/pg_dumpall.c | 2 +- src/bin/pg_rewind/datapagemap.c | 2 +- src/bin/pg_rewind/libpq_source.c | 2 +- src/bin/pg_rewind/local_source.c | 2 +- src/bin/pg_rewind/pg_rewind.c | 2 +- src/bin/pg_rewind/timeline.c | 2 +- src/bin/pg_upgrade/check.c | 4 +- src/bin/pg_upgrade/function.c | 4 +- src/bin/pg_upgrade/info.c | 10 +- src/bin/pg_upgrade/parallel.c | 12 +- src/bin/pg_upgrade/tablespace.c | 4 +- src/bin/pg_upgrade/task.c | 4 +- src/bin/pg_verifybackup/astreamer_verify.c | 2 +- src/bin/pg_verifybackup/pg_verifybackup.c | 8 +- src/bin/pgbench/pgbench.c | 14 +- src/bin/psql/command.c | 2 +- src/bin/psql/copy.c | 2 +- src/bin/psql/crosstabview.c | 10 +- src/bin/psql/describe.c | 2 +- src/bin/psql/tab-complete.in.c | 4 +- src/bin/scripts/reindexdb.c | 6 +- src/bin/scripts/vacuuming.c | 2 +- src/common/blkreftable.c | 2 +- src/fe_utils/conditional.c | 2 +- src/fe_utils/print.c | 4 +- src/fe_utils/simple_list.c | 4 +- src/interfaces/ecpg/ecpglib/misc.c | 2 +- src/interfaces/libpq/fe-auth-scram.c | 2 +- src/interfaces/libpq/fe-auth.c | 2 +- src/interfaces/libpq/fe-connect.c | 6 +- src/interfaces/libpq/fe-exec.c | 6 +- src/interfaces/libpq/fe-lobj.c | 2 +- src/interfaces/libpq/fe-print.c | 2 +- src/interfaces/libpq/fe-protocol3.c | 4 +- src/interfaces/libpq/libpq-events.c | 2 +- src/pl/plperl/plperl.c | 22 +-- src/pl/plpython/plpy_cursorobject.c | 4 +- src/pl/plpython/plpy_exec.c | 6 +- src/pl/plpython/plpy_spi.c | 4 +- src/pl/tcl/pltcl.c | 14 +- src/port/dirent.c | 2 +- src/timezone/localtime.c | 2 +- 234 files changed, 755 insertions(+), 755 deletions(-) 7.6% contrib/ 6.4% src/backend/access/ 10.0% src/backend/commands/ 8.4% src/backend/executor/ 4.7% src/backend/optimizer/plan/ 12.3% src/backend/utils/adt/ 3.7% src/backend/utils/ 14.3% src/backend/ 17.0% src/bin/pg_dump/ 9.5% src/bin/ 3.0% src/pl/ diff --git a/contrib/btree_gist/btree_utils_num.c b/contrib/btree_gist/btree_utils_num.c index 51c8836f27a..946a1bc2326 100644 --- a/contrib/btree_gist/btree_utils_num.c +++ b/contrib/btree_gist/btree_utils_num.c @@ -344,7 +344,7 @@ gbt_num_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v, Nsrt *arr; int nbytes; - arr = (Nsrt *) palloc((maxoff + 1) * sizeof(Nsrt)); + arr = (Nsrt *) palloc((maxoff + 1) * sizeof(*arr)); nbytes = (maxoff + 2) * sizeof(OffsetNumber); v->spl_left = (OffsetNumber *) palloc(nbytes); v->spl_right = (OffsetNumber *) palloc(nbytes); diff --git a/contrib/btree_gist/btree_utils_var.c b/contrib/btree_gist/btree_utils_var.c index c2d192d424e..0b16584aeae 100644 --- a/contrib/btree_gist/btree_utils_var.c +++ b/contrib/btree_gist/btree_utils_var.c @@ -467,7 +467,7 @@ gbt_var_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v, GBT_VARKEY **sv = NULL; gbt_vsrt_arg varg; - arr = (Vsrt *) palloc((maxoff + 1) * sizeof(Vsrt)); + arr = (Vsrt *) palloc((maxoff + 1) * sizeof(*arr)); nbytes = (maxoff + 2) * sizeof(OffsetNumber); v->spl_left = (OffsetNumber *) palloc(nbytes); v->spl_right = (OffsetNumber *) palloc(nbytes); @@ -476,7 +476,7 @@ gbt_var_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v, v->spl_nleft = 0; v->spl_nright = 0; - sv = palloc(sizeof(GBT_VARKEY *) * (maxoff + 1)); + sv = palloc(sizeof(*sv) * (maxoff + 1)); /* Sort entries */ diff --git a/contrib/file_fdw/file_fdw.c b/contrib/file_fdw/file_fdw.c index e9cda3c47d1..dd85f097112 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 = (Datum *) palloc(tupDesc->natts * sizeof(*values)); + nulls = (bool *) palloc(tupDesc->natts * sizeof(*nulls)); /* 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 2e5fa115924..be3734b5520 100644 --- a/contrib/hstore/hstore_gin.c +++ b/contrib/hstore/hstore_gin.c @@ -103,7 +103,7 @@ gin_extract_hstore_query(PG_FUNCTION_ARGS) text *item; *nentries = 1; - entries = (Datum *) palloc(sizeof(Datum)); + entries = (Datum *) palloc(sizeof(*entries)); 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 = (Datum *) palloc(sizeof(*entries) * 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 34e3918811c..acff50c029c 100644 --- a/contrib/hstore/hstore_io.c +++ b/contrib/hstore/hstore_io.c @@ -522,7 +522,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(pcount * sizeof(*pairs)); for (i = 0; i < pcount; ++i) { @@ -673,7 +673,7 @@ hstore_from_arrays(PG_FUNCTION_ARGS) Assert(key_count == value_count); } - pairs = palloc(key_count * sizeof(Pairs)); + pairs = palloc(key_count * sizeof(*pairs)); for (i = 0; i < key_count; ++i) { @@ -767,7 +767,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(count * sizeof(*pairs)); for (i = 0; i < count; ++i) { @@ -908,7 +908,7 @@ hstore_from_record(PG_FUNCTION_ARGS) } Assert(ncolumns <= MaxTupleAttributeNumber); /* thus, no overflow */ - pairs = palloc(ncolumns * sizeof(Pairs)); + pairs = palloc(ncolumns * sizeof(*pairs)); if (rec) { @@ -918,8 +918,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 = (Datum *) palloc(ncolumns * sizeof(*values)); + nulls = (bool *) palloc(ncolumns * sizeof(*nulls)); /* Break down the tuple into fields */ heap_deform_tuple(&tuple, tupdesc, values, nulls); @@ -1101,8 +1101,8 @@ hstore_populate_record(PG_FUNCTION_ARGS) my_extra->ncolumns = ncolumns; } - values = (Datum *) palloc(ncolumns * sizeof(Datum)); - nulls = (bool *) palloc(ncolumns * sizeof(bool)); + values = (Datum *) palloc(ncolumns * sizeof(*values)); + nulls = (bool *) palloc(ncolumns * sizeof(*nulls)); if (rec) { diff --git a/contrib/hstore/hstore_op.c b/contrib/hstore/hstore_op.c index bcba75f9258..19ee61dedf9 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(sizeof(*key_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(sizeof(*out_datums) * key_count); + out_nulls = palloc(sizeof(*out_nulls) * 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(sizeof(*out_pairs) * nkeys); bufsiz = 0; /* @@ -705,7 +705,7 @@ hstore_akeys(PG_FUNCTION_ARGS) PG_RETURN_POINTER(a); } - d = (Datum *) palloc(sizeof(Datum) * count); + d = (Datum *) palloc(sizeof(*d) * 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 = (Datum *) palloc(sizeof(*d) * count); + nulls = (bool *) palloc(sizeof(*nulls) * count); for (i = 0; i < count; ++i) { diff --git a/contrib/hstore_plperl/hstore_plperl.c b/contrib/hstore_plperl/hstore_plperl.c index 31393b4fa50..ebef6422d77 100644 --- a/contrib/hstore_plperl/hstore_plperl.c +++ b/contrib/hstore_plperl/hstore_plperl.c @@ -121,7 +121,7 @@ plperl_to_hstore(PG_FUNCTION_ARGS) pcount = hv_iterinit(hv); - pairs = palloc(pcount * sizeof(Pairs)); + pairs = palloc(pcount * sizeof(*pairs)); i = 0; while ((he = hv_iternext(hv))) diff --git a/contrib/oid2name/oid2name.c b/contrib/oid2name/oid2name.c index 51802907138..2b155648d9f 100644 --- a/contrib/oid2name/oid2name.c +++ b/contrib/oid2name/oid2name.c @@ -400,7 +400,7 @@ sql_exec(PGconn *conn, const char *todo, bool quiet) nfields = PQnfields(res); /* for each field, get the needed width */ - length = (int *) pg_malloc(sizeof(int) * nfields); + length = (int *) pg_malloc(sizeof(*length) * nfields); for (j = 0; j < nfields; j++) length[j] = strlen(PQfname(res, j)); @@ -585,11 +585,11 @@ main(int argc, char **argv) struct options *my_opts; PGconn *pgconn; - my_opts = (struct options *) pg_malloc(sizeof(struct options)); + my_opts = (struct options *) pg_malloc(sizeof(*my_opts)); - my_opts->oids = (eary *) pg_malloc(sizeof(eary)); - my_opts->tables = (eary *) pg_malloc(sizeof(eary)); - my_opts->filenumbers = (eary *) pg_malloc(sizeof(eary)); + my_opts->oids = (eary *) pg_malloc(sizeof(*my_opts->oids)); + my_opts->tables = (eary *) pg_malloc(sizeof(*my_opts->tables)); + my_opts->filenumbers = (eary *) pg_malloc(sizeof(*my_opts->filenumbers)); my_opts->oids->num = my_opts->oids->alloc = 0; my_opts->tables->num = my_opts->tables->alloc = 0; diff --git a/contrib/pageinspect/btreefuncs.c b/contrib/pageinspect/btreefuncs.c index 62c905c6e7c..ac9a3f947cf 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 = (Datum *) palloc(nposting * sizeof(*tids_datum)); 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 f6168d8e895..b242596c2c7 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 = (Datum *) palloc(ndecoded * sizeof(*tids_datum)); 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 50e805d3195..2c6c9a0d69f 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 = (Datum *) palloc(ondisk.builder.committed.xcnt * sizeof(*arrayelems)); for (int 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 = (Datum *) palloc(ondisk.builder.catchange.xcnt * sizeof(*arrayelems)); for (int j = 0; j < ondisk.builder.catchange.xcnt; j++) arrayelems[j] = TransactionIdGetDatum(ondisk.builder.catchange.xip[j]); diff --git a/contrib/pg_stat_statements/pg_stat_statements.c b/contrib/pg_stat_statements/pg_stat_statements.c index 39208f80b5b..2af6ea863b2 100644 --- a/contrib/pg_stat_statements/pg_stat_statements.c +++ b/contrib/pg_stat_statements/pg_stat_statements.c @@ -2194,7 +2194,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(hash_get_num_entries(pgss_hash) * sizeof(*entries)); i = 0; tottextlen = 0; diff --git a/contrib/pg_trgm/trgm_gist.c b/contrib/pg_trgm/trgm_gist.c index 5c7deb103a6..dab1c8cdd32 100644 --- a/contrib/pg_trgm/trgm_gist.c +++ b/contrib/pg_trgm/trgm_gist.c @@ -423,7 +423,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 = (bool *) palloc(len * sizeof(*check)); 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 1a76794c422..50fd6284318 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 = (pg_wchar *) palloc((text_re_len + 1) * sizeof(*pattern)); pattern_len = pg_mb2wchar_with_len(text_re_val, pattern, text_re_len); @@ -769,7 +769,7 @@ getColorInfo(regex_t *regex, TrgmNFA *trgmNFA) trgmNFA->ncolors = colorsCount; trgmNFA->colorInfo = (TrgmColorInfo *) - palloc0(colorsCount * sizeof(TrgmColorInfo)); + palloc0(colorsCount * sizeof(*trgmNFA->colorInfo)); /* * Loop over colors, filling TrgmColorInfo about each. Note we include diff --git a/contrib/pgcrypto/pgp-armor.c b/contrib/pgcrypto/pgp-armor.c index bfc90af063d..196a40a8255 100644 --- a/contrib/pgcrypto/pgp-armor.c +++ b/contrib/pgcrypto/pgp-armor.c @@ -441,8 +441,8 @@ pgp_extract_armor_headers(const uint8 *src, unsigned len, buf[armor_len] = '\0'; /* Allocate return arrays */ - *keys = (char **) palloc(hdrlines * sizeof(char *)); - *values = (char **) palloc(hdrlines * sizeof(char *)); + *keys = (char **) palloc(hdrlines * sizeof(**keys)); + *values = (char **) palloc(hdrlines * sizeof(**values)); /* * Split the header lines at newlines and ": " separators, and collect diff --git a/contrib/pgrowlocks/pgrowlocks.c b/contrib/pgrowlocks/pgrowlocks.c index f88269332b6..1db925fbddc 100644 --- a/contrib/pgrowlocks/pgrowlocks.c +++ b/contrib/pgrowlocks/pgrowlocks.c @@ -119,7 +119,7 @@ pgrowlocks(PG_FUNCTION_ARGS) attinmeta = TupleDescGetAttInMetadata(rsinfo->setDesc); - values = (char **) palloc(rsinfo->setDesc->natts * sizeof(char *)); + values = (char **) palloc(rsinfo->setDesc->natts * sizeof(*values)); while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL) { @@ -144,7 +144,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(NCHARS * sizeof(*values[Atnum_xmax])); snprintf(values[Atnum_xmax], NCHARS, "%u", xmax); if (infomask & HEAP_XMAX_IS_MULTI) { @@ -226,7 +226,7 @@ pgrowlocks(PG_FUNCTION_ARGS) { values[Atnum_ismulti] = pstrdup("false"); - values[Atnum_xids] = palloc(NCHARS * sizeof(char)); + values[Atnum_xids] = palloc(NCHARS * sizeof(*values[Atnum_xids])); snprintf(values[Atnum_xids], NCHARS, "{%u}", xmax); values[Atnum_modes] = palloc(NCHARS); @@ -256,7 +256,7 @@ pgrowlocks(PG_FUNCTION_ARGS) snprintf(values[Atnum_modes], NCHARS, "{No Key Update}"); } - values[Atnum_pids] = palloc(NCHARS * sizeof(char)); + values[Atnum_pids] = palloc(NCHARS * sizeof(*values[Atnum_pids])); snprintf(values[Atnum_pids], NCHARS, "{%d}", BackendXidGetPid(xmax)); } diff --git a/contrib/postgres_fdw/postgres_fdw.c b/contrib/postgres_fdw/postgres_fdw.c index 5e178c21b39..60c0544d3b8 100644 --- a/contrib/postgres_fdw/postgres_fdw.c +++ b/contrib/postgres_fdw/postgres_fdw.c @@ -3844,7 +3844,7 @@ fetch_more_data(ForeignScanState *node) /* Convert the data into HeapTuples */ numrows = PQntuples(res); - fsstate->tuples = (HeapTuple *) palloc0(numrows * sizeof(HeapTuple)); + fsstate->tuples = (HeapTuple *) palloc0(numrows * sizeof(*fsstate->tuples)); fsstate->num_tuples = numrows; fsstate->next_tuple = 0; @@ -4650,7 +4650,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)); + palloc0(resultTupType->natts * sizeof(*dmstate->attnoMap)); dmstate->ctidAttno = dmstate->oidAttno = 0; @@ -7528,8 +7528,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 = (Datum *) palloc0(tupdesc->natts * sizeof(*values)); + nulls = (bool *) palloc(tupdesc->natts * sizeof(*nulls)); /* 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 2d3a048c73e..16077811d21 100644 --- a/contrib/seg/seg.c +++ b/contrib/seg/seg.c @@ -345,7 +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)); + palloc(maxoff * sizeof(*sort_items)); for (i = 1; i <= maxoff; i++) { seg = DatumGetSegP(entryvec->vector[i].key); @@ -360,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 = (OffsetNumber *) palloc(maxoff * sizeof(*v->spl_left)); + v->spl_right = (OffsetNumber *) palloc(maxoff * sizeof(*v->spl_right)); left = v->spl_left; v->spl_nleft = 0; right = v->spl_right; diff --git a/contrib/spi/autoinc.c b/contrib/spi/autoinc.c index b5609f20251..672a0ed3589 100644 --- a/contrib/spi/autoinc.c +++ b/contrib/spi/autoinc.c @@ -67,9 +67,9 @@ autoinc(PG_FUNCTION_ARGS) args = trigger->tgargs; tupdesc = rel->rd_att; - chattrs = (int *) palloc(nargs / 2 * sizeof(int)); - newvals = (Datum *) palloc(nargs / 2 * sizeof(Datum)); - newnulls = (bool *) palloc(nargs / 2 * sizeof(bool)); + chattrs = (int *) palloc(nargs / 2 * sizeof(*chattrs)); + newvals = (Datum *) palloc(nargs / 2 * sizeof(*newvals)); + newnulls = (bool *) palloc(nargs / 2 * sizeof(*newnulls)); for (i = 0; i < nargs;) { diff --git a/contrib/spi/refint.c b/contrib/spi/refint.c index fbbd558ca1e..7dc787bd0e4 100644 --- a/contrib/spi/refint.c +++ b/contrib/spi/refint.c @@ -121,7 +121,7 @@ check_primary_key(PG_FUNCTION_ARGS) * We use SPI plan preparation feature, so allocate space to place key * values. */ - kvals = (Datum *) palloc(nkeys * sizeof(Datum)); + kvals = (Datum *) palloc(nkeys * sizeof(*kvals)); /* * Construct ident string as TriggerName $ TriggeredRelationId and try to @@ -132,7 +132,7 @@ check_primary_key(PG_FUNCTION_ARGS) /* if there is no plan then allocate argtypes for preparation */ if (plan->nplans <= 0) - argtypes = (Oid *) palloc(nkeys * sizeof(Oid)); + argtypes = (Oid *) palloc(nkeys * sizeof(*argtypes)); /* For each column in key ... */ for (i = 0; i < nkeys; i++) @@ -343,7 +343,7 @@ check_foreign_key(PG_FUNCTION_ARGS) * We use SPI plan preparation feature, so allocate space to place key * values. */ - kvals = (Datum *) palloc(nkeys * sizeof(Datum)); + kvals = (Datum *) palloc(nkeys * sizeof(*kvals)); /* * Construct ident string as TriggerName $ TriggeredRelationId $ @@ -354,7 +354,7 @@ check_foreign_key(PG_FUNCTION_ARGS) /* if there is no plan(s) then allocate argtypes for preparation */ if (plan->nplans <= 0) - argtypes = (Oid *) palloc(nkeys * sizeof(Oid)); + argtypes = (Oid *) palloc(nkeys * sizeof(*argtypes)); /* * else - check that we have exactly nrefs plan(s) ready diff --git a/contrib/tablefunc/tablefunc.c b/contrib/tablefunc/tablefunc.c index c40fd36dc96..62588cfc4ba 100644 --- a/contrib/tablefunc/tablefunc.c +++ b/contrib/tablefunc/tablefunc.c @@ -485,7 +485,7 @@ crosstab(PG_FUNCTION_ARGS) char **values; /* allocate and zero space */ - values = (char **) palloc0((1 + num_categories) * sizeof(char *)); + values = (char **) palloc0((1 + num_categories) * sizeof(*values)); /* * now loop through the sql results and assign each value in sequence @@ -862,7 +862,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 = (char **) palloc0(result_ncols * sizeof(*values)); for (i = 0; i < proc; i++) { @@ -1245,9 +1245,9 @@ build_tuplestore_recursively(char *key_fld, } if (show_branch) - values = (char **) palloc((CONNECTBY_NCOLS + serial_column) * sizeof(char *)); + values = (char **) palloc((CONNECTBY_NCOLS + serial_column) * sizeof(*values)); else - values = (char **) palloc((CONNECTBY_NCOLS_NOBRANCH + serial_column) * sizeof(char *)); + values = (char **) palloc((CONNECTBY_NCOLS_NOBRANCH + serial_column) * sizeof(*values)); /* First time through, do a little setup */ if (level == 0) diff --git a/contrib/xml2/xpath.c b/contrib/xml2/xpath.c index 662d7d02f27..3e631431d10 100644 --- a/contrib/xml2/xpath.c +++ b/contrib/xml2/xpath.c @@ -651,8 +651,8 @@ xpath_table(PG_FUNCTION_ARGS) attinmeta = TupleDescGetAttInMetadata(rsinfo->setDesc); - values = (char **) palloc(rsinfo->setDesc->natts * sizeof(char *)); - xpaths = (xmlChar **) palloc(rsinfo->setDesc->natts * sizeof(xmlChar *)); + values = (char **) palloc(rsinfo->setDesc->natts * sizeof(*values)); + xpaths = (xmlChar **) palloc(rsinfo->setDesc->natts * sizeof(*xpaths)); /* * Split XPaths. xpathset is a writable CString. diff --git a/src/backend/access/brin/brin_minmax_multi.c b/src/backend/access/brin/brin_minmax_multi.c index 0298a9da8ba..e496e98b06d 100644 --- a/src/backend/access/brin/brin_minmax_multi.c +++ b/src/backend/access/brin/brin_minmax_multi.c @@ -1392,7 +1392,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 = (ExpandedRange *) palloc0(neranges * sizeof(*eranges)); /* fill the expanded ranges */ fill_expanded_ranges(eranges, neranges, ranges); @@ -2785,7 +2785,7 @@ brin_minmax_multi_union(PG_FUNCTION_ARGS) oldctx = MemoryContextSwitchTo(ctx); /* allocate and fill */ - eranges = (ExpandedRange *) palloc0(neranges * sizeof(ExpandedRange)); + eranges = (ExpandedRange *) palloc0(neranges * sizeof(*eranges)); /* 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 47b2b2d2335..83c8a7234c9 100644 --- a/src/backend/access/common/printtup.c +++ b/src/backend/access/common/printtup.c @@ -264,7 +264,7 @@ printtup_prepare_info(DR_printtup *myState, TupleDesc typeinfo, int numAttrs) return; myState->myinfo = (PrinttupAttrInfo *) - palloc0(numAttrs * sizeof(PrinttupAttrInfo)); + palloc0(numAttrs * sizeof(*myState->myinfo)); for (i = 0; i < numAttrs; i++) { diff --git a/src/backend/access/common/reloptions.c b/src/backend/access/common/reloptions.c index 31926d8a368..032f5f2beaf 100644 --- a/src/backend/access/common/reloptions.c +++ b/src/backend/access/common/reloptions.c @@ -730,7 +730,7 @@ 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(max_custom_options * sizeof(*custom_options)); } else { @@ -1544,7 +1544,7 @@ parseRelOptions(Datum options, bool validate, relopt_kind kind, if (numoptions > 0) { - reloptions = palloc(numoptions * sizeof(relopt_value)); + reloptions = palloc(numoptions * sizeof(*reloptions)); 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 bcd1ddcc68b..1a224491255 100644 --- a/src/backend/access/common/tupdesc.c +++ b/src/backend/access/common/tupdesc.c @@ -369,7 +369,7 @@ CreateTupleDescCopyConstr(TupleDesc tupdesc) if ((cpy->num_defval = constr->num_defval) > 0) { - cpy->defval = (AttrDefault *) palloc(cpy->num_defval * sizeof(AttrDefault)); + cpy->defval = (AttrDefault *) palloc(cpy->num_defval * sizeof(*cpy->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); @@ -394,7 +394,7 @@ CreateTupleDescCopyConstr(TupleDesc tupdesc) if ((cpy->num_check = constr->num_check) > 0) { - cpy->check = (ConstrCheck *) palloc(cpy->num_check * sizeof(ConstrCheck)); + cpy->check = (ConstrCheck *) palloc(cpy->num_check * sizeof(*cpy->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 0140bd4904b..82941bcdd32 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((*nitems) * sizeof(*result)); 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(nuncompressed * sizeof(*seginfo->items)); 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 b3e2e9d5f6e..e9457753b90 100644 --- a/src/backend/access/gin/ginget.c +++ b/src/backend/access/gin/ginget.c @@ -544,7 +544,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(key->nadditional * sizeof(*key->additionalEntries)); for (i = 0; i < key->nadditional; i++) key->additionalEntries[i] = key->scanEntry[i]; } @@ -577,8 +577,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(key->nrequired * sizeof(*key->requiredEntries)); + key->additionalEntries = palloc(key->nadditional * sizeof(*key->additionalEntries)); j = 0; for (i = 0; i < key->nrequired; i++) @@ -595,7 +595,7 @@ startScanKey(GinState *ginstate, GinScanOpaque so, GinScanKey key) key->nrequired = 1; key->nadditional = 0; - key->requiredEntries = palloc(1 * sizeof(GinScanEntry)); + key->requiredEntries = palloc(1 * sizeof(*key->requiredEntries)); 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 df30dcc0228..579d5d282c3 100644 --- a/src/backend/access/gin/gininsert.c +++ b/src/backend/access/gin/gininsert.c @@ -1517,7 +1517,7 @@ 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((buffer->nitems + tup->nitems) * sizeof(*buffer->items)); else buffer->items = repalloc(buffer->items, (buffer->nitems + tup->nitems) * sizeof(ItemPointerData)); diff --git a/src/backend/access/gin/ginpostinglist.c b/src/backend/access/gin/ginpostinglist.c index 1bf061803da..99c2f03f779 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(nallocated * sizeof(*result)); ndecoded = 0; while ((char *) segment < endseg) diff --git a/src/backend/access/gin/ginscan.c b/src/backend/access/gin/ginscan.c index 2ca635909f9..032a6c0fa02 100644 --- a/src/backend/access/gin/ginscan.c +++ b/src/backend/access/gin/ginscan.c @@ -289,7 +289,7 @@ ginNewScanKey(IndexScanDesc scan) so->totalentries = 0; so->allocentries = 32; so->entries = (GinScanEntry *) - palloc(so->allocentries * sizeof(GinScanEntry)); + palloc(so->allocentries * sizeof(*so->entries)); so->isVoidRes = false; @@ -357,7 +357,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 = (GinNullCategory *) palloc0(nQueryValues * sizeof(*categories)); if (nullFlags) { int32 j; diff --git a/src/backend/access/gin/ginutil.c b/src/backend/access/gin/ginutil.c index 605f80aad39..60018006565 100644 --- a/src/backend/access/gin/ginutil.c +++ b/src/backend/access/gin/ginutil.c @@ -534,7 +534,7 @@ ginExtractEntries(GinState *ginstate, OffsetNumber attnum, * assuming that everything's non-null. */ if (nullFlags == NULL) - nullFlags = (bool *) palloc0(*nentries * sizeof(bool)); + nullFlags = (bool *) palloc0(*nentries * sizeof(*nullFlags)); /* * If there's more than one key, sort and unique-ify. @@ -596,7 +596,7 @@ ginExtractEntries(GinState *ginstate, OffsetNumber attnum, /* * Create GinNullCategory representation from nullFlags. */ - *categories = (GinNullCategory *) palloc0(*nentries * sizeof(GinNullCategory)); + *categories = (GinNullCategory *) palloc0(*nentries * sizeof(**categories)); for (i = 0; i < *nentries; i++) (*categories)[i] = (nullFlags[i] ? GIN_CAT_NULL_KEY : GIN_CAT_NORM_KEY); diff --git a/src/backend/access/gist/gistget.c b/src/backend/access/gist/gistget.c index 9ba45acfff3..c1ab8a83971 100644 --- a/src/backend/access/gist/gistget.c +++ b/src/backend/access/gist/gistget.c @@ -661,7 +661,7 @@ gistgettuple(IndexScanDesc scan, ScanDirection dir) so->killedItems = (OffsetNumber *) palloc(MaxIndexTuplesPerPage - * sizeof(OffsetNumber)); + * sizeof(*so->killedItems)); MemoryContextSwitchTo(oldCxt); } @@ -698,7 +698,7 @@ gistgettuple(IndexScanDesc scan, ScanDirection dir) so->killedItems = (OffsetNumber *) palloc(MaxIndexTuplesPerPage - * sizeof(OffsetNumber)); + * sizeof(*so->killedItems)); MemoryContextSwitchTo(oldCxt); } diff --git a/src/backend/access/gist/gistproc.c b/src/backend/access/gist/gistproc.c index 9ac06504be1..96ba21d22a9 100644 --- a/src/backend/access/gist/gistproc.c +++ b/src/backend/access/gist/gistproc.c @@ -515,8 +515,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 = (SplitInterval *) palloc(nentries * sizeof(*intervalsLower)); + intervalsUpper = (SplitInterval *) palloc(nentries * sizeof(*intervalsUpper)); /* * Calculate the overall minimum bounding box over all the entries. @@ -692,8 +692,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 = (OffsetNumber *) palloc(nentries * sizeof(*v->spl_left)); + v->spl_right = (OffsetNumber *) palloc(nentries * sizeof(*v->spl_right)); v->spl_nleft = 0; v->spl_nright = 0; @@ -706,7 +706,7 @@ gist_box_picksplit(PG_FUNCTION_ARGS) * either group without affecting overlap along selected axis. */ commonEntriesCount = 0; - commonEntries = (CommonEntry *) palloc(nentries * sizeof(CommonEntry)); + commonEntries = (CommonEntry *) palloc(nentries * sizeof(*commonEntries)); /* 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 01b8ff0b6fa..804d62847ff 100644 --- a/src/backend/access/gist/gistscan.c +++ b/src/backend/access/gist/gistscan.c @@ -228,7 +228,7 @@ gistrescan(IndexScanDesc scan, ScanKey key, int nkeys, */ if (!first_time) { - fn_extras = (void **) palloc(scan->numberOfKeys * sizeof(void *)); + fn_extras = (void **) palloc(scan->numberOfKeys * sizeof(*fn_extras)); for (i = 0; i < scan->numberOfKeys; i++) fn_extras[i] = scan->keyData[i].sk_func.fn_extra; } @@ -283,14 +283,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 = (void **) palloc(scan->numberOfOrderBys * sizeof(*fn_extras)); 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 = (Oid *) palloc(scan->numberOfOrderBys * sizeof(*so->orderByTypes)); /* * 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 21fea505d9c..95d3e8dc17d 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 = (OffsetNumber *) palloc(len * sizeof(*v->spl_left)); + v->spl_right = (OffsetNumber *) palloc(len * sizeof(*v->spl_right)); 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 = (OffsetNumber *) palloc(len * sizeof(*offNullTuples)); 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 = (OffsetNumber *) palloc(len * sizeof(*v->splitVector.spl_left)); 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 = (IndexTuple *) palloc(len * sizeof(*newitup)); + OffsetNumber *map = (OffsetNumber *) palloc(len * sizeof(*map)); int newlen = 0; GIST_SPLITVEC backupSplit; diff --git a/src/backend/access/gist/gistxlog.c b/src/backend/access/gist/gistxlog.c index 6484ca5e2ca..615eeb7ca7b 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(*n * sizeof(*tuples)); for (i = 0; i < *n; i++) { diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c index 225f9829f22..840e2c8392a 100644 --- a/src/backend/access/heap/heapam.c +++ b/src/backend/access/heap/heapam.c @@ -2399,7 +2399,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(ntuples * sizeof(*heaptuples)); for (i = 0; i < ntuples; i++) { HeapTuple tuple; @@ -8784,7 +8784,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(delstate->ndeltids * sizeof(*reordereddeltids)); 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 e8c99c3773d..2f01b6caaa0 100644 --- a/src/backend/access/heap/vacuumlazy.c +++ b/src/backend/access/heap/vacuumlazy.c @@ -763,7 +763,7 @@ heap_vacuum_rel(Relation rel, const VacuumParams params, vacrel->new_rel_tuples = 0; vacrel->new_live_tuples = 0; vacrel->indstats = (IndexBulkDeleteResult **) - palloc0(vacrel->nindexes * sizeof(IndexBulkDeleteResult *)); + palloc0(vacrel->nindexes * sizeof(*vacrel->indstats)); /* 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 031eb76ba8c..0f28d9e3680 100644 --- a/src/backend/access/nbtree/nbtinsert.c +++ b/src/backend/access/nbtree/nbtinsert.c @@ -2842,8 +2842,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(MaxTIDsPerBTreePage * sizeof(*delstate.deltids)); + delstate.status = palloc(MaxTIDsPerBTreePage * sizeof(*delstate.status)); for (offnum = minoff; offnum <= maxoff; diff --git a/src/backend/access/nbtree/nbtpreprocesskeys.c b/src/backend/access/nbtree/nbtpreprocesskeys.c index 5b251c5058d..d00b6c62316 100644 --- a/src/backend/access/nbtree/nbtpreprocesskeys.c +++ b/src/backend/access/nbtree/nbtpreprocesskeys.c @@ -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(so->numberOfKeys * sizeof(*unmarkikey)); nunmark = 0; /* Set things up for first key's attribute */ @@ -1659,8 +1659,8 @@ _bt_unmark_keys(IndexScanDesc scan, int *keyDataMap) nkept = 0; if (so->numArrayKeys) { - unmarkOrderProcs = palloc(nunmark * sizeof(FmgrInfo)); - keepOrderProcs = palloc((so->numberOfKeys - nunmark) * sizeof(FmgrInfo)); + unmarkOrderProcs = palloc(nunmark * sizeof(*unmarkOrderProcs)); + keepOrderProcs = palloc((so->numberOfKeys - nunmark) * sizeof(*keepOrderProcs)); } /* @@ -1893,10 +1893,10 @@ _bt_preprocess_array_keys(IndexScanDesc scan, int *new_numberOfKeys) arrayKeyData = (ScanKey) palloc(numArrayKeyData * sizeof(ScanKeyData)); /* Allocate space for per-array data in the workspace context */ - so->arrayKeys = (BTArrayKeyInfo *) palloc(numArrayKeys * sizeof(BTArrayKeyInfo)); + so->arrayKeys = (BTArrayKeyInfo *) palloc(numArrayKeys * sizeof(*so->arrayKeys)); /* Allocate space for ORDER procs used to help _bt_checkkeys */ - so->orderProcs = (FmgrInfo *) palloc(numArrayKeyData * sizeof(FmgrInfo)); + so->orderProcs = (FmgrInfo *) palloc(numArrayKeyData * sizeof(*so->orderProcs)); numArrayKeys = 0; numArrayKeyData = 0; diff --git a/src/backend/access/transam/multixact.c b/src/backend/access/transam/multixact.c index 8ba2f4529dc..25fd7e9e40a 100644 --- a/src/backend/access/transam/multixact.c +++ b/src/backend/access/transam/multixact.c @@ -1309,7 +1309,7 @@ GetMultiXactIdMembers(MultiXactId multi, MultiXactMember **members, length = nextMXOffset - offset; /* read the members */ - ptr = (MultiXactMember *) palloc(length * sizeof(MultiXactMember)); + ptr = (MultiXactMember *) palloc(length * sizeof(*ptr)); 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 ec4e3628bd5..3e492b807f0 100644 --- a/src/backend/access/transam/twophase.c +++ b/src/backend/access/transam/twophase.c @@ -2004,7 +2004,7 @@ PrescanPreparedTransactions(TransactionId **xids_p, int *nxids_p) if (nxids == 0) { allocsize = 10; - xids = palloc(allocsize * sizeof(TransactionId)); + xids = palloc(allocsize * sizeof(*xids)); } else { diff --git a/src/backend/access/transam/xact.c b/src/backend/access/transam/xact.c index b69d452551a..b7442939f8b 100644 --- a/src/backend/access/transam/xact.c +++ b/src/backend/access/transam/xact.c @@ -5599,7 +5599,7 @@ SerializeTransactionState(Size maxsize, char *start_address) <= maxsize); /* Copy them to our scratch space. */ - workspace = palloc(nxids * sizeof(TransactionId)); + workspace = palloc(nxids * sizeof(*workspace)); for (s = CurrentTransactionState; s != NULL; s = s->parent) { if (FullTransactionIdIsValid(s->fullTransactionId)) diff --git a/src/backend/backup/basebackup_incremental.c b/src/backend/backup/basebackup_incremental.c index 7678e4f6ec3..4c1656a5925 100644 --- a/src/backend/backup/basebackup_incremental.c +++ b/src/backend/backup/basebackup_incremental.c @@ -311,7 +311,7 @@ PrepareForIncrementalBackup(IncrementalBackupInfo *ib, * to the beginning. */ expectedTLEs = readTimeLineHistory(backup_state->starttli); - tlep = palloc0(num_wal_ranges * sizeof(TimeLineHistoryEntry *)); + tlep = palloc0(num_wal_ranges * sizeof(*tlep)); for (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 5b410ff14c9..51dad280fc7 100644 --- a/src/backend/catalog/aclchk.c +++ b/src/backend/catalog/aclchk.c @@ -1900,7 +1900,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 = (AclMode *) palloc0(num_col_privileges * sizeof(*col_privileges)); have_col_privileges = false; /* diff --git a/src/backend/catalog/dependency.c b/src/backend/catalog/dependency.c index 838ed26d6b9..a9767485bb4 100644 --- a/src/backend/catalog/dependency.c +++ b/src/backend/catalog/dependency.c @@ -2691,7 +2691,7 @@ 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)); + palloc(addrs->maxrefs * sizeof(*addrs->extras)); /* enlarge array if needed */ if (addrs->numrefs >= addrs->maxrefs) diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c index 265cc3e5fbf..509d610522c 100644 --- a/src/backend/catalog/heap.c +++ b/src/backend/catalog/heap.c @@ -2174,7 +2174,7 @@ StoreRelCheck(Relation rel, const char *ccname, Node *expr, ListCell *vl; int i = 0; - attNos = (int16 *) palloc(keycount * sizeof(int16)); + attNos = (int16 *) palloc(keycount * sizeof(*attNos)); foreach(vl, varList) { Var *var = (Var *) lfirst(vl); diff --git a/src/backend/catalog/namespace.c b/src/backend/catalog/namespace.c index c94089caa58..95e28f73920 100644 --- a/src/backend/catalog/namespace.c +++ b/src/backend/catalog/namespace.c @@ -1648,7 +1648,7 @@ MatchNamedCall(HeapTuple proctup, int nargs, List *argnames, Assert(include_out_arguments ? (pronargs == pronallargs) : (pronargs <= pronallargs)); /* initialize state for matching */ - *argnumbers = (int *) palloc(pronargs * sizeof(int)); + *argnumbers = (int *) palloc(pronargs * sizeof(**argnumbers)); memset(arggiven, false, pronargs * sizeof(bool)); /* there are numposargs positional args before the named args */ diff --git a/src/backend/catalog/pg_constraint.c b/src/backend/catalog/pg_constraint.c index 43b4507d86e..59c4392ec12 100644 --- a/src/backend/catalog/pg_constraint.c +++ b/src/backend/catalog/pg_constraint.c @@ -118,7 +118,7 @@ CreateConstraintEntry(const char *constraintName, { Datum *conkey; - conkey = (Datum *) palloc(constraintNKeys * sizeof(Datum)); + conkey = (Datum *) palloc(constraintNKeys * sizeof(*conkey)); for (i = 0; i < constraintNKeys; i++) conkey[i] = Int16GetDatum(constraintKey[i]); conkeyArray = construct_array_builtin(conkey, constraintNKeys, INT2OID); @@ -131,7 +131,7 @@ CreateConstraintEntry(const char *constraintName, Datum *fkdatums; int nkeys = Max(foreignNKeys, numFkDeleteSetCols); - fkdatums = (Datum *) palloc(nkeys * sizeof(Datum)); + fkdatums = (Datum *) palloc(nkeys * sizeof(*fkdatums)); for (i = 0; i < foreignNKeys; i++) fkdatums[i] = Int16GetDatum(foreignKey[i]); confkeyArray = construct_array_builtin(fkdatums, foreignNKeys, INT2OID); @@ -167,7 +167,7 @@ CreateConstraintEntry(const char *constraintName, { Datum *opdatums; - opdatums = (Datum *) palloc(constraintNKeys * sizeof(Datum)); + opdatums = (Datum *) palloc(constraintNKeys * sizeof(*opdatums)); 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 929bb53b620..63f9e5c2a6d 100644 --- a/src/backend/catalog/pg_inherits.c +++ b/src/backend/catalog/pg_inherits.c @@ -105,7 +105,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 = (Oid *) palloc(maxoids * sizeof(*oidarr)); numoids = 0; relation = table_open(InheritsRelationId, AccessShareLock); diff --git a/src/backend/catalog/pg_shdepend.c b/src/backend/catalog/pg_shdepend.c index fe4e4536676..25dfab1f4b7 100644 --- a/src/backend/catalog/pg_shdepend.c +++ b/src/backend/catalog/pg_shdepend.c @@ -717,7 +717,7 @@ checkSharedDependencies(Oid classId, Oid objectId, allocedobjects = 128; /* arbitrary initial array size */ objects = (ShDependObjectInfo *) - palloc(allocedobjects * sizeof(ShDependObjectInfo)); + palloc(allocedobjects * sizeof(*objects)); numobjects = 0; initStringInfo(&descs); initStringInfo(&alldescs); diff --git a/src/backend/commands/alter.c b/src/backend/commands/alter.c index cb75e11fced..2aa1940fdd9 100644 --- a/src/backend/commands/alter.c +++ b/src/backend/commands/alter.c @@ -324,9 +324,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(RelationGetNumberOfAttributes(rel) * sizeof(*values)); + nulls = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(*nulls)); + replaces = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(*replaces)); namestrcpy(&nameattrdata, new_name); values[Anum_name - 1] = NameGetDatum(&nameattrdata); replaces[Anum_name - 1] = true; @@ -802,9 +802,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(RelationGetNumberOfAttributes(rel) * sizeof(*values)); + nulls = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(*nulls)); + replaces = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(*replaces)); values[Anum_namespace - 1] = ObjectIdGetDatum(nspOid); replaces[Anum_namespace - 1] = true; newtup = heap_modify_tuple(tup, RelationGetDescr(rel), @@ -1012,9 +1012,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(nattrs * sizeof(*values)); + nulls = palloc0(nattrs * sizeof(*nulls)); + replaces = palloc0(nattrs * sizeof(*replaces)); 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 5e2a7a8234e..ca1bf9b6557 100644 --- a/src/backend/commands/analyze.c +++ b/src/backend/commands/analyze.c @@ -380,7 +380,7 @@ do_analyze_rel(Relation onerel, const VacuumParams params, ListCell *le; vacattrstats = (VacAttrStats **) palloc(list_length(va_cols) * - sizeof(VacAttrStats *)); + sizeof(*vacattrstats)); tcnt = 0; foreach(le, va_cols) { @@ -409,7 +409,7 @@ do_analyze_rel(Relation onerel, const VacuumParams params, { attr_cnt = onerel->rd_att->natts; vacattrstats = (VacAttrStats **) - palloc(attr_cnt * sizeof(VacAttrStats *)); + palloc(attr_cnt * sizeof(*vacattrstats)); tcnt = 0; for (i = 1; i <= attr_cnt; i++) { @@ -452,7 +452,7 @@ do_analyze_rel(Relation onerel, const VacuumParams params, indexdata = NULL; if (nindexes > 0) { - indexdata = (AnlIndexData *) palloc0(nindexes * sizeof(AnlIndexData)); + indexdata = (AnlIndexData *) palloc0(nindexes * sizeof(*indexdata)); for (ind = 0; ind < nindexes; ind++) { AnlIndexData *thisdata = &indexdata[ind]; @@ -465,7 +465,7 @@ 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 *)); + palloc(indexInfo->ii_NumIndexAttrs * sizeof(*thisdata->vacattrstats)); tcnt = 0; for (i = 0; i < indexInfo->ii_NumIndexAttrs; i++) { @@ -528,7 +528,7 @@ do_analyze_rel(Relation onerel, const VacuumParams params, /* * Acquire the sample rows */ - rows = (HeapTuple *) palloc(targrows * sizeof(HeapTuple)); + rows = (HeapTuple *) palloc(targrows * sizeof(*rows)); pgstat_progress_update_param(PROGRESS_ANALYZE_PHASE, inh ? PROGRESS_ANALYZE_PHASE_ACQUIRE_SAMPLE_ROWS_INH : PROGRESS_ANALYZE_PHASE_ACQUIRE_SAMPLE_ROWS); @@ -923,8 +923,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 = (Datum *) palloc(numrows * attr_cnt * sizeof(*exprvals)); + exprnulls = (bool *) palloc(numrows * attr_cnt * sizeof(*exprnulls)); numindexrows = 0; tcnt = 0; for (rowno = 0; rowno < numrows; rowno++) @@ -1443,10 +1443,10 @@ 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)); + rels = (Relation *) palloc(list_length(tableOIDs) * sizeof(*rels)); acquirefuncs = (AcquireSampleRowsFunc *) - palloc(list_length(tableOIDs) * sizeof(AcquireSampleRowsFunc)); - relblocks = (double *) palloc(list_length(tableOIDs) * sizeof(double)); + palloc(list_length(tableOIDs) * sizeof(*acquirefuncs)); + relblocks = (double *) palloc(list_length(tableOIDs) * sizeof(*relblocks)); totalblocks = 0; nrels = 0; has_child = false; @@ -1721,7 +1721,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 = (Datum *) palloc(nnum * sizeof(*numdatums)); ArrayType *arry; for (n = 0; n < nnum; n++) @@ -2093,7 +2093,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 = (TrackItem *) palloc(track_max * sizeof(*track)); track_cnt = 0; fmgr_info(mystats->eqfunc, &f_cmpeq); @@ -2330,7 +2330,7 @@ compute_distinct_stats(VacAttrStatsP stats, if (num_mcv > 0) { - mcv_counts = (int *) palloc(num_mcv * sizeof(int)); + mcv_counts = (int *) palloc(num_mcv * sizeof(*mcv_counts)); for (i = 0; i < num_mcv; i++) mcv_counts[i] = track[i].count; @@ -2350,8 +2350,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 = (Datum *) palloc(num_mcv * sizeof(*mcv_values)); + mcv_freqs = (float4 *) palloc(num_mcv * sizeof(*mcv_freqs)); for (i = 0; i < num_mcv; i++) { mcv_values[i] = datumCopy(track[i].value, @@ -2429,9 +2429,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 = (ScalarItem *) palloc(samplerows * sizeof(*values)); + tupnoLink = (int *) palloc(samplerows * sizeof(*tupnoLink)); + track = (ScalarMCVItem *) palloc(num_mcv * sizeof(*track)); memset(&ssup, 0, sizeof(ssup)); ssup.ssup_cxt = CurrentMemoryContext; @@ -2695,7 +2695,7 @@ compute_scalar_stats(VacAttrStatsP stats, if (num_mcv > 0) { - mcv_counts = (int *) palloc(num_mcv * sizeof(int)); + mcv_counts = (int *) palloc(num_mcv * sizeof(*mcv_counts)); for (i = 0; i < num_mcv; i++) mcv_counts[i] = track[i].count; @@ -2715,8 +2715,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 = (Datum *) palloc(num_mcv * sizeof(*mcv_values)); + mcv_freqs = (float4 *) palloc(num_mcv * sizeof(*mcv_freqs)); for (i = 0; i < num_mcv; i++) { mcv_values[i] = datumCopy(values[track[i].first].value, @@ -2810,7 +2810,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 = (Datum *) palloc(num_hist * sizeof(*hist_values)); /* * 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 eb86402cae4..b37d3789bd8 100644 --- a/src/backend/commands/async.c +++ b/src/backend/commands/async.c @@ -1592,8 +1592,8 @@ SignalBackends(void) * XXX in principle these pallocs could fail, which would be bad. Maybe * preallocate the arrays? They're not that large, though. */ - pids = (int32 *) palloc(MaxBackends * sizeof(int32)); - procnos = (ProcNumber *) palloc(MaxBackends * sizeof(ProcNumber)); + pids = (int32 *) palloc(MaxBackends * sizeof(*pids)); + procnos = (ProcNumber *) palloc(MaxBackends * sizeof(*procnos)); count = 0; LWLockAcquire(NotifyQueueLock, LW_EXCLUSIVE); diff --git a/src/backend/commands/collationcmds.c b/src/backend/commands/collationcmds.c index 8acbfbbeda0..333c6d99180 100644 --- a/src/backend/commands/collationcmds.c +++ b/src/backend/commands/collationcmds.c @@ -862,7 +862,7 @@ pg_import_system_collations(PG_FUNCTION_ARGS) /* expansible array of aliases */ maxaliases = 100; - aliases = (CollAliasData *) palloc(maxaliases * sizeof(CollAliasData)); + aliases = (CollAliasData *) palloc(maxaliases * sizeof(*aliases)); naliases = 0; locale_a_handle = OpenPipeStream("locale -a", "r"); diff --git a/src/backend/commands/copyfrom.c b/src/backend/commands/copyfrom.c index 2ae3d2ba86e..dbd2b537422 100644 --- a/src/backend/commands/copyfrom.c +++ b/src/backend/commands/copyfrom.c @@ -192,7 +192,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 = (char **) palloc(attr_count * sizeof(*cstate->raw_fields)); } /* @@ -1589,7 +1589,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 = (bool *) palloc0(num_phys_attrs * sizeof(*cstate->opts.force_notnull_flags)); if (cstate->opts.force_notnull_all) MemSet(cstate->opts.force_notnull_flags, true, num_phys_attrs * sizeof(bool)); else if (cstate->opts.force_notnull) @@ -1632,7 +1632,7 @@ BeginCopyFrom(ParseState *pstate, cstate->escontext = NULL; /* 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 = (bool *) palloc0(num_phys_attrs * sizeof(*cstate->opts.force_null_flags)); if (cstate->opts.force_null_all) MemSet(cstate->opts.force_null_flags, true, num_phys_attrs * sizeof(bool)); else if (cstate->opts.force_null) @@ -1663,7 +1663,7 @@ BeginCopyFrom(ParseState *pstate, List *attnums; ListCell *cur; - cstate->convert_select_flags = (bool *) palloc0(num_phys_attrs * sizeof(bool)); + cstate->convert_select_flags = (bool *) palloc0(num_phys_attrs * sizeof(*cstate->convert_select_flags)); attnums = CopyGetAttnums(tupDesc, cstate->rel, cstate->opts.convert_select); @@ -1749,10 +1749,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 = (FmgrInfo *) palloc(num_phys_attrs * sizeof(*in_functions)); + typioparams = (Oid *) palloc(num_phys_attrs * sizeof(*typioparams)); + defmap = (int *) palloc(num_phys_attrs * sizeof(*defmap)); + defexprs = (ExprState **) palloc(num_phys_attrs * sizeof(*defexprs)); for (int attnum = 1; attnum <= num_phys_attrs; attnum++) { @@ -1818,7 +1818,7 @@ BeginCopyFrom(ParseState *pstate, } } - cstate->defaults = (bool *) palloc0(tupDesc->natts * sizeof(bool)); + cstate->defaults = (bool *) palloc0(tupDesc->natts * sizeof(*cstate->defaults)); /* initialize progress */ pgstat_progress_start_command(PROGRESS_COMMAND_COPY, diff --git a/src/backend/commands/copyto.c b/src/backend/commands/copyto.c index dae91630ac3..a5597dd22f4 100644 --- a/src/backend/commands/copyto.c +++ b/src/backend/commands/copyto.c @@ -891,7 +891,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 = (bool *) palloc0(num_phys_attrs * sizeof(*cstate->opts.force_quote_flags)); if (cstate->opts.force_quote_all) { MemSet(cstate->opts.force_quote_flags, true, num_phys_attrs * sizeof(bool)); @@ -1081,7 +1081,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 = (FmgrInfo *) palloc(num_phys_attrs * sizeof(*cstate->out_functions)); foreach(cur, cstate->attnumlist) { int attnum = lfirst_int(cur); diff --git a/src/backend/commands/dbcommands.c b/src/backend/commands/dbcommands.c index d1f3be89b35..1794b3b0d67 100644 --- a/src/backend/commands/dbcommands.c +++ b/src/backend/commands/dbcommands.c @@ -3052,7 +3052,7 @@ remove_dbtablespaces(Oid db_id) return; } - tablespace_ids = (Oid *) palloc(ntblspc * sizeof(Oid)); + tablespace_ids = (Oid *) palloc(ntblspc * sizeof(*tablespace_ids)); 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 5a6390631eb..ca1d5db1f5d 100644 --- a/src/backend/commands/explain.c +++ b/src/backend/commands/explain.c @@ -4982,10 +4982,10 @@ ExplainCreateWorkersState(int num_workers) wstate = palloc_object(ExplainWorkersState); wstate->num_workers = num_workers; - wstate->worker_inited = (bool *) palloc0(num_workers * sizeof(bool)); + wstate->worker_inited = (bool *) palloc0(num_workers * sizeof(*wstate->worker_inited)); wstate->worker_str = (StringInfoData *) - palloc0(num_workers * sizeof(StringInfoData)); - wstate->worker_state_save = (int *) palloc(num_workers * sizeof(int)); + palloc0(num_workers * sizeof(*wstate->worker_str)); + wstate->worker_state_save = (int *) palloc(num_workers * sizeof(*wstate->worker_state_save)); return wstate; } diff --git a/src/backend/commands/explain_dr.c b/src/backend/commands/explain_dr.c index 5833aa80fb5..78f6dbb20ba 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 = (FmgrInfo *) palloc0(nattrs * sizeof(*receiver->finfos)); for (int i = 0; i < nattrs; i++) { diff --git a/src/backend/commands/explain_state.c b/src/backend/commands/explain_state.c index a6623f8fa52..7261c960d05 100644 --- a/src/backend/commands/explain_state.c +++ b/src/backend/commands/explain_state.c @@ -285,7 +285,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 *)); + palloc0(es->extension_state_allocated * sizeof(*es->extension_state)); } /* If there's an array but it's currently full, expand it. */ diff --git a/src/backend/commands/extension.c b/src/backend/commands/extension.c index c43b74e319e..97dfe551064 100644 --- a/src/backend/commands/extension.c +++ b/src/backend/commands/extension.c @@ -2557,7 +2557,7 @@ convert_requires_to_datum(List *requires) ListCell *lc; ndatums = list_length(requires); - datums = (Datum *) palloc(ndatums * sizeof(Datum)); + datums = (Datum *) palloc(ndatums * sizeof(*datums)); ndatums = 0; foreach(lc, requires) { diff --git a/src/backend/commands/functioncmds.c b/src/backend/commands/functioncmds.c index 8a435cd93db..41f4ade0e1b 100644 --- a/src/backend/commands/functioncmds.c +++ b/src/backend/commands/functioncmds.c @@ -212,10 +212,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 = (Oid *) palloc(parameterCount * sizeof(*inTypes)); + allTypes = (Datum *) palloc(parameterCount * sizeof(*allTypes)); + paramModes = (Datum *) palloc(parameterCount * sizeof(*paramModes)); + paramNames = (Datum *) palloc0(parameterCount * sizeof(*paramNames)); *parameterDefaults = NIL; /* Scan the list and extract data into work arrays */ @@ -917,8 +917,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 = (Oid *) palloc(pinfo->nargs * sizeof(*pinfo->argtypes)); + pinfo->argnames = (char **) palloc(pinfo->nargs * sizeof(*pinfo->argnames)); for (int i = 0; i < list_length(parameterTypes); i++) { char *s = strVal(list_nth(inParameterNames, i)); @@ -1226,7 +1226,7 @@ CreateFunction(ParseState *pstate, CreateFunctionStmt *stmt) Datum *arr; int i; - arr = palloc(list_length(trftypes_list) * sizeof(Datum)); + arr = palloc(list_length(trftypes_list) * sizeof(*arr)); 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 5bd5f8c9968..f55c915545c 100644 --- a/src/backend/commands/policy.c +++ b/src/backend/commands/policy.c @@ -151,7 +151,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 = (Datum *) palloc(*num_roles * sizeof(*role_oids)); foreach(cell, roles) { diff --git a/src/backend/commands/subscriptioncmds.c b/src/backend/commands/subscriptioncmds.c index abbcaff0838..12e6130d87b 100644 --- a/src/backend/commands/subscriptioncmds.c +++ b/src/backend/commands/subscriptioncmds.c @@ -975,8 +975,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(subrel_count * sizeof(*subrel_local_oids)); + subseq_local_oids = palloc(subrel_count * sizeof(*subseq_local_oids)); foreach(lc, subrel_states) { SubscriptionRelState *relstate = (SubscriptionRelState *) lfirst(lc); @@ -1008,7 +1008,7 @@ AlterSubscription_refresh(Subscription *sub, bool copy_data, * step. */ off = 0; - pubrel_local_oids = palloc(list_length(pubrels) * sizeof(Oid)); + pubrel_local_oids = palloc(list_length(pubrels) * sizeof(*pubrel_local_oids)); foreach_ptr(PublicationRelKind, pubrelinfo, pubrels) { diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c index 1c9ef53be20..94669e72329 100644 --- a/src/backend/commands/tablecmds.c +++ b/src/backend/commands/tablecmds.c @@ -2090,7 +2090,7 @@ ExecuteTruncateGuts(List *explicit_rels, */ estate = CreateExecutorState(); resultRelInfos = (ResultRelInfo *) - palloc(list_length(rels) * sizeof(ResultRelInfo)); + palloc(list_length(rels) * sizeof(*resultRelInfos)); resultRelInfo = resultRelInfos; foreach(cell, rels) { @@ -2297,7 +2297,7 @@ ExecuteTruncateGuts(List *explicit_rels, /* should only get here if wal_level >= logical */ Assert(XLogLogicalInfoActive()); - logrelids = palloc(list_length(relids_logged) * sizeof(Oid)); + logrelids = palloc(list_length(relids_logged) * sizeof(*logrelids)); foreach(cell, relids_logged) logrelids[i++] = lfirst_oid(cell); diff --git a/src/backend/commands/tablespace.c b/src/backend/commands/tablespace.c index df31eace47a..77d81098162 100644 --- a/src/backend/commands/tablespace.c +++ b/src/backend/commands/tablespace.c @@ -1227,7 +1227,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 = (Oid *) palloc(list_length(namelist) * sizeof(*tblSpcs)); numSpcs = 0; foreach(l, namelist) { diff --git a/src/backend/commands/trigger.c b/src/backend/commands/trigger.c index 12c97f2c023..35868e10e31 100644 --- a/src/backend/commands/trigger.c +++ b/src/backend/commands/trigger.c @@ -932,7 +932,7 @@ CreateTriggerFiringOn(CreateTrigStmt *stmt, const char *queryString, ListCell *cell; int i = 0; - columns = (int16 *) palloc(ncolumns * sizeof(int16)); + columns = (int16 *) palloc(ncolumns * sizeof(*columns)); foreach(cell, stmt->columns) { char *name = strVal(lfirst(cell)); @@ -1876,7 +1876,7 @@ RelationBuildTriggers(Relation relation) * necessary) */ maxtrigs = 16; - triggers = (Trigger *) palloc(maxtrigs * sizeof(Trigger)); + triggers = (Trigger *) palloc(maxtrigs * sizeof(*triggers)); numtrigs = 0; /* @@ -1926,7 +1926,7 @@ RelationBuildTriggers(Relation relation) build->tgnattr = pg_trigger->tgattr.dim1; if (build->tgnattr > 0) { - build->tgattr = (int16 *) palloc(build->tgnattr * sizeof(int16)); + build->tgattr = (int16 *) palloc(build->tgnattr * sizeof(*build->tgattr)); memcpy(build->tgattr, &(pg_trigger->tgattr.values), build->tgnattr * sizeof(int16)); } @@ -1944,7 +1944,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 = (char **) palloc(build->tgnargs * sizeof(*build->tgargs)); for (i = 0; i < build->tgnargs; i++) { build->tgargs[i] = pstrdup(p); @@ -2099,7 +2099,7 @@ CopyTriggerDesc(TriggerDesc *trigdesc) newdesc = palloc_object(TriggerDesc); memcpy(newdesc, trigdesc, sizeof(TriggerDesc)); - trigger = (Trigger *) palloc(trigdesc->numtriggers * sizeof(Trigger)); + trigger = (Trigger *) palloc(trigdesc->numtriggers * sizeof(*trigger)); memcpy(trigger, trigdesc->triggers, trigdesc->numtriggers * sizeof(Trigger)); newdesc->triggers = trigger; @@ -2111,7 +2111,7 @@ CopyTriggerDesc(TriggerDesc *trigdesc) { int16 *newattr; - newattr = (int16 *) palloc(trigger->tgnattr * sizeof(int16)); + newattr = (int16 *) palloc(trigger->tgnattr * sizeof(*newattr)); memcpy(newattr, trigger->tgattr, trigger->tgnattr * sizeof(int16)); trigger->tgattr = newattr; @@ -2121,7 +2121,7 @@ CopyTriggerDesc(TriggerDesc *trigdesc) char **newargs; int16 j; - newargs = (char **) palloc(trigger->tgnargs * sizeof(char *)); + newargs = (char **) palloc(trigger->tgnargs * sizeof(*newargs)); for (j = 0; j < trigger->tgnargs; j++) newargs[j] = pstrdup(trigger->tgargs[j]); trigger->tgargs = newargs; diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c index 0528d1b6ecb..d70afb71c9c 100644 --- a/src/backend/commands/vacuum.c +++ b/src/backend/commands/vacuum.c @@ -2374,7 +2374,7 @@ vac_open_indexes(Relation relation, LOCKMODE lockmode, i = list_length(indexoidlist); if (i > 0) - *Irel = (Relation *) palloc(i * sizeof(Relation)); + *Irel = (Relation *) palloc(i * sizeof(**Irel)); else *Irel = NULL; diff --git a/src/backend/executor/execExprInterp.c b/src/backend/executor/execExprInterp.c index 5e7bd933afc..9f77179e86e 100644 --- a/src/backend/executor/execExprInterp.c +++ b/src/backend/executor/execExprInterp.c @@ -3447,10 +3447,10 @@ ExecEvalArrayExpr(ExprState *state, ExprEvalStep *op) char *dat; int iitem; - subdata = (char **) palloc(nelems * sizeof(char *)); - subbitmaps = (bits8 **) palloc(nelems * sizeof(bits8 *)); - subbytes = (int *) palloc(nelems * sizeof(int)); - subnitems = (int *) palloc(nelems * sizeof(int)); + subdata = (char **) palloc(nelems * sizeof(*subdata)); + subbitmaps = (bits8 **) palloc(nelems * sizeof(*subbitmaps)); + subbytes = (int *) palloc(nelems * sizeof(*subbytes)); + subnitems = (int *) palloc(nelems * sizeof(*subnitems)); /* loop through and get data area from each element */ for (int elemoff = 0; elemoff < nelems; elemoff++) @@ -3501,9 +3501,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 = (int *) palloc(elem_ndims * sizeof(*elem_dims)); memcpy(elem_dims, ARR_DIMS(array), elem_ndims * sizeof(int)); - elem_lbs = (int *) palloc(elem_ndims * sizeof(int)); + elem_lbs = (int *) palloc(elem_ndims * sizeof(*elem_lbs)); 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 8eb4c25e1cb..1f98f53b669 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 = (Oid *) palloc(numCols * sizeof(*eqFunctions)); /* 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 = (Oid *) palloc(numCols * sizeof(**eqFuncOids)); + *hashFunctions = (FmgrInfo *) palloc(numCols * sizeof(**hashFunctions)); for (i = 0; i < numCols; i++) { diff --git a/src/backend/executor/execJunk.c b/src/backend/executor/execJunk.c index 3f196de1ad2..cd1d6a84587 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 = (AttrNumber *) palloc(cleanLength * sizeof(*cleanMap)); 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 = (AttrNumber *) palloc0(cleanLength * sizeof(*cleanMap)); 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 26200c5a3d6..67f7924508c 100644 --- a/src/backend/executor/execParallel.c +++ b/src/backend/executor/execParallel.c @@ -568,7 +568,7 @@ ExecParallelSetupTupleQueues(ParallelContext *pcxt, bool reinitialize) /* Allocate memory for shared memory queue handles. */ responseq = (shm_mq_handle **) - palloc(pcxt->nworkers * sizeof(shm_mq_handle *)); + palloc(pcxt->nworkers * sizeof(*responseq)); /* * If not reinitializing, allocate space from the DSM for the queues; diff --git a/src/backend/executor/execSRF.c b/src/backend/executor/execSRF.c index a03fe780a02..8b0b8fd0264 100644 --- a/src/backend/executor/execSRF.c +++ b/src/backend/executor/execSRF.c @@ -337,7 +337,7 @@ ExecMakeTableFunctionResult(SetExprState *setexpr, int natts = expectedDesc->natts; bool *nullflags; - nullflags = (bool *) palloc(natts * sizeof(bool)); + nullflags = (bool *) palloc(natts * sizeof(*nullflags)); memset(nullflags, true, natts * sizeof(bool)); tuplestore_putvalues(tupstore, expectedDesc, NULL, nullflags); } @@ -405,7 +405,7 @@ no_function_result: int natts = expectedDesc->natts; bool *nullflags; - nullflags = (bool *) palloc(natts * sizeof(bool)); + nullflags = (bool *) palloc(natts * sizeof(*nullflags)); 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 b0dc2cfa66f..d8e86d3735a 100644 --- a/src/backend/executor/execTuples.c +++ b/src/backend/executor/execTuples.c @@ -2291,9 +2291,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 = (FmgrInfo *) palloc0(natts * sizeof(*attinfuncinfo)); + attioparams = (Oid *) palloc0(natts * sizeof(*attioparams)); + atttypmods = (int32 *) palloc0(natts * sizeof(*atttypmods)); for (i = 0; i < natts; i++) { @@ -2330,8 +2330,8 @@ BuildTupleFromCStrings(AttInMetadata *attinmeta, char **values) int i; HeapTuple tuple; - dvalues = (Datum *) palloc(natts * sizeof(Datum)); - nulls = (bool *) palloc(natts * sizeof(bool)); + dvalues = (Datum *) palloc(natts * sizeof(*dvalues)); + nulls = (bool *) palloc(natts * sizeof(*nulls)); /* * 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 fdc65c2b42b..9489bb73882 100644 --- a/src/backend/executor/execUtils.c +++ b/src/backend/executor/execUtils.c @@ -797,7 +797,7 @@ ExecInitRangeTable(EState *estate, List *rangeTable, List *permInfos, * and stored here as needed. */ estate->es_relations = (Relation *) - palloc0(estate->es_range_table_size * sizeof(Relation)); + palloc0(estate->es_range_table_size * sizeof(*estate->es_relations)); /* * es_result_relations and es_rowmarks are also parallel to @@ -891,7 +891,7 @@ ExecInitResultRelation(EState *estate, ResultRelInfo *resultRelInfo, if (estate->es_result_relations == NULL) estate->es_result_relations = (ResultRelInfo **) - palloc0(estate->es_range_table_size * sizeof(ResultRelInfo *)); + palloc0(estate->es_range_table_size * sizeof(*estate->es_result_relations)); estate->es_result_relations[rti - 1] = resultRelInfo; /* diff --git a/src/backend/executor/functions.c b/src/backend/executor/functions.c index d9cc723daa0..53d1fcfabdb 100644 --- a/src/backend/executor/functions.c +++ b/src/backend/executor/functions.c @@ -274,7 +274,7 @@ prepare_sql_fn_parse_info(HeapTuple procedureTuple, Oid *argOidVect; int argnum; - argOidVect = (Oid *) palloc(nargs * sizeof(Oid)); + argOidVect = (Oid *) palloc(nargs * sizeof(*argOidVect)); memcpy(argOidVect, procedureStruct->proargtypes.values, nargs * sizeof(Oid)); diff --git a/src/backend/executor/instrument.c b/src/backend/executor/instrument.c index 9e11c662a7c..e9eddf7448c 100644 --- a/src/backend/executor/instrument.c +++ b/src/backend/executor/instrument.c @@ -33,7 +33,7 @@ InstrAlloc(int n, int instrument_options, bool async_mode) Instrumentation *instr; /* initialize all fields to zeroes, then modify as needed */ - instr = palloc0(n * sizeof(Instrumentation)); + instr = palloc0(n * sizeof(*instr)); if (instrument_options & (INSTRUMENT_BUFFERS | INSTRUMENT_TIMER | INSTRUMENT_WAL)) { bool need_buffers = (instrument_options & INSTRUMENT_BUFFERS) != 0; diff --git a/src/backend/executor/nodeAgg.c b/src/backend/executor/nodeAgg.c index a18556f62ec..f3a02a14a6d 100644 --- a/src/backend/executor/nodeAgg.c +++ b/src/backend/executor/nodeAgg.c @@ -1632,9 +1632,9 @@ find_hash_columns(AggState *aggstate) maxCols = bms_num_members(colnos) + perhash->numCols; perhash->hashGrpColIdxInput = - palloc(maxCols * sizeof(AttrNumber)); + palloc(maxCols * sizeof(*perhash->hashGrpColIdxInput)); perhash->hashGrpColIdxHash = - palloc(perhash->numCols * sizeof(AttrNumber)); + palloc(perhash->numCols * sizeof(*perhash->hashGrpColIdxHash)); /* Add all the grouping columns to colnos */ for (i = 0; i < perhash->numCols; i++) @@ -3558,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(num_sets * sizeof(*phasedata->gset_lengths)); + phasedata->grouped_cols = palloc(num_sets * sizeof(*phasedata->grouped_cols)); i = 0; foreach(l, aggnode->groupingSets) @@ -4317,13 +4317,13 @@ build_pertrans_for_aggref(AggStatePerTrans pertrans, /* Extract the sort information for use later */ pertrans->sortColIdx = - (AttrNumber *) palloc(numSortCols * sizeof(AttrNumber)); + (AttrNumber *) palloc(numSortCols * sizeof(*pertrans->sortColIdx)); pertrans->sortOperators = - (Oid *) palloc(numSortCols * sizeof(Oid)); + (Oid *) palloc(numSortCols * sizeof(*pertrans->sortOperators)); pertrans->sortCollations = - (Oid *) palloc(numSortCols * sizeof(Oid)); + (Oid *) palloc(numSortCols * sizeof(*pertrans->sortCollations)); pertrans->sortNullsFirst = - (bool *) palloc(numSortCols * sizeof(bool)); + (bool *) palloc(numSortCols * sizeof(*pertrans->sortNullsFirst)); i = 0; foreach(lc, sortlist) @@ -4350,7 +4350,7 @@ build_pertrans_for_aggref(AggStatePerTrans pertrans, Assert(numArguments > 0); Assert(list_length(aggref->aggdistinct) == numDistinctCols); - ops = palloc(numDistinctCols * sizeof(Oid)); + ops = palloc(numDistinctCols * sizeof(*ops)); i = 0; foreach(lc, aggref->aggdistinct) diff --git a/src/backend/executor/nodeAppend.c b/src/backend/executor/nodeAppend.c index 77c4dd9e4b1..e071a9a93b6 100644 --- a/src/backend/executor/nodeAppend.c +++ b/src/backend/executor/nodeAppend.c @@ -179,7 +179,7 @@ ExecInitAppend(Append *node, EState *estate, int eflags) } appendplanstates = (PlanState **) palloc(nplans * - sizeof(PlanState *)); + sizeof(*appendplanstates)); /* * call ExecInitNode on each of the valid plans to be executed and save @@ -256,7 +256,7 @@ ExecInitAppend(Append *node, EState *estate, int eflags) if (nasyncplans > 0) { appendstate->as_asyncrequests = (AsyncRequest **) - palloc0(nplans * sizeof(AsyncRequest *)); + palloc0(nplans * sizeof(*appendstate->as_asyncrequests)); i = -1; while ((i = bms_next_member(asyncplans, i)) >= 0) @@ -275,7 +275,7 @@ ExecInitAppend(Append *node, EState *estate, int eflags) } appendstate->as_asyncresults = (TupleTableSlot **) - palloc0(nasyncplans * sizeof(TupleTableSlot *)); + palloc0(nasyncplans * sizeof(*appendstate->as_asyncresults)); 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 939907b6fcd..c28d402b7cf 100644 --- a/src/backend/executor/nodeBitmapAnd.c +++ b/src/backend/executor/nodeBitmapAnd.c @@ -69,7 +69,7 @@ ExecInitBitmapAnd(BitmapAnd *node, EState *estate, int eflags) */ nplans = list_length(node->bitmapplans); - bitmapplanstates = (PlanState **) palloc0(nplans * sizeof(PlanState *)); + bitmapplanstates = (PlanState **) palloc0(nplans * sizeof(*bitmapplanstates)); /* * create new BitmapAndState for our BitmapAnd node diff --git a/src/backend/executor/nodeBitmapOr.c b/src/backend/executor/nodeBitmapOr.c index 231760ec93d..bff717aaa64 100644 --- a/src/backend/executor/nodeBitmapOr.c +++ b/src/backend/executor/nodeBitmapOr.c @@ -70,7 +70,7 @@ ExecInitBitmapOr(BitmapOr *node, EState *estate, int eflags) */ nplans = list_length(node->bitmapplans); - bitmapplanstates = (PlanState **) palloc0(nplans * sizeof(PlanState *)); + bitmapplanstates = (PlanState **) palloc0(nplans * sizeof(*bitmapplanstates)); /* * create new BitmapOrState for our BitmapOr node diff --git a/src/backend/executor/nodeGatherMerge.c b/src/backend/executor/nodeGatherMerge.c index c04522fea4d..754a6abf959 100644 --- a/src/backend/executor/nodeGatherMerge.c +++ b/src/backend/executor/nodeGatherMerge.c @@ -408,7 +408,7 @@ gather_merge_setup(GatherMergeState *gm_state) * case the extra array entries go unused. */ gm_state->gm_slots = (TupleTableSlot **) - palloc0((nreaders + 1) * sizeof(TupleTableSlot *)); + palloc0((nreaders + 1) * sizeof(*gm_state->gm_slots)); /* Allocate the tuple slot and tuple array for each worker */ gm_state->gm_tuple_buffers = (GMReaderTupleBuffer *) diff --git a/src/backend/executor/nodeIncrementalSort.c b/src/backend/executor/nodeIncrementalSort.c index 975b0397e7a..6117b979d39 100644 --- a/src/backend/executor/nodeIncrementalSort.c +++ b/src/backend/executor/nodeIncrementalSort.c @@ -167,7 +167,7 @@ preparePresortedCols(IncrementalSortState *node) node->presorted_keys = (PresortedKeyData *) palloc(plannode->nPresortedCols * - sizeof(PresortedKeyData)); + sizeof(*node->presorted_keys)); /* 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 72b135e5dcf..baa92b515c9 100644 --- a/src/backend/executor/nodeIndexscan.c +++ b/src/backend/executor/nodeIndexscan.c @@ -1027,9 +1027,9 @@ ExecInitIndexScan(IndexScan *node, EState *estate, int eflags) indexstate->iss_SortSupport = (SortSupportData *) palloc0(numOrderByKeys * sizeof(SortSupportData)); indexstate->iss_OrderByTypByVals = (bool *) - palloc(numOrderByKeys * sizeof(bool)); + palloc(numOrderByKeys * sizeof(*indexstate->iss_OrderByTypByVals)); indexstate->iss_OrderByTypLens = (int16 *) - palloc(numOrderByKeys * sizeof(int16)); + palloc(numOrderByKeys * sizeof(*indexstate->iss_OrderByTypLens)); i = 0; forboth(lco, node->indexorderbyops, lcx, node->indexorderbyorig) { @@ -1058,9 +1058,9 @@ ExecInitIndexScan(IndexScan *node, EState *estate, int eflags) /* allocate arrays to hold the re-calculated distances */ indexstate->iss_OrderByValues = (Datum *) - palloc(numOrderByKeys * sizeof(Datum)); + palloc(numOrderByKeys * sizeof(*indexstate->iss_OrderByValues)); indexstate->iss_OrderByNulls = (bool *) - palloc(numOrderByKeys * sizeof(bool)); + palloc(numOrderByKeys * sizeof(*indexstate->iss_OrderByNulls)); /* and initialize the reorder queue */ indexstate->iss_ReorderQueue = pairingheap_allocate(reorderqueue_cmp, @@ -1185,7 +1185,7 @@ ExecIndexBuildScanKeys(PlanState *planstate, Relation index, /* Allocate array_keys as large as it could possibly need to be */ array_keys = (IndexArrayKeyInfo *) - palloc0(n_scan_keys * sizeof(IndexArrayKeyInfo)); + palloc0(n_scan_keys * sizeof(*array_keys)); n_array_keys = 0; /* @@ -1276,7 +1276,7 @@ ExecIndexBuildScanKeys(PlanState *planstate, Relation index, { max_runtime_keys = 8; runtime_keys = (IndexRuntimeKeyInfo *) - palloc(max_runtime_keys * sizeof(IndexRuntimeKeyInfo)); + palloc(max_runtime_keys * sizeof(*runtime_keys)); } else { @@ -1400,7 +1400,7 @@ ExecIndexBuildScanKeys(PlanState *planstate, Relation index, { max_runtime_keys = 8; runtime_keys = (IndexRuntimeKeyInfo *) - palloc(max_runtime_keys * sizeof(IndexRuntimeKeyInfo)); + palloc(max_runtime_keys * sizeof(*runtime_keys)); } else { @@ -1518,7 +1518,7 @@ ExecIndexBuildScanKeys(PlanState *planstate, Relation index, { max_runtime_keys = 8; runtime_keys = (IndexRuntimeKeyInfo *) - palloc(max_runtime_keys * sizeof(IndexRuntimeKeyInfo)); + palloc(max_runtime_keys * sizeof(*runtime_keys)); } else { diff --git a/src/backend/executor/nodeMemoize.c b/src/backend/executor/nodeMemoize.c index 7444391e8a1..f5d719f9dea 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 = (ExprState **) palloc(nkeys * sizeof(*mstate->param_exprs)); mstate->collations = node->collations; /* Just point directly to the plan * data */ - mstate->hashfunctions = (FmgrInfo *) palloc(nkeys * sizeof(FmgrInfo)); + mstate->hashfunctions = (FmgrInfo *) palloc(nkeys * sizeof(*mstate->hashfunctions)); - eqfuncoids = palloc(nkeys * sizeof(Oid)); + eqfuncoids = palloc(nkeys * sizeof(*eqfuncoids)); for (i = 0; i < nkeys; i++) { diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index 874b71e6608..702efd6c84d 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -462,7 +462,7 @@ ExecInitGenerated(ResultRelInfo *resultRelInfo, */ oldContext = MemoryContextSwitchTo(estate->es_query_cxt); - ri_GeneratedExprs = (ExprState **) palloc0(natts * sizeof(ExprState *)); + ri_GeneratedExprs = (ExprState **) palloc0(natts * sizeof(*ri_GeneratedExprs)); ri_NumGeneratedNeeded = 0; for (int i = 0; i < natts; i++) diff --git a/src/backend/executor/nodeSubplan.c b/src/backend/executor/nodeSubplan.c index c8b7bd9eb66..66b8a91e161 100644 --- a/src/backend/executor/nodeSubplan.c +++ b/src/backend/executor/nodeSubplan.c @@ -976,14 +976,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 = (AttrNumber *) palloc(ncols * sizeof(*sstate->keyColIdx)); + sstate->tab_eq_funcoids = (Oid *) palloc(ncols * sizeof(*sstate->tab_eq_funcoids)); + sstate->tab_collations = (Oid *) palloc(ncols * sizeof(*sstate->tab_collations)); + sstate->tab_hash_funcs = (FmgrInfo *) palloc(ncols * sizeof(*sstate->tab_hash_funcs)); + lhs_hash_funcs = (FmgrInfo *) palloc(ncols * sizeof(*lhs_hash_funcs)); + sstate->cur_eq_funcs = (FmgrInfo *) palloc(ncols * sizeof(*sstate->cur_eq_funcs)); /* we'll need the cross-type equality fns below, but not in sstate */ - cross_eq_funcoids = (Oid *) palloc(ncols * sizeof(Oid)); + cross_eq_funcoids = (Oid *) palloc(ncols * sizeof(*cross_eq_funcoids)); i = 1; foreach(l, oplist) diff --git a/src/backend/executor/nodeTidscan.c b/src/backend/executor/nodeTidscan.c index 35fcd5625db..123f60b1f2c 100644 --- a/src/backend/executor/nodeTidscan.c +++ b/src/backend/executor/nodeTidscan.c @@ -158,7 +158,7 @@ TidListEval(TidScanState *tidstate) */ numAllocTids = list_length(tidstate->tss_tidexprs); tidList = (ItemPointerData *) - palloc(numAllocTids * sizeof(ItemPointerData)); + palloc(numAllocTids * sizeof(*tidList)); numTids = 0; foreach(l, tidstate->tss_tidexprs) diff --git a/src/backend/executor/nodeValuesscan.c b/src/backend/executor/nodeValuesscan.c index 8e85a5f2e9a..f6b9cd7dd70 100644 --- a/src/backend/executor/nodeValuesscan.c +++ b/src/backend/executor/nodeValuesscan.c @@ -278,9 +278,9 @@ ExecInitValuesScan(ValuesScan *node, EState *estate, int eflags) * simpler expressions.) */ scanstate->exprlists = (List **) - palloc(scanstate->array_len * sizeof(List *)); + palloc(scanstate->array_len * sizeof(*scanstate->exprlists)); scanstate->exprstatelists = (List **) - palloc0(scanstate->array_len * sizeof(List *)); + palloc0(scanstate->array_len * sizeof(*scanstate->exprstatelists)); i = 0; foreach(vtl, node->values_lists) { diff --git a/src/backend/jit/llvm/llvmjit_expr.c b/src/backend/jit/llvm/llvmjit_expr.c index f9c7f29e728..ebbf5c53db9 100644 --- a/src/backend/jit/llvm/llvmjit_expr.c +++ b/src/backend/jit/llvm/llvmjit_expr.c @@ -699,7 +699,7 @@ llvm_compile_expr(ExprState *state) /* create blocks for checking args, one for each */ b_checkargnulls = (LLVMBasicBlockRef *) - palloc(sizeof(LLVMBasicBlockRef) * op->d.func.nargs); + palloc(sizeof(*b_checkargnulls) * 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 ed54f190494..8a3a6b8b74a 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 = (short *) palloc0((u_size + 1) * sizeof(*state->pair_uv)); + state->pair_vu = (short *) palloc0((v_size + 1) * sizeof(*state->pair_vu)); + state->distance = (short *) palloc((u_size + 1) * sizeof(*state->distance)); + state->queue = (short *) palloc((u_size + 2) * sizeof(*state->queue)); while (hk_breadth_search(state)) { diff --git a/src/backend/lib/knapsack.c b/src/backend/lib/knapsack.c index 5b3697a090f..65c876e5136 100644 --- a/src/backend/lib/knapsack.c +++ b/src/backend/lib/knapsack.c @@ -65,8 +65,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((1 + max_weight) * sizeof(*values)); + sets = palloc((1 + max_weight) * sizeof(*sets)); for (i = 0; i <= max_weight; ++i) { diff --git a/src/backend/libpq/auth.c b/src/backend/libpq/auth.c index 8045dbffe04..8a306c1b8f2 100644 --- a/src/backend/libpq/auth.c +++ b/src/backend/libpq/auth.c @@ -1347,7 +1347,7 @@ pg_SSPI_recvauth(Port *port) */ if (sspictx == NULL) { - sspictx = malloc(sizeof(CtxtHandle)); + sspictx = malloc(sizeof(*sspictx)); if (sspictx == NULL) ereport(ERROR, (errmsg("out of memory"))); diff --git a/src/backend/libpq/hba.c b/src/backend/libpq/hba.c index 4c259f58d77..14561450582 100644 --- a/src/backend/libpq/hba.c +++ b/src/backend/libpq/hba.c @@ -310,7 +310,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((strlen(token->string + 1) + 1) * sizeof(*wstr)); wlen = pg_mb2wchar_with_len(token->string + 1, wstr, strlen(token->string + 1)); @@ -351,7 +351,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((strlen(match) + 1) * sizeof(*wmatchstr)); 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/queryjumblefuncs.c b/src/backend/nodes/queryjumblefuncs.c index ffc230af427..8a594abbb35 100644 --- a/src/backend/nodes/queryjumblefuncs.c +++ b/src/backend/nodes/queryjumblefuncs.c @@ -188,7 +188,7 @@ InitJumble(void) jstate->jumble_len = 0; jstate->clocations_buf_size = 32; jstate->clocations = (LocationLen *) palloc(jstate->clocations_buf_size * - sizeof(LocationLen)); + sizeof(*jstate->clocations)); jstate->clocations_count = 0; jstate->highest_extern_param_id = 0; jstate->pending_nulls = 0; diff --git a/src/backend/nodes/readfuncs.c b/src/backend/nodes/readfuncs.c index 9a8ca27ec10..d961d527be3 100644 --- a/src/backend/nodes/readfuncs.c +++ b/src/backend/nodes/readfuncs.c @@ -670,7 +670,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 = (datatype *) palloc(numCols * sizeof(*vals)); \ 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 4c43fd0b19b..4e0a9c44c45 100644 --- a/src/backend/optimizer/path/allpaths.c +++ b/src/backend/optimizer/path/allpaths.c @@ -1063,7 +1063,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 = (double *) palloc0(nattrs * sizeof(*parent_attrsizes)); foreach(l, root->append_rel_list) { @@ -2651,7 +2651,7 @@ set_subquery_pathlist(PlannerInfo *root, RelOptInfo *rel, */ memset(&safetyInfo, 0, sizeof(safetyInfo)); safetyInfo.unsafeFlags = (unsigned char *) - palloc0((list_length(subquery->targetList) + 1) * sizeof(unsigned char)); + palloc0((list_length(subquery->targetList) + 1) * sizeof(*safetyInfo.unsafeFlags)); /* * If the subquery has the "security_barrier" flag, it means the subquery diff --git a/src/backend/optimizer/path/equivclass.c b/src/backend/optimizer/path/equivclass.c index 441f12f6c50..b846e982494 100644 --- a/src/backend/optimizer/path/equivclass.c +++ b/src/backend/optimizer/path/equivclass.c @@ -1383,7 +1383,7 @@ generate_base_implied_equalities_no_const(PlannerInfo *root, * 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 *)); + palloc0(root->simple_rel_array_size * sizeof(*prev_ems)); /* 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 139fa1f875a..78928997e61 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 = (EquivalenceClass **) palloc(nClauses * sizeof(*ecs)); + scores = (int *) palloc(nClauses * sizeof(*scores)); necs = 0; foreach(lc, mergeclauses) diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c index bc417f93840..dfa2963a657 100644 --- a/src/backend/optimizer/plan/createplan.c +++ b/src/backend/optimizer/plan/createplan.c @@ -1728,8 +1728,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(nkeys * sizeof(*operators)); + collations = palloc(nkeys * sizeof(*collations)); i = 0; forboth(lc, param_exprs, lc2, best_path->hash_operators) @@ -2270,7 +2270,7 @@ create_groupingsets_plan(PlannerInfo *root, GroupingSetsPath *best_path) maxref = gc->tleSortGroupRef; } - grouping_map = (AttrNumber *) palloc0((maxref + 1) * sizeof(AttrNumber)); + grouping_map = (AttrNumber *) palloc0((maxref + 1) * sizeof(*grouping_map)); /* Now look up the column numbers in the child's tlist */ foreach(lc, root->processed_groupClause) @@ -2708,9 +2708,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 = (AttrNumber *) palloc(numUniqkeys * sizeof(*uniqColIdx)); + uniqOperators = (Oid *) palloc(numUniqkeys * sizeof(*uniqOperators)); + uniqCollations = (Oid *) palloc(numUniqkeys * sizeof(*uniqCollations)); numUniqkeys = 0; foreach(l, parse->sortClause) @@ -4524,10 +4524,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 = (Oid *) palloc(nClauses * sizeof(*mergefamilies)); + mergecollations = (Oid *) palloc(nClauses * sizeof(*mergecollations)); + mergereversals = (bool *) palloc(nClauses * sizeof(*mergereversals)); + mergenullsfirst = (bool *) palloc(nClauses * sizeof(*mergenullsfirst)); opathkey = NULL; opeclass = NULL; @@ -5277,7 +5277,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 = (QualItem *) palloc(nitems * sizeof(*items)); i = 0; foreach(lc, clauses) { @@ -6157,10 +6157,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 = (AttrNumber *) palloc(numsortkeys * sizeof(*sortColIdx)); + sortOperators = (Oid *) palloc(numsortkeys * sizeof(*sortOperators)); + collations = (Oid *) palloc(numsortkeys * sizeof(*collations)); + nullsFirst = (bool *) palloc(numsortkeys * sizeof(*nullsFirst)); numsortkeys = 0; @@ -6398,10 +6398,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 = (AttrNumber *) palloc(numsortkeys * sizeof(*sortColIdx)); + sortOperators = (Oid *) palloc(numsortkeys * sizeof(*sortOperators)); + collations = (Oid *) palloc(numsortkeys * sizeof(*collations)); + nullsFirst = (bool *) palloc(numsortkeys * sizeof(*nullsFirst)); numsortkeys = 0; foreach(l, sortcls) @@ -6449,10 +6449,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 = (AttrNumber *) palloc(numsortkeys * sizeof(*sortColIdx)); + sortOperators = (Oid *) palloc(numsortkeys * sizeof(*sortOperators)); + collations = (Oid *) palloc(numsortkeys * sizeof(*collations)); + nullsFirst = (bool *) palloc(numsortkeys * sizeof(*nullsFirst)); numsortkeys = 0; foreach(l, groupcls) diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c index 8b22c30559b..826be6fcd72 100644 --- a/src/backend/optimizer/plan/planner.c +++ b/src/backend/optimizer/plan/planner.c @@ -2248,7 +2248,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 = (int *) palloc((maxref + 1) * sizeof(*gd->tleref_to_colnum_map)); /* * If we have any unsortable sets, we must extract them before trying to @@ -3002,10 +3002,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((num_sets_raw + 1) * sizeof(*orig_sets)); + set_masks = palloc0((num_sets_raw + 1) * sizeof(*set_masks)); + adjacency = palloc0((num_sets_raw + 1) * sizeof(*adjacency)); + adjacency_buf = palloc((num_sets_raw + 1) * sizeof(*adjacency_buf)); j_size = 0; j = 0; @@ -3067,7 +3067,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((n_adj + 1) * sizeof(*adjacency[i])); memcpy(adjacency[i], adjacency_buf, (n_adj + 1) * sizeof(short)); } else @@ -3090,7 +3090,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((num_sets + 1) * sizeof(*chains)); for (i = 1; i <= num_sets; ++i) { @@ -3106,7 +3106,7 @@ extract_rollup_sets(List *groupingSets) } /* build result lists. */ - results = palloc0((num_chains + 1) * sizeof(List *)); + results = palloc0((num_chains + 1) * sizeof(*results)); for (i = 1; i <= num_sets; ++i) { @@ -4397,7 +4397,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(num_rollups * sizeof(*k_weights)); Bitmapset *hash_items = NULL; int i; @@ -6448,8 +6448,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 = (bool *) palloc0(ncols * sizeof(*col_is_srf)); + postpone_col = (bool *) palloc0(ncols * sizeof(*postpone_col)); have_srf = have_volatile = have_expensive = have_srf_sortcols = false; i = 0; diff --git a/src/backend/optimizer/prep/prepjointree.c b/src/backend/optimizer/prep/prepjointree.c index c3b726e93e7..11df46d0b0f 100644 --- a/src/backend/optimizer/prep/prepjointree.c +++ b/src/backend/optimizer/prep/prepjointree.c @@ -552,7 +552,7 @@ expand_virtual_generated_columns(PlannerInfo *root, Query *parse, rvcontext.wrap_option = REPLACE_WRAP_NONE; /* initialize cache array with indexes 0 .. length(tlist) */ rvcontext.rv_cache = palloc0((list_length(tlist) + 1) * - sizeof(Node *)); + sizeof(*rvcontext.rv_cache)); /* * If the query uses grouping sets, we need a PlaceHolderVar for each @@ -1518,7 +1518,7 @@ pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte, 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 *)); + sizeof(*rvcontext.rv_cache)); /* * If the parent query uses grouping sets, we need a PlaceHolderVar for @@ -1841,7 +1841,7 @@ make_setop_translation_list(Query *query, int newvarno, /* (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)); + (AttrNumber *) palloc0(appinfo->num_child_cols * sizeof(*pcolnos)); foreach(l, query->targetList) { @@ -2059,7 +2059,7 @@ pull_up_simple_values(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte) rvcontext.wrap_option = REPLACE_WRAP_NONE; /* initialize cache array with indexes 0 .. length(tlist) */ rvcontext.rv_cache = palloc0((list_length(tlist) + 1) * - sizeof(Node *)); + sizeof(*rvcontext.rv_cache)); /* * Replace all of the top query's references to the RTE's outputs with @@ -2227,7 +2227,7 @@ pull_up_constant_function(PlannerInfo *root, Node *jtnode, 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 *)); + sizeof(*rvcontext.rv_cache)); /* * 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 271bb4e6828..538ad162544 100644 --- a/src/backend/optimizer/util/appendinfo.c +++ b/src/backend/optimizer/util/appendinfo.c @@ -94,7 +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)); + (AttrNumber *) palloc0(newnatts * sizeof(*pcolnos)); 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 ddafc21c819..28f7190b45e 100644 --- a/src/backend/optimizer/util/clauses.c +++ b/src/backend/optimizer/util/clauses.c @@ -243,7 +243,7 @@ find_window_functions(Node *clause, Index maxWinRef) lists->numWindowFuncs = 0; lists->maxWinRef = maxWinRef; - lists->windowFuncs = (List **) palloc0((maxWinRef + 1) * sizeof(List *)); + lists->windowFuncs = (List **) palloc0((maxWinRef + 1) * sizeof(*lists->windowFuncs)); (void) find_window_functions_walker(clause, lists); return lists; } @@ -4981,7 +4981,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 = (int *) palloc0(funcform->pronargs * sizeof(*usecounts)); newexpr = substitute_actual_parameters(newexpr, funcform->pronargs, args, usecounts); diff --git a/src/backend/parser/analyze.c b/src/backend/parser/analyze.c index 92be345d9a8..e7277cd3c13 100644 --- a/src/backend/parser/analyze.c +++ b/src/backend/parser/analyze.c @@ -1615,7 +1615,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 = (List **) palloc0(sublist_length * sizeof(*colexprs)); } else if (sublist_length != list_length(sublist)) { @@ -1888,7 +1888,7 @@ transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt) targetvars = NIL; targetnames = NIL; sortnscolumns = (ParseNamespaceColumn *) - palloc0(list_length(sostmt->colTypes) * sizeof(ParseNamespaceColumn)); + palloc0(list_length(sostmt->colTypes) * sizeof(*sortnscolumns)); sortcolindex = 0; forfour(lct, sostmt->colTypes, diff --git a/src/backend/parser/parse_clause.c b/src/backend/parser/parse_clause.c index 944482207f3..7bffdd544df 100644 --- a/src/backend/parser/parse_clause.c +++ b/src/backend/parser/parse_clause.c @@ -1290,7 +1290,7 @@ transformFromClauseItem(ParseState *pstate, Node *n, /* 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)); + sizeof(*res_nscolumns)); res_colindex = 0; if (j->usingClause) diff --git a/src/backend/parser/parse_cte.c b/src/backend/parser/parse_cte.c index 366fd901d9d..38a4220c011 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 = (CteItem *) palloc0(cstate.numitems * sizeof(*cstate.items)); i = 0; foreach(lc, withClause->ctes) { diff --git a/src/backend/parser/parse_relation.c b/src/backend/parser/parse_relation.c index dd64f45478a..0c6a3d589ee 100644 --- a/src/backend/parser/parse_relation.c +++ b/src/backend/parser/parse_relation.c @@ -1316,7 +1316,7 @@ buildNSItemFromTupleDesc(RangeTblEntry *rte, Index rtindex, /* extract per-column data from the tupdesc */ nscolumns = (ParseNamespaceColumn *) - palloc0(maxattrs * sizeof(ParseNamespaceColumn)); + palloc0(maxattrs * sizeof(*nscolumns)); for (varattno = 0; varattno < maxattrs; varattno++) { @@ -1382,7 +1382,7 @@ buildNSItemFromLists(RangeTblEntry *rte, Index rtindex, /* extract per-column data from the lists */ nscolumns = (ParseNamespaceColumn *) - palloc0(maxattrs * sizeof(ParseNamespaceColumn)); + palloc0(maxattrs * sizeof(*nscolumns)); varattno = 0; forthree(lct, coltypes, diff --git a/src/backend/partitioning/partbounds.c b/src/backend/partitioning/partbounds.c index 40ac700d529..838624bf668 100644 --- a/src/backend/partitioning/partbounds.c +++ b/src/backend/partitioning/partbounds.c @@ -386,7 +386,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 = (int *) palloc(greatest_modulus * sizeof(*boundinfo->indexes)); for (i = 0; i < greatest_modulus; i++) boundinfo->indexes[i] = -1; @@ -395,7 +395,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 = (Datum *) palloc(nparts * 2 * sizeof(*boundDatums)); /* * For hash partitioning, there are as many datums (modulus and remainder @@ -478,7 +478,7 @@ create_list_bounds(PartitionBoundSpec **boundspecs, int nparts, ndatums = get_non_null_list_datum_count(boundspecs, nparts); all_values = (PartitionListValue *) - palloc(ndatums * sizeof(PartitionListValue)); + palloc(ndatums * sizeof(*all_values)); /* Create a unified list of non-null values across all partitions. */ for (j = 0, i = 0; i < nparts; i++) @@ -534,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 = (int *) palloc(ndatums * sizeof(*boundinfo->indexes)); /* * 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 = (Datum *) palloc(ndatums * sizeof(*boundDatums)); /* * Copy values. Canonical indexes are values ranging from 0 to (nparts - @@ -735,7 +735,7 @@ create_range_bounds(PartitionBoundSpec **boundspecs, int nparts, /* Save distinct bounds from all_bounds into rbounds. */ rbounds = (PartitionRangeBound **) - palloc(ndatums * sizeof(PartitionRangeBound *)); + palloc(ndatums * sizeof(*rbounds)); k = 0; prev = NULL; for (i = 0; i < ndatums; i++) @@ -816,7 +816,7 @@ create_range_bounds(PartitionBoundSpec **boundspecs, int nparts, * arrays in each loop. */ partnatts = key->partnatts; - boundDatums = (Datum *) palloc(ndatums * partnatts * sizeof(Datum)); + boundDatums = (Datum *) palloc(ndatums * partnatts * sizeof(*boundDatums)); boundKinds = palloc_array(PartitionRangeDatumKind, ndatums * partnatts); for (i = 0; i < ndatums; i++) @@ -1020,7 +1020,7 @@ partition_bounds_copy(PartitionBoundInfo src, Assert(key->strategy == PARTITION_STRATEGY_RANGE); dest->kind = (PartitionRangeDatumKind **) palloc(ndatums * - sizeof(PartitionRangeDatumKind *)); + sizeof(*dest->kind)); /* * In the loop below, to save from allocating a series of small arrays @@ -1028,7 +1028,7 @@ partition_bounds_copy(PartitionBoundInfo src, * here and use a smaller portion of it for each datum. */ boundKinds = (PartitionRangeDatumKind *) palloc(ndatums * partnatts * - sizeof(PartitionRangeDatumKind)); + sizeof(*boundKinds)); for (i = 0; i < ndatums; i++) { @@ -1051,7 +1051,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(ndatums * natts * sizeof(*boundDatums)); for (i = 0; i < ndatums; i++) { diff --git a/src/backend/partitioning/partdesc.c b/src/backend/partitioning/partdesc.c index 5624f503fec..d128842bab1 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 = (Oid *) palloc(nparts * sizeof(*oids)); + is_leaf = (bool *) palloc(nparts * sizeof(*is_leaf)); + boundspecs = palloc(nparts * sizeof(*boundspecs)); } /* Collect bound spec nodes for each partition. */ @@ -336,8 +336,8 @@ retry: partdesc->last_found_part_index = -1; partdesc->last_found_count = 0; - partdesc->oids = (Oid *) palloc(nparts * sizeof(Oid)); - partdesc->is_leaf = (bool *) palloc(nparts * sizeof(bool)); + partdesc->oids = (Oid *) palloc(nparts * sizeof(*partdesc->oids)); + partdesc->is_leaf = (bool *) palloc(nparts * sizeof(*partdesc->is_leaf)); /* * 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 0227a2c9281..f1aed928388 100644 --- a/src/backend/partitioning/partprune.c +++ b/src/backend/partitioning/partprune.c @@ -653,12 +653,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 = (int *) palloc(nparts * sizeof(*subplan_map)); memset(subplan_map, -1, nparts * sizeof(int)); - subpart_map = (int *) palloc(nparts * sizeof(int)); + subpart_map = (int *) palloc(nparts * sizeof(*subpart_map)); memset(subpart_map, -1, nparts * sizeof(int)); - relid_map = (Oid *) palloc0(nparts * sizeof(Oid)); - leafpart_rti_map = (int *) palloc0(nparts * sizeof(int)); + relid_map = (Oid *) palloc0(nparts * sizeof(*relid_map)); + leafpart_rti_map = (int *) palloc0(nparts * sizeof(*leafpart_rti_map)); present_parts = NULL; i = -1; @@ -867,7 +867,7 @@ get_matching_partitions(PartitionPruneContext *context, List *pruning_steps) * of the last pruning step. */ results = (PruneStepResult **) - palloc0(num_steps * sizeof(PruneStepResult *)); + palloc0(num_steps * sizeof(*results)); foreach(lc, pruning_steps) { PartitionPruneStep *step = lfirst(lc); diff --git a/src/backend/port/posix_sema.c b/src/backend/port/posix_sema.c index d7fb0c0c4da..ca965d51928 100644 --- a/src/backend/port/posix_sema.c +++ b/src/backend/port/posix_sema.c @@ -210,7 +210,7 @@ PGReserveSemaphores(int maxSemas) DataDir))); #ifdef USE_NAMED_POSIX_SEMAPHORES - mySemPointers = (sem_t **) malloc(maxSemas * sizeof(sem_t *)); + mySemPointers = (sem_t **) malloc(maxSemas * sizeof(*mySemPointers)); if (mySemPointers == NULL) elog(PANIC, "out of memory"); #else diff --git a/src/backend/port/sysv_sema.c b/src/backend/port/sysv_sema.c index 9faaeeefc79..b0712f4b720 100644 --- a/src/backend/port/sysv_sema.c +++ b/src/backend/port/sysv_sema.c @@ -350,7 +350,7 @@ PGReserveSemaphores(int maxSemas) maxSemaSets = (maxSemas + SEMAS_PER_SET - 1) / SEMAS_PER_SET; mySemaSets = (IpcSemaphoreId *) - malloc(maxSemaSets * sizeof(IpcSemaphoreId)); + malloc(maxSemaSets * sizeof(*mySemaSets)); if (mySemaSets == NULL) elog(PANIC, "out of memory"); numSemaSets = 0; diff --git a/src/backend/port/win32_sema.c b/src/backend/port/win32_sema.c index 5854ad1f54d..ba2797b4c5c 100644 --- a/src/backend/port/win32_sema.c +++ b/src/backend/port/win32_sema.c @@ -46,7 +46,7 @@ PGSemaphoreShmemSize(int maxSemas) void PGReserveSemaphores(int maxSemas) { - mySemSet = (HANDLE *) malloc(maxSemas * sizeof(HANDLE)); + mySemSet = (HANDLE *) malloc(maxSemas * sizeof(*mySemSet)); if (mySemSet == NULL) elog(PANIC, "out of memory"); numSems = 0; diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c index 1bd3924e35e..3458acbe37c 100644 --- a/src/backend/postmaster/autovacuum.c +++ b/src/backend/postmaster/autovacuum.c @@ -1029,7 +1029,7 @@ rebuild_database_list(Oid newdb) int i; /* put all the hash elements into an array */ - dbary = palloc(nelems * sizeof(avl_dbase)); + dbary = palloc(nelems * sizeof(*dbary)); /* 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 7f8cf1fa2ec..2a76bdbe324 100644 --- a/src/backend/postmaster/checkpointer.c +++ b/src/backend/postmaster/checkpointer.c @@ -1466,7 +1466,7 @@ AbsorbSyncRequests(void) if (n > 0) { if (!requests) - requests = (CheckpointerRequest *) palloc(n * sizeof(CheckpointerRequest)); + requests = (CheckpointerRequest *) palloc(n * sizeof(*requests)); for (i = 0; i < n; i++) { diff --git a/src/backend/postmaster/pmchild.c b/src/backend/postmaster/pmchild.c index 584bb58c8ab..893b070686a 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(num_pmchild_slots * sizeof(*slots)); #ifdef USE_VALGRIND pmchild_array = slots; #endif diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c index 7dd3a201b1c..9693475e873 100644 --- a/src/backend/postmaster/postmaster.c +++ b/src/backend/postmaster/postmaster.c @@ -1111,7 +1111,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(MAXLISTEN * sizeof(*ListenSockets)); on_proc_exit(CloseServerPorts, 0); if (ListenAddresses) diff --git a/src/backend/regex/regc_pg_locale.c b/src/backend/regex/regc_pg_locale.c index bb0e3f1d139..c80eee4e12c 100644 --- a/src/backend/regex/regc_pg_locale.c +++ b/src/backend/regex/regc_pg_locale.c @@ -283,7 +283,7 @@ regc_ctype_get_cache(regc_wc_probefunc probefunc, int cclasscode) /* * Nope, so initialize some workspace ... */ - pcc = (pg_ctype_cache *) malloc(sizeof(pg_ctype_cache)); + pcc = (pg_ctype_cache *) malloc(sizeof(*pcc)); if (pcc == NULL) return NULL; pcc->probefunc = probefunc; diff --git a/src/backend/replication/logical/proto.c b/src/backend/replication/logical/proto.c index 27ad74fd759..702d73bf530 100644 --- a/src/backend/replication/logical/proto.c +++ b/src/backend/replication/logical/proto.c @@ -870,7 +870,7 @@ logicalrep_read_tuple(StringInfo in, LogicalRepTupleData *tuple) natts = pq_getmsgint(in, 2); /* Allocate space for per-column values; zero out unused StringInfoDatas */ - tuple->colvalues = (StringInfoData *) palloc0(natts * sizeof(StringInfoData)); + tuple->colvalues = (StringInfoData *) palloc0(natts * sizeof(*tuple->colvalues)); tuple->colstatus = palloc_array(char, natts); tuple->ncols = natts; diff --git a/src/backend/replication/logical/reorderbuffer.c b/src/backend/replication/logical/reorderbuffer.c index f18c6fb52b5..47db7af9b1e 100644 --- a/src/backend/replication/logical/reorderbuffer.c +++ b/src/backend/replication/logical/reorderbuffer.c @@ -2490,7 +2490,7 @@ ReorderBufferProcessTXN(ReorderBuffer *rb, ReorderBufferTXN *txn, int nrelations = 0; Relation *relations; - relations = palloc0(nrelids * sizeof(Relation)); + relations = palloc0(nrelids * sizeof(*relations)); for (i = 0; i < nrelids; i++) { Oid relid = change->data.truncate.relids[i]; diff --git a/src/backend/replication/logical/snapbuild.c b/src/backend/replication/logical/snapbuild.c index d6ab1e017eb..a49a8add398 100644 --- a/src/backend/replication/logical/snapbuild.c +++ b/src/backend/replication/logical/snapbuild.c @@ -209,7 +209,7 @@ AllocateSnapshotBuilder(ReorderBuffer *reorder, builder->committed.xcnt = 0; builder->committed.xcnt_space = 128; /* arbitrary number */ builder->committed.xip = - palloc0(builder->committed.xcnt_space * sizeof(TransactionId)); + palloc0(builder->committed.xcnt_space * sizeof(*builder->committed.xip)); builder->committed.includes_all_transactions = true; builder->catchange.xcnt = 0; diff --git a/src/backend/replication/logical/tablesync.c b/src/backend/replication/logical/tablesync.c index 6bb0cbeedad..293e59d2c61 100644 --- a/src/backend/replication/logical/tablesync.c +++ b/src/backend/replication/logical/tablesync.c @@ -901,8 +901,8 @@ fetch_remote_table_info(char *nspname, char *relname, LogicalRepRelation *lrel, nspname, relname, res->err))); /* We don't know the number of rows coming, so allocate enough space. */ - lrel->attnames = palloc0(MaxTupleAttributeNumber * sizeof(char *)); - lrel->atttyps = palloc0(MaxTupleAttributeNumber * sizeof(Oid)); + lrel->attnames = palloc0(MaxTupleAttributeNumber * sizeof(*lrel->attnames)); + lrel->atttyps = palloc0(MaxTupleAttributeNumber * sizeof(*lrel->atttyps)); lrel->attkeys = NULL; /* diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c index fc64476a9ef..446c8e3055b 100644 --- a/src/backend/replication/logical/worker.c +++ b/src/backend/replication/logical/worker.c @@ -974,8 +974,8 @@ slot_fill_defaults(LogicalRepRelMapEntry *rel, EState *estate, if (num_phys_attrs == rel->remoterel.natts) return; - defmap = (int *) palloc(num_phys_attrs * sizeof(int)); - defexprs = (ExprState **) palloc(num_phys_attrs * sizeof(ExprState *)); + defmap = (int *) palloc(num_phys_attrs * sizeof(*defmap)); + defexprs = (ExprState **) palloc(num_phys_attrs * sizeof(*defexprs)); Assert(rel->attrmap->maplen == num_phys_attrs); for (attnum = 0; attnum < num_phys_attrs; attnum++) @@ -5265,7 +5265,7 @@ subxact_info_read(Oid subid, TransactionId xid) */ oldctx = MemoryContextSwitchTo(LogicalStreamingContext); subxact_data.subxacts = palloc(subxact_data.nsubxacts_max * - sizeof(SubXactInfo)); + sizeof(*subxact_data.subxacts)); MemoryContextSwitchTo(oldctx); if (len > 0) @@ -5331,7 +5331,7 @@ subxact_info_add(TransactionId xid) * subxact_info_read. */ oldctx = MemoryContextSwitchTo(LogicalStreamingContext); - subxacts = palloc(subxact_data.nsubxacts_max * sizeof(SubXactInfo)); + subxacts = palloc(subxact_data.nsubxacts_max * sizeof(*subxacts)); MemoryContextSwitchTo(oldctx); } else if (subxact_data.nsubxacts == subxact_data.nsubxacts_max) diff --git a/src/backend/replication/pgoutput/pgoutput.c b/src/backend/replication/pgoutput/pgoutput.c index 787998abb8a..c5e3c3ba335 100644 --- a/src/backend/replication/pgoutput/pgoutput.c +++ b/src/backend/replication/pgoutput/pgoutput.c @@ -1667,7 +1667,7 @@ pgoutput_truncate(LogicalDecodingContext *ctx, ReorderBufferTXN *txn, old = MemoryContextSwitchTo(data->context); - relids = palloc0(nrelations * sizeof(Oid)); + relids = palloc0(nrelations * sizeof(*relids)); nrelids = 0; for (i = 0; i < nrelations; i++) diff --git a/src/backend/rewrite/rewriteHandler.c b/src/backend/rewrite/rewriteHandler.c index 688dcd09ca6..350c4fdc305 100644 --- a/src/backend/rewrite/rewriteHandler.c +++ b/src/backend/rewrite/rewriteHandler.c @@ -800,7 +800,7 @@ rewriteTargetListIU(List *targetList, * scan, then appended to the reconstructed tlist. */ numattrs = RelationGetNumberOfAttributes(target_relation); - new_tles = (TargetEntry **) palloc0(numattrs * sizeof(TargetEntry *)); + new_tles = (TargetEntry **) palloc0(numattrs * sizeof(*new_tles)); next_junk_attrno = numattrs + 1; foreach(temp, targetList) @@ -1444,7 +1444,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 = (int *) palloc0(numattrs * sizeof(*attrnos)); foreach(lc, parsetree->targetList) { diff --git a/src/backend/statistics/extended_stats.c b/src/backend/statistics/extended_stats.c index 19778b773d2..2f6c8fbaabc 100644 --- a/src/backend/statistics/extended_stats.c +++ b/src/backend/statistics/extended_stats.c @@ -698,7 +698,7 @@ lookup_var_attr_stats(Bitmapset *attrs, List *exprs, natts = bms_num_members(attrs) + list_length(exprs); - stats = (VacAttrStats **) palloc(natts * sizeof(VacAttrStats *)); + stats = (VacAttrStats **) palloc(natts * sizeof(*stats)); /* lookup VacAttrStats info for the requested columns (same attnum) */ while ((x = bms_next_member(attrs, x)) >= 0) @@ -2132,8 +2132,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 = (Datum *) palloc(numrows * sizeof(*exprvals)); + exprnulls = (bool *) palloc(numrows * sizeof(*exprnulls)); tcnt = 0; for (i = 0; i < numrows; i++) @@ -2250,7 +2250,7 @@ build_expr_data(List *exprs, int stattarget) AnlExprData *exprdata; ListCell *lc; - exprdata = (AnlExprData *) palloc0(nexprs * sizeof(AnlExprData)); + exprdata = (AnlExprData *) palloc0(nexprs * sizeof(*exprdata)); idx = 0; foreach(lc, exprs) @@ -2343,7 +2343,7 @@ serialize_expr_stats(AnlExprData *exprdata, int nexprs) if (nnum > 0) { int n; - Datum *numdatums = (Datum *) palloc(nnum * sizeof(Datum)); + Datum *numdatums = (Datum *) palloc(nnum * sizeof(*numdatums)); ArrayType *arry; for (n = 0; n < nnum; n++) diff --git a/src/backend/statistics/mcv.c b/src/backend/statistics/mcv.c index ec650ba029f..6560e83fc91 100644 --- a/src/backend/statistics/mcv.c +++ b/src/backend/statistics/mcv.c @@ -428,7 +428,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 = (SortItem *) palloc(ngroups * sizeof(*groups)); j = 0; groups[0] = items[0]; @@ -1097,7 +1097,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(ndims * sizeof(*info)); 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 58046d2bd62..3705ac18b00 100644 --- a/src/backend/statistics/mvdistinct.c +++ b/src/backend/statistics/mvdistinct.c @@ -310,7 +310,7 @@ statext_ndistinct_deserialize(bytea *data) Assert((item->nattributes >= 2) && (item->nattributes <= STATS_MAX_DIMENSIONS)); item->attributes - = (AttrNumber *) palloc(item->nattributes * sizeof(AttrNumber)); + = (AttrNumber *) palloc(item->nattributes * sizeof(*item->attributes)); memcpy(item->attributes, tmp, sizeof(AttrNumber) * item->nattributes); tmp += sizeof(AttrNumber) * item->nattributes; diff --git a/src/backend/storage/file/fd.c b/src/backend/storage/file/fd.c index e9eaaf9c829..60dc73675f0 100644 --- a/src/backend/storage/file/fd.c +++ b/src/backend/storage/file/fd.c @@ -902,7 +902,7 @@ InitFileAccess(void) Assert(SizeVfdCache == 0); /* call me only once */ /* initialize cache header entry */ - VfdCache = (Vfd *) malloc(sizeof(Vfd)); + VfdCache = (Vfd *) malloc(sizeof(*VfdCache)); if (VfdCache == NULL) ereport(FATAL, (errcode(ERRCODE_OUT_OF_MEMORY), @@ -972,7 +972,7 @@ count_usable_fds(int max_to_probe, int *usable_fds, int *already_open) #endif size = 1024; - fd = (int *) palloc(size * sizeof(int)); + fd = (int *) palloc(size * sizeof(*fd)); #ifdef HAVE_GETRLIMIT getrlimit_status = getrlimit(RLIMIT_NOFILE, &rlim); @@ -2581,7 +2581,7 @@ reserveAllocatedDesc(void) if (allocatedDescs == NULL) { newMax = FD_MINFREE / 3; - newDescs = (AllocateDesc *) malloc(newMax * sizeof(AllocateDesc)); + newDescs = (AllocateDesc *) malloc(newMax * sizeof(*newDescs)); /* Out of memory already? Treat as fatal error. */ if (newDescs == NULL) ereport(ERROR, diff --git a/src/backend/storage/ipc/procarray.c b/src/backend/storage/ipc/procarray.c index f3a1603204e..cf1b0ee45c1 100644 --- a/src/backend/storage/ipc/procarray.c +++ b/src/backend/storage/ipc/procarray.c @@ -1458,7 +1458,7 @@ TransactionIdIsInProgress(TransactionId xid) */ int maxxids = RecoveryInProgress() ? TOTAL_MAX_CACHED_SUBXIDS : arrayP->maxProcs; - xids = (TransactionId *) malloc(maxxids * sizeof(TransactionId)); + xids = (TransactionId *) malloc(maxxids * sizeof(*xids)); if (xids == NULL) ereport(ERROR, (errcode(ERRCODE_OUT_OF_MEMORY), @@ -2158,14 +2158,14 @@ GetSnapshotData(Snapshot snapshot) * we are in recovery, see later comments. */ snapshot->xip = (TransactionId *) - malloc(GetMaxSnapshotXidCount() * sizeof(TransactionId)); + malloc(GetMaxSnapshotXidCount() * sizeof(*snapshot->xip)); if (snapshot->xip == NULL) ereport(ERROR, (errcode(ERRCODE_OUT_OF_MEMORY), errmsg("out of memory"))); Assert(snapshot->subxip == NULL); snapshot->subxip = (TransactionId *) - malloc(GetMaxSnapshotSubxidCount() * sizeof(TransactionId)); + malloc(GetMaxSnapshotSubxidCount() * sizeof(*snapshot->subxip)); if (snapshot->subxip == NULL) ereport(ERROR, (errcode(ERRCODE_OUT_OF_MEMORY), @@ -2668,7 +2668,7 @@ GetRunningTransactionData(void) * First call */ CurrentRunningXacts->xids = (TransactionId *) - malloc(TOTAL_MAX_CACHED_SUBXIDS * sizeof(TransactionId)); + malloc(TOTAL_MAX_CACHED_SUBXIDS * sizeof(*CurrentRunningXacts->xids)); if (CurrentRunningXacts->xids == NULL) ereport(ERROR, (errcode(ERRCODE_OUT_OF_MEMORY), @@ -3389,7 +3389,7 @@ GetConflictingVirtualXIDs(TransactionId limitXmin, Oid dbOid) if (vxids == NULL) { vxids = (VirtualTransactionId *) - malloc(sizeof(VirtualTransactionId) * (arrayP->maxProcs + 1)); + malloc(sizeof(*vxids) * (arrayP->maxProcs + 1)); if (vxids == NULL) ereport(ERROR, (errcode(ERRCODE_OUT_OF_MEMORY), diff --git a/src/backend/storage/lmgr/deadlock.c b/src/backend/storage/lmgr/deadlock.c index c4bfaaa67ac..e3a2d59a9d5 100644 --- a/src/backend/storage/lmgr/deadlock.c +++ b/src/backend/storage/lmgr/deadlock.c @@ -152,16 +152,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 = (PGPROC **) palloc(MaxBackends * sizeof(*visitedProcs)); + deadlockDetails = (DEADLOCK_INFO *) palloc(MaxBackends * sizeof(*deadlockDetails)); /* * 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 = (int *) palloc(MaxBackends * sizeof(*beforeConstraints)); + afterConstraints = (int *) palloc(MaxBackends * sizeof(*afterConstraints)); /* * We need to consider rearranging at most MaxBackends/2 wait queues @@ -170,8 +170,8 @@ InitDeadLockChecking(void) * MaxBackends total waiters. */ waitOrders = (WAIT_ORDER *) - palloc((MaxBackends / 2) * sizeof(WAIT_ORDER)); - waitOrderProcs = (PGPROC **) palloc(MaxBackends * sizeof(PGPROC *)); + palloc((MaxBackends / 2) * sizeof(*waitOrders)); + waitOrderProcs = (PGPROC **) palloc(MaxBackends * sizeof(*waitOrderProcs)); /* * Allow at most MaxBackends distinct constraints in a configuration. (Is @@ -182,7 +182,7 @@ InitDeadLockChecking(void) * really big might potentially allow a stack-overflow problem. */ maxCurConstraints = MaxBackends; - curConstraints = (EDGE *) palloc(maxCurConstraints * sizeof(EDGE)); + curConstraints = (EDGE *) palloc(maxCurConstraints * sizeof(*curConstraints)); /* * Allow up to 3*MaxBackends constraints to be saved without having to @@ -196,7 +196,7 @@ InitDeadLockChecking(void) "MAX_BACKENDS_BITS too big for * 4"); maxPossibleConstraints = MaxBackends * 4; possibleConstraints = - (EDGE *) palloc(maxPossibleConstraints * sizeof(EDGE)); + (EDGE *) palloc(maxPossibleConstraints * sizeof(*possibleConstraints)); MemoryContextSwitchTo(oldcxt); } diff --git a/src/backend/storage/lmgr/lock.c b/src/backend/storage/lmgr/lock.c index 9015ba3caf7..48a7c93f180 100644 --- a/src/backend/storage/lmgr/lock.c +++ b/src/backend/storage/lmgr/lock.c @@ -4192,7 +4192,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(els * sizeof(*accessExclusiveLocks)); /* Now scan the tables to copy the data */ hash_seq_init(&seqstat, LockMethodProcLockHash); diff --git a/src/backend/tcop/fastpath.c b/src/backend/tcop/fastpath.c index 62f9ffa0dc0..a1bd7ad3953 100644 --- a/src/backend/tcop/fastpath.c +++ b/src/backend/tcop/fastpath.c @@ -339,7 +339,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 = (int16 *) palloc(numAFormats * sizeof(*aformats)); for (i = 0; i < numAFormats; i++) aformats[i] = pq_getmsgint(msgBuf, 2); } diff --git a/src/backend/tsearch/wparser_def.c b/src/backend/tsearch/wparser_def.c index 9fbeab47545..e04b7f11ace 100644 --- a/src/backend/tsearch/wparser_def.c +++ b/src/backend/tsearch/wparser_def.c @@ -2251,7 +2251,7 @@ mark_hl_fragments(HeadlineParsedText *prs, TSQuery query, List *locations, maxitems; CoverPos *covers; - covers = palloc(maxcovers * sizeof(CoverPos)); + covers = palloc(maxcovers * sizeof(*covers)); /* get all covers */ while (hlCover(prs, query, locations, &nextpos, &p, &q)) diff --git a/src/backend/utils/activity/pgstat_xact.c b/src/backend/utils/activity/pgstat_xact.c index bc9864bd8d9..dac619eaa75 100644 --- a/src/backend/utils/activity/pgstat_xact.c +++ b/src/backend/utils/activity/pgstat_xact.c @@ -286,7 +286,7 @@ pgstat_get_transactional_drops(bool isCommit, xl_xact_stats_item **items) Assert(!isCommit || xact_state->prev == NULL); *items = palloc(dclist_count(&xact_state->pending_drops) - * sizeof(xl_xact_stats_item)); + * sizeof(**items)); dclist_foreach(iter, &xact_state->pending_drops) { diff --git a/src/backend/utils/adt/acl.c b/src/backend/utils/adt/acl.c index 05d48412f82..a603f6a42ae 100644 --- a/src/backend/utils/adt/acl.c +++ b/src/backend/utils/adt/acl.c @@ -1553,7 +1553,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(ACL_NUM(acl) * 2 * sizeof(*list)); acldat = ACL_DAT(acl); /* diff --git a/src/backend/utils/adt/array_typanalyze.c b/src/backend/utils/adt/array_typanalyze.c index 61aedd31ff1..ecc4a4d9e1e 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 = (Datum *) palloc(num_mcelem * sizeof(*mcelem_values)); + mcelem_freqs = (float4 *) palloc((num_mcelem + 3) * sizeof(*mcelem_freqs)); /* * See comments above about use of nonnull_cnt as the divisor for diff --git a/src/backend/utils/adt/arrayfuncs.c b/src/backend/utils/adt/arrayfuncs.c index b67ce57656a..85a3912b295 100644 --- a/src/backend/utils/adt/arrayfuncs.c +++ b/src/backend/utils/adt/arrayfuncs.c @@ -1108,8 +1108,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 = (char **) palloc(nitems * sizeof(*values)); + needquotes = (bool *) palloc(nitems * sizeof(*needquotes)); overall_length = 0; array_iter_setup(&iter, v); @@ -1394,8 +1394,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 = (Datum *) palloc(nitems * sizeof(*dataPtr)); + nullsPtr = (bool *) palloc(nitems * sizeof(*nullsPtr)); ReadArrayBinary(buf, nitems, &my_extra->proc, typioparam, typmod, typlen, typbyval, typalign, @@ -3272,8 +3272,8 @@ array_map(Datum arrayd, typalign = ret_extra->typalign; /* Allocate temporary arrays for new values */ - values = (Datum *) palloc(nitems * sizeof(Datum)); - nulls = (bool *) palloc(nitems * sizeof(bool)); + values = (Datum *) palloc(nitems * sizeof(*values)); + nulls = (bool *) palloc(nitems * sizeof(*nulls)); /* Loop over source data */ array_iter_setup(&iter, v); @@ -4652,9 +4652,9 @@ 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)); + palloc(iterator->slice_len * sizeof(*iterator->slice_values)); iterator->slice_nulls = (bool *) - palloc(iterator->slice_len * sizeof(bool)); + palloc(iterator->slice_len * sizeof(*iterator->slice_nulls)); } /* @@ -6464,8 +6464,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 = (Datum *) palloc(nitems * sizeof(*values)); + nulls = (bool *) palloc(nitems * sizeof(*nulls)); /* 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 650bb51d4cd..a4f8dd25b2d 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 = (int32 *) palloc(*n * sizeof(*result)); 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 fcc6981632b..f810d96664d 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 = (Datum *) palloc(max * sizeof(*elems)); cnt = 0; left_found = !OidIsValid(lower); diff --git a/src/backend/utils/adt/formatting.c b/src/backend/utils/adt/formatting.c index a4570471bba..7bbdd0014ab 100644 --- a/src/backend/utils/adt/formatting.c +++ b/src/backend/utils/adt/formatting.c @@ -3922,7 +3922,7 @@ datetime_to_char_body(TmToChar *tmtc, const text *fmt, bool is_interval, Oid col */ incache = false; - format = (FormatNode *) palloc((fmt_len + 1) * sizeof(FormatNode)); + format = (FormatNode *) palloc((fmt_len + 1) * sizeof(*format)); parse_format(format, fmt_str, DCH_keywords, DCH_suff, DCH_index, DCH_FLAG, NULL); @@ -4337,7 +4337,7 @@ datetime_format_has_tz(const char *fmt_str) */ incache = false; - format = (FormatNode *) palloc((fmt_len + 1) * sizeof(FormatNode)); + format = (FormatNode *) palloc((fmt_len + 1) * sizeof(*format)); parse_format(format, fmt_str, DCH_keywords, DCH_suff, DCH_index, DCH_FLAG, NULL); @@ -4424,7 +4424,7 @@ do_to_timestamp(const text *date_txt, const text *fmt, Oid collid, bool std, * Allocate new memory if format picture is bigger than static * cache and do not use cache (call parser always) */ - format = (FormatNode *) palloc((fmt_len + 1) * sizeof(FormatNode)); + format = (FormatNode *) palloc((fmt_len + 1) * sizeof(*format)); parse_format(format, fmt_str, DCH_keywords, DCH_suff, DCH_index, DCH_FLAG | (std ? STD_FLAG : 0), NULL); @@ -4960,7 +4960,7 @@ NUM_cache(int len, NUMDesc *Num, const text *pars_str, bool *shouldFree) * Allocate new memory if format picture is bigger than static cache * and do not use cache (call parser always) */ - format = (FormatNode *) palloc((len + 1) * sizeof(FormatNode)); + format = (FormatNode *) palloc((len + 1) * sizeof(*format)); *shouldFree = true; diff --git a/src/backend/utils/adt/jsonfuncs.c b/src/backend/utils/adt/jsonfuncs.c index 980e2882957..35261e3d5cd 100644 --- a/src/backend/utils/adt/jsonfuncs.c +++ b/src/backend/utils/adt/jsonfuncs.c @@ -3552,8 +3552,8 @@ populate_record(TupleDesc tupdesc, record->ncolumns = ncolumns; } - values = (Datum *) palloc(ncolumns * sizeof(Datum)); - nulls = (bool *) palloc(ncolumns * sizeof(bool)); + values = (Datum *) palloc(ncolumns * sizeof(*values)); + nulls = (bool *) palloc(ncolumns * sizeof(*nulls)); if (defaultval) { @@ -3908,7 +3908,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((len + 1) * sizeof(*val)); memcpy(val, _state->save_json_start, len); val[len] = '\0'; @@ -4359,7 +4359,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((len + 1) * sizeof(*val)); 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 15a90f6f50c..b57be9894a8 100644 --- a/src/backend/utils/adt/levenshtein.c +++ b/src/backend/utils/adt/levenshtein.c @@ -195,7 +195,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 = (int *) palloc((m + 1) * sizeof(*s_char_len)); for (i = 0; i < m; ++i) { s_char_len[i] = pg_mblen(cp); @@ -209,7 +209,7 @@ varstr_levenshtein(const char *source, int slen, ++n; /* Previous and current rows of notional array. */ - prev = (int *) palloc(2 * m * sizeof(int)); + prev = (int *) palloc(2 * m * sizeof(*prev)); curr = prev + m; /* diff --git a/src/backend/utils/adt/lockfuncs.c b/src/backend/utils/adt/lockfuncs.c index bf38d68aa03..71a03797e60 100644 --- a/src/backend/utils/adt/lockfuncs.c +++ b/src/backend/utils/adt/lockfuncs.c @@ -476,7 +476,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 = (Datum *) palloc(lockData->nlocks * sizeof(*arrayelems)); narrayelems = 0; /* For each blocked proc in the lock group ... */ @@ -578,7 +578,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 = (int *) palloc(MaxBackends * sizeof(*blockers)); /* Collect a snapshot of processes waited for by GetSafeSnapshot */ num_blockers = @@ -589,7 +589,7 @@ pg_safe_snapshot_blocking_pids(PG_FUNCTION_ARGS) { int i; - blocker_datums = (Datum *) palloc(num_blockers * sizeof(Datum)); + blocker_datums = (Datum *) palloc(num_blockers * sizeof(*blocker_datums)); 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 169acf0ef63..a3b6f686794 100644 --- a/src/backend/utils/adt/multirangetypes.c +++ b/src/backend/utils/adt/multirangetypes.c @@ -1000,7 +1000,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(range_count * sizeof(*ranges)); for (i = 0; i < range_count; i++) { if (nulls[i]) @@ -1104,7 +1104,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(range_count3 * sizeof(*ranges3)); 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, @@ -1158,7 +1158,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((range_count1 + range_count2) * sizeof(*ranges3)); range_count3 = 0; /* @@ -1355,7 +1355,7 @@ multirange_intersect_internal(Oid mltrngtypoid, TypeCacheEntry *rangetyp, * but one extra won't hurt. *----------------------------------------------- */ - ranges3 = palloc0((range_count1 + range_count2) * sizeof(RangeType *)); + ranges3 = palloc0((range_count1 + range_count2) * sizeof(*ranges3)); range_count3 = 0; /* @@ -1468,7 +1468,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(range_count * sizeof(*ranges)); 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 b2487881d54..95aae677fb3 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 = (Datum *) palloc(list_length(search_path) * sizeof(*names)); i = 0; foreach(l, search_path) { diff --git a/src/backend/utils/adt/numeric.c b/src/backend/utils/adt/numeric.c index 2460698df01..e23c3752303 100644 --- a/src/backend/utils/adt/numeric.c +++ b/src/backend/utils/adt/numeric.c @@ -12016,8 +12016,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(accum_ndigits * sizeof(*new_pos_digits)); + new_neg_digits = palloc0(accum_ndigits * sizeof(*new_neg_digits)); if (accum->pos_digits) { @@ -12105,8 +12105,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(src->ndigits * sizeof(*dst->pos_digits)); + dst->neg_digits = palloc(src->ndigits * sizeof(*dst->neg_digits)); 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 a24a2d208fb..7e138f319bc 100644 --- a/src/backend/utils/adt/oracle_compat.c +++ b/src/backend/utils/adt/oracle_compat.c @@ -422,7 +422,7 @@ dotrim(const char *string, int stringlen, int str_len; stringchars = (const char **) palloc(stringlen * sizeof(char *)); - stringmblen = (int *) palloc(stringlen * sizeof(int)); + stringmblen = (int *) palloc(stringlen * sizeof(*stringmblen)); stringnchars = 0; p = string; len = stringlen; @@ -436,7 +436,7 @@ dotrim(const char *string, int stringlen, } setchars = (const char **) palloc(setlen * sizeof(char *)); - setmblen = (int *) palloc(setlen * sizeof(int)); + setmblen = (int *) palloc(setlen * sizeof(*setmblen)); setnchars = 0; p = set; len = setlen; diff --git a/src/backend/utils/adt/orderedsetaggs.c b/src/backend/utils/adt/orderedsetaggs.c index ac3963fc3e0..ce74bd9c8a7 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 = (AttrNumber *) palloc(numSortCols * sizeof(*qstate->sortColIdx)); + qstate->sortOperators = (Oid *) palloc(numSortCols * sizeof(*qstate->sortOperators)); + qstate->eqOperators = (Oid *) palloc(numSortCols * sizeof(*qstate->eqOperators)); + qstate->sortCollations = (Oid *) palloc(numSortCols * sizeof(*qstate->sortCollations)); + qstate->sortNullsFirsts = (bool *) palloc(numSortCols * sizeof(*qstate->sortNullsFirsts)); i = 0; foreach(lc, sortlist) @@ -668,7 +668,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 = (struct pct_info *) palloc(num_percentiles * sizeof(*pct_info)); for (i = 0; i < num_percentiles; i++) { @@ -774,8 +774,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 = (Datum *) palloc(num_percentiles * sizeof(*result_datum)); + result_isnull = (bool *) palloc(num_percentiles * sizeof(*result_isnull)); /* * Start by dealing with any nulls in the param array - those are sorted @@ -897,8 +897,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 = (Datum *) palloc(num_percentiles * sizeof(*result_datum)); + result_isnull = (bool *) palloc(num_percentiles * sizeof(*result_isnull)); /* * 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 8ff4353c4e7..ca6f1ebb53e 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(natts * sizeof(*item->attributes)); 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 45ea6cbc780..ae9ac76d172 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 = (Datum *) palloc(num_hist * sizeof(*bound_hist_values)); /* * 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 = (Datum *) palloc(num_hist * sizeof(*length_hist_values)); /* * The object of this loop is to copy the first and last lengths[] diff --git a/src/backend/utils/adt/rowtypes.c b/src/backend/utils/adt/rowtypes.c index 7220995ce21..8954249047b 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 = (Datum *) palloc(ncolumns1 * sizeof(*values1)); + nulls1 = (bool *) palloc(ncolumns1 * sizeof(*nulls1)); heap_deform_tuple(&tuple1, tupdesc1, values1, nulls1); - values2 = (Datum *) palloc(ncolumns2 * sizeof(Datum)); - nulls2 = (bool *) palloc(ncolumns2 * sizeof(bool)); + values2 = (Datum *) palloc(ncolumns2 * sizeof(*values2)); + nulls2 = (bool *) palloc(ncolumns2 * sizeof(*nulls2)); 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 = (Datum *) palloc(ncolumns1 * sizeof(*values1)); + nulls1 = (bool *) palloc(ncolumns1 * sizeof(*nulls1)); heap_deform_tuple(&tuple1, tupdesc1, values1, nulls1); - values2 = (Datum *) palloc(ncolumns2 * sizeof(Datum)); - nulls2 = (bool *) palloc(ncolumns2 * sizeof(bool)); + values2 = (Datum *) palloc(ncolumns2 * sizeof(*values2)); + nulls2 = (bool *) palloc(ncolumns2 * sizeof(*nulls2)); 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 = (Datum *) palloc(ncolumns1 * sizeof(*values1)); + nulls1 = (bool *) palloc(ncolumns1 * sizeof(*nulls1)); heap_deform_tuple(&tuple1, tupdesc1, values1, nulls1); - values2 = (Datum *) palloc(ncolumns2 * sizeof(Datum)); - nulls2 = (bool *) palloc(ncolumns2 * sizeof(bool)); + values2 = (Datum *) palloc(ncolumns2 * sizeof(*values2)); + nulls2 = (bool *) palloc(ncolumns2 * sizeof(*nulls2)); 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 = (Datum *) palloc(ncolumns1 * sizeof(*values1)); + nulls1 = (bool *) palloc(ncolumns1 * sizeof(*nulls1)); heap_deform_tuple(&tuple1, tupdesc1, values1, nulls1); - values2 = (Datum *) palloc(ncolumns2 * sizeof(Datum)); - nulls2 = (bool *) palloc(ncolumns2 * sizeof(bool)); + values2 = (Datum *) palloc(ncolumns2 * sizeof(*values2)); + nulls2 = (bool *) palloc(ncolumns2 * sizeof(*nulls2)); heap_deform_tuple(&tuple2, tupdesc2, values2, nulls2); /* diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c index 9f85eb86da1..100fbcf52c3 100644 --- a/src/backend/utils/adt/ruleutils.c +++ b/src/backend/utils/adt/ruleutils.c @@ -2569,7 +2569,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 = (Oid *) palloc(nElems * sizeof(*operators)); for (i = 0; i < nElems; i++) operators[i] = DatumGetObjectId(elems[i]); @@ -3771,7 +3771,7 @@ deparse_context_for_plan_tree(PlannedStmt *pstmt, List *rtable_names) ListCell *lc; dpns->appendrels = (AppendRelInfo **) - palloc0((ntables + 1) * sizeof(AppendRelInfo *)); + palloc0((ntables + 1) * sizeof(*dpns->appendrels)); foreach(lc, pstmt->appendRelations) { AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc); @@ -4400,7 +4400,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 = (char **) palloc(ncolumns * sizeof(*real_colnames)); for (i = 0; i < ncolumns; i++) { @@ -4444,7 +4444,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 = (char **) palloc(ncolumns * sizeof(*real_colnames)); i = 0; foreach(lc, colnames) @@ -4480,8 +4480,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 = (char **) palloc(ncolumns * sizeof(*colinfo->new_colnames)); + colinfo->is_new_col = (bool *) palloc(ncolumns * sizeof(*colinfo->is_new_col)); /* If the RTE is wide enough, use a hash table to avoid O(N^2) costs */ build_colinfo_names_hash(colinfo); @@ -4683,8 +4683,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 = (char **) palloc0(nnewcolumns * sizeof(*colinfo->new_colnames)); + colinfo->is_new_col = (bool *) palloc0(nnewcolumns * sizeof(*colinfo->is_new_col)); /* * Generating the new_colnames array is a bit tricky since any new columns @@ -5096,8 +5096,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 = (int *) palloc0(numjoincols * sizeof(*colinfo->leftattnos)); + colinfo->rightattnos = (int *) palloc0(numjoincols * sizeof(*colinfo->rightattnos)); /* * 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 c760b19db55..3eb1f8e16da 100644 --- a/src/backend/utils/adt/selfuncs.c +++ b/src/backend/utils/adt/selfuncs.c @@ -2436,8 +2436,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 = (bool *) palloc0(sslot1.nvalues * sizeof(*hasmatch1)); + hasmatch2 = (bool *) palloc0(sslot2.nvalues * sizeof(*hasmatch2)); /* * If the MCV lists are long enough to justify hashing, try to look up diff --git a/src/backend/utils/adt/tsquery_cleanup.c b/src/backend/utils/adt/tsquery_cleanup.c index 45de2da900c..8c47c21a647 100644 --- a/src/backend/utils/adt/tsquery_cleanup.c +++ b/src/backend/utils/adt/tsquery_cleanup.c @@ -102,7 +102,7 @@ plaintree(NODE *root, int *len) pl.len = 16; if (root && (root->valnode->type == QI_VAL || root->valnode->type == QI_OPR)) { - pl.ptr = (QueryItem *) palloc(pl.len * sizeof(QueryItem)); + pl.ptr = (QueryItem *) palloc(pl.len * sizeof(*pl.ptr)); plainnode(&pl, root); } else diff --git a/src/backend/utils/adt/tsquery_rewrite.c b/src/backend/utils/adt/tsquery_rewrite.c index 2f9e81fbfea..a1f1989d939 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 = (bool *) palloc0(node->nchild * sizeof(*matched)); nmatched = 0; i = j = 0; while (i < node->nchild && j < ex->nchild) diff --git a/src/backend/utils/adt/tsvector_op.c b/src/backend/utils/adt/tsvector_op.c index b809089ac5d..fb419102f23 100644 --- a/src/backend/utils/adt/tsvector_op.c +++ b/src/backend/utils/adt/tsvector_op.c @@ -594,7 +594,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(nlex * sizeof(*skip_indices)); for (i = skip_count = 0; i < nlex; i++) { char *lex; @@ -686,8 +686,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(posv->npos * sizeof(*positions)); + weights = palloc(posv->npos * sizeof(*weights)); for (j = 0; j < posv->npos; j++) { positions[j] = Int16GetDatum(WEP_GETPOS(posv->pos[j])); @@ -725,7 +725,7 @@ tsvector_to_array(PG_FUNCTION_ARGS) int i; ArrayType *array; - elements = palloc(tsin->size * sizeof(Datum)); + elements = palloc(tsin->size * sizeof(*elements)); for (i = 0; i < tsin->size; i++) { @@ -1539,7 +1539,7 @@ TS_phrase_output(ExecPhraseData *data, if (data->pos == NULL) { data->pos = (WordEntryPos *) - palloc(max_npos * sizeof(WordEntryPos)); + palloc(max_npos * sizeof(*data->pos)); data->allocated = true; } data->pos[data->npos++] = output_pos; diff --git a/src/backend/utils/adt/varlena.c b/src/backend/utils/adt/varlena.c index baa5b44ea8d..0be4180974e 100644 --- a/src/backend/utils/adt/varlena.c +++ b/src/backend/utils/adt/varlena.c @@ -3331,7 +3331,7 @@ replace_text_regexp(text *src_text, text *pattern_text, initStringInfo(&buf); /* Convert data string to wide characters. */ - data = (pg_wchar *) palloc((src_text_len + 1) * sizeof(pg_wchar)); + data = (pg_wchar *) palloc((src_text_len + 1) * sizeof(*data)); data_len = pg_mb2wchar_with_len(VARDATA_ANY(src_text), data, src_text_len); /* Check whether replace_text has escapes, especially regexp submatches. */ @@ -5464,7 +5464,7 @@ unicode_normalize_func(PG_FUNCTION_ARGS) /* convert to char32_t */ size = pg_mbstrlen_with_len(VARDATA_ANY(input), VARSIZE_ANY_EXHDR(input)); - input_chars = palloc((size + 1) * sizeof(char32_t)); + input_chars = palloc((size + 1) * sizeof(*input_chars)); p = (unsigned char *) VARDATA_ANY(input); for (i = 0; i < size; i++) { @@ -5532,7 +5532,7 @@ unicode_is_normalized(PG_FUNCTION_ARGS) /* convert to char32_t */ size = pg_mbstrlen_with_len(VARDATA_ANY(input), VARSIZE_ANY_EXHDR(input)); - input_chars = palloc((size + 1) * sizeof(char32_t)); + input_chars = palloc((size + 1) * sizeof(*input_chars)); p = (unsigned char *) VARDATA_ANY(input); for (i = 0; i < size; i++) { diff --git a/src/backend/utils/adt/xml.c b/src/backend/utils/adt/xml.c index c8ab9d61c68..715fb7d915f 100644 --- a/src/backend/utils/adt/xml.c +++ b/src/backend/utils/adt/xml.c @@ -1414,7 +1414,7 @@ xml_pnstrdup(const xmlChar *str, size_t len) { xmlChar *result; - result = (xmlChar *) palloc((len + 1) * sizeof(xmlChar)); + result = (xmlChar *) palloc((len + 1) * sizeof(*result)); memcpy(result, str, len * sizeof(xmlChar)); result[len] = 0; return result; @@ -1426,7 +1426,7 @@ pg_xmlCharStrndup(const char *str, size_t len) { xmlChar *result; - result = (xmlChar *) palloc((len + 1) * sizeof(xmlChar)); + result = (xmlChar *) palloc((len + 1) * sizeof(*result)); memcpy(result, str, len); result[len] = '\0'; diff --git a/src/backend/utils/cache/catcache.c b/src/backend/utils/cache/catcache.c index 1d09c66ac95..9a80880be58 100644 --- a/src/backend/utils/cache/catcache.c +++ b/src/backend/utils/cache/catcache.c @@ -936,7 +936,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(nbuckets * sizeof(*cp->cc_bucket)); /* * 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 868f8f6188f..eca88a1e369 100644 --- a/src/backend/utils/cache/inval.c +++ b/src/backend/utils/cache/inval.c @@ -1103,7 +1103,7 @@ inplaceGetInvalidationMessages(SharedInvalidationMessage **msgs, *RelcacheInitFileInval = inplaceInvalInfo->RelcacheInitFileInval; nummsgs = NumMessagesInGroup(&inplaceInvalInfo->CurrentCmdInvalidMsgs); *msgs = msgarray = (SharedInvalidationMessage *) - palloc(nummsgs * sizeof(SharedInvalidationMessage)); + palloc(nummsgs * sizeof(*msgarray)); nmsgs = 0; ProcessMessageSubGroupMulti(&inplaceInvalInfo->CurrentCmdInvalidMsgs, diff --git a/src/backend/utils/cache/lsyscache.c b/src/backend/utils/cache/lsyscache.c index 5aa7a26d95c..a07853763fc 100644 --- a/src/backend/utils/cache/lsyscache.c +++ b/src/backend/utils/cache/lsyscache.c @@ -1873,7 +1873,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 = (Oid *) palloc(*nargs * sizeof(**argtypes)); 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 a4dc1cbe5ae..b8a997a4f26 100644 --- a/src/backend/utils/cache/relcache.c +++ b/src/backend/utils/cache/relcache.c @@ -3109,7 +3109,7 @@ RememberToFreeTupleDescAtEOX(TupleDesc td) oldcxt = MemoryContextSwitchTo(CacheMemoryContext); - EOXactTupleDescArray = (TupleDesc *) palloc(16 * sizeof(TupleDesc)); + EOXactTupleDescArray = (TupleDesc *) palloc(16 * sizeof(*EOXactTupleDescArray)); EOXactTupleDescArrayLen = 16; NextEOXactTupleDescNum = 0; MemoryContextSwitchTo(oldcxt); @@ -6194,7 +6194,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 = (Relation *) palloc(max_rels * sizeof(*rels)); num_rels = 0; nailed_rels = nailed_indexes = 0; diff --git a/src/backend/utils/cache/typcache.c b/src/backend/utils/cache/typcache.c index 0c17d99d021..aca0f14d579 100644 --- a/src/backend/utils/cache/typcache.c +++ b/src/backend/utils/cache/typcache.c @@ -1218,7 +1218,7 @@ load_domaintype_info(TypeCacheEntry *typentry) { cconslen = 8; ccons = (DomainConstraintState **) - palloc(cconslen * sizeof(DomainConstraintState *)); + palloc(cconslen * sizeof(*ccons)); } else if (nccons >= cconslen) { diff --git a/src/backend/utils/fmgr/funcapi.c b/src/backend/utils/fmgr/funcapi.c index f40879f0617..5c138be33b0 100644 --- a/src/backend/utils/fmgr/funcapi.c +++ b/src/backend/utils/fmgr/funcapi.c @@ -1410,7 +1410,7 @@ get_func_arg_info(HeapTuple procTup, ARR_ELEMTYPE(arr) != OIDOID) elog(ERROR, "proallargtypes is not a 1-D Oid array or it contains nulls"); Assert(numargs >= procStruct->pronargs); - *p_argtypes = (Oid *) palloc(numargs * sizeof(Oid)); + *p_argtypes = (Oid *) palloc(numargs * sizeof(**p_argtypes)); memcpy(*p_argtypes, ARR_DATA_PTR(arr), numargs * sizeof(Oid)); } @@ -1419,7 +1419,7 @@ get_func_arg_info(HeapTuple procTup, /* If no proallargtypes, use proargtypes */ numargs = procStruct->proargtypes.dim1; Assert(numargs == procStruct->pronargs); - *p_argtypes = (Oid *) palloc(numargs * sizeof(Oid)); + *p_argtypes = (Oid *) palloc(numargs * sizeof(**p_argtypes)); memcpy(*p_argtypes, procStruct->proargtypes.values, numargs * sizeof(Oid)); } @@ -1456,7 +1456,7 @@ get_func_arg_info(HeapTuple procTup, ARR_ELEMTYPE(arr) != CHAROID) elog(ERROR, "proargmodes is not a 1-D char array of length %d or it contains nulls", numargs); - *p_argmodes = (char *) palloc(numargs * sizeof(char)); + *p_argmodes = (char *) palloc(numargs * sizeof(**p_argmodes)); memcpy(*p_argmodes, ARR_DATA_PTR(arr), numargs * sizeof(char)); } @@ -1498,7 +1498,7 @@ get_func_trftypes(HeapTuple procTup, ARR_HASNULL(arr) || ARR_ELEMTYPE(arr) != OIDOID) elog(ERROR, "protrftypes is not a 1-D Oid array or it contains nulls"); - *p_trftypes = (Oid *) palloc(nelems * sizeof(Oid)); + *p_trftypes = (Oid *) palloc(nelems * sizeof(**p_trftypes)); memcpy(*p_trftypes, ARR_DATA_PTR(arr), nelems * sizeof(Oid)); @@ -1570,7 +1570,7 @@ get_func_input_arg_names(Datum proargnames, Datum proargmodes, } /* extract input-argument names */ - inargnames = (char **) palloc(numargs * sizeof(char *)); + inargnames = (char **) palloc(numargs * sizeof(*inargnames)); numinargs = 0; for (i = 0; i < numargs; i++) { @@ -1809,8 +1809,8 @@ build_function_result_tupdesc_d(char prokind, return NULL; /* extract output-argument types and names */ - outargtypes = (Oid *) palloc(numargs * sizeof(Oid)); - outargnames = (char **) palloc(numargs * sizeof(char *)); + outargtypes = (Oid *) palloc(numargs * sizeof(*outargtypes)); + outargnames = (char **) palloc(numargs * sizeof(*outargnames)); numoutargs = 0; for (i = 0; i < numargs; i++) { @@ -2040,7 +2040,7 @@ extract_variadic_args(FunctionCallInfo fcinfo, int variadic_start, &nargs); /* All the elements of the array have the same type */ - types_res = (Oid *) palloc0(nargs * sizeof(Oid)); + types_res = (Oid *) palloc0(nargs * sizeof(*types_res)); for (i = 0; i < nargs; i++) types_res[i] = element_type; } @@ -2048,9 +2048,9 @@ extract_variadic_args(FunctionCallInfo fcinfo, int variadic_start, { nargs = PG_NARGS() - variadic_start; Assert(nargs > 0); - nulls_res = (bool *) palloc0(nargs * sizeof(bool)); - args_res = (Datum *) palloc0(nargs * sizeof(Datum)); - types_res = (Oid *) palloc0(nargs * sizeof(Oid)); + nulls_res = (bool *) palloc0(nargs * sizeof(*nulls_res)); + args_res = (Datum *) palloc0(nargs * sizeof(*args_res)); + types_res = (Oid *) palloc0(nargs * sizeof(*types_res)); for (i = 0; i < nargs; i++) { diff --git a/src/backend/utils/misc/ps_status.c b/src/backend/utils/misc/ps_status.c index 5d8de92a57b..ec688b211e7 100644 --- a/src/backend/utils/misc/ps_status.c +++ b/src/backend/utils/misc/ps_status.c @@ -200,7 +200,7 @@ save_ps_display_args(int argc, char **argv) /* * move the environment out of the way */ - new_environ = (char **) malloc((i + 1) * sizeof(char *)); + new_environ = (char **) malloc((i + 1) * sizeof(*new_environ)); if (!new_environ) { write_stderr("out of memory\n"); @@ -240,7 +240,7 @@ save_ps_display_args(int argc, char **argv) char **new_argv; int i; - new_argv = (char **) malloc((argc + 1) * sizeof(char *)); + new_argv = (char **) malloc((argc + 1) * sizeof(*new_argv)); if (!new_argv) { write_stderr("out of memory\n"); diff --git a/src/backend/utils/sort/logtape.c b/src/backend/utils/sort/logtape.c index 42bf50221b8..a2c7f1ae8ac 100644 --- a/src/backend/utils/sort/logtape.c +++ b/src/backend/utils/sort/logtape.c @@ -566,7 +566,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 = (int64 *) palloc(lts->freeBlocksLen * sizeof(*lts->freeBlocks)); lts->nFreeBlocks = 0; lts->enable_prealloc = preallocate; diff --git a/src/backend/utils/sort/tuplesort.c b/src/backend/utils/sort/tuplesort.c index 88ae529e843..a1cb8197519 100644 --- a/src/backend/utils/sort/tuplesort.c +++ b/src/backend/utils/sort/tuplesort.c @@ -788,7 +788,7 @@ tuplesort_begin_batch(Tuplesortstate *state) } if (state->memtuples == NULL) { - state->memtuples = (SortTuple *) palloc(state->memtupsize * sizeof(SortTuple)); + state->memtuples = (SortTuple *) palloc(state->memtupsize * sizeof(*state->memtuples)); USEMEM(state, GetMemoryChunkSpace(state->memtuples)); } @@ -1884,7 +1884,7 @@ inittapes(Tuplesortstate *state, bool mergeruns) state->nInputTapes = 0; state->nInputRuns = 0; - state->outputTapes = palloc0(state->maxTapes * sizeof(LogicalTape *)); + state->outputTapes = palloc0(state->maxTapes * sizeof(*state->outputTapes)); state->nOutputTapes = 0; state->nOutputRuns = 0; @@ -2109,7 +2109,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(state->nInputTapes * sizeof(*state->outputTapes)); state->nOutputTapes = 0; state->nOutputRuns = 0; @@ -3093,7 +3093,7 @@ leader_takeover_tapes(Tuplesortstate *state) state->nInputTapes = 0; state->nInputRuns = 0; - state->outputTapes = palloc0(nParticipants * sizeof(LogicalTape *)); + state->outputTapes = palloc0(nParticipants * sizeof(*state->outputTapes)); state->nOutputTapes = nParticipants; state->nOutputRuns = nParticipants; diff --git a/src/backend/utils/sort/tuplestore.c b/src/backend/utils/sort/tuplestore.c index def945b0454..5b651233458 100644 --- a/src/backend/utils/sort/tuplestore.c +++ b/src/backend/utils/sort/tuplestore.c @@ -290,7 +290,7 @@ 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 = (void **) palloc(state->memtupsize * sizeof(*state->memtuples)); USEMEM(state, GetMemoryChunkSpace(state->memtuples)); @@ -298,7 +298,7 @@ tuplestore_begin_common(int eflags, bool interXact, int maxKBytes) state->readptrcount = 1; state->readptrsize = 8; /* arbitrary */ state->readptrs = (TSReadPointer *) - palloc(state->readptrsize * sizeof(TSReadPointer)); + palloc(state->readptrsize * sizeof(*state->readptrs)); state->readptrs[0].eflags = eflags; state->readptrs[0].eof_reached = false; diff --git a/src/backend/utils/time/snapmgr.c b/src/backend/utils/time/snapmgr.c index 40a2e90e071..f98bd0b6c94 100644 --- a/src/backend/utils/time/snapmgr.c +++ b/src/backend/utils/time/snapmgr.c @@ -1489,7 +1489,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 = (TransactionId *) palloc(xcnt * sizeof(*snapshot.xip)); for (i = 0; i < xcnt; i++) snapshot.xip[i] = parseXidFromText("xip:", &filebuf, path); @@ -1505,7 +1505,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 = (TransactionId *) palloc(xcnt * sizeof(*snapshot.subxip)); for (i = 0; i < xcnt; i++) snapshot.subxip[i] = parseXidFromText("sxp:", &filebuf, path); } diff --git a/src/bin/initdb/initdb.c b/src/bin/initdb/initdb.c index 92fe2f531f7..92393fdbede 100644 --- a/src/bin/initdb/initdb.c +++ b/src/bin/initdb/initdb.c @@ -444,7 +444,7 @@ escape_quotes_bki(const char *src) static void add_stringlist_item(_stringlist **listhead, const char *str) { - _stringlist *newentry = pg_malloc(sizeof(_stringlist)); + _stringlist *newentry = pg_malloc(sizeof(*newentry)); _stringlist *oldentry; newentry->str = pg_strdup(str); @@ -687,7 +687,7 @@ readfile(const char *path) initStringInfo(&line); maxlines = 1024; - result = (char **) pg_malloc(maxlines * sizeof(char *)); + result = (char **) pg_malloc(maxlines * sizeof(*result)); n = 0; while (pg_get_line_buf(infile, &line)) diff --git a/src/bin/pg_amcheck/pg_amcheck.c b/src/bin/pg_amcheck/pg_amcheck.c index 2b1fd566c35..b92b42d0761 100644 --- a/src/bin/pg_amcheck/pg_amcheck.c +++ b/src/bin/pg_amcheck/pg_amcheck.c @@ -1593,7 +1593,7 @@ compile_database_list(PGconn *conn, SimplePtrList *databases, if (initial_dbname) { - DatabaseInfo *dat = (DatabaseInfo *) pg_malloc0(sizeof(DatabaseInfo)); + DatabaseInfo *dat = (DatabaseInfo *) pg_malloc0(sizeof(*dat)); /* This database is included. Add to list */ if (opts.verbose) @@ -1738,7 +1738,7 @@ compile_database_list(PGconn *conn, SimplePtrList *databases, if (opts.verbose) pg_log_info("including database \"%s\"", datname); - dat = (DatabaseInfo *) pg_malloc0(sizeof(DatabaseInfo)); + dat = (DatabaseInfo *) pg_malloc0(sizeof(*dat)); dat->datname = pstrdup(datname); simple_ptr_list_append(databases, dat); } @@ -2202,7 +2202,7 @@ compile_relation_list_one_db(PGconn *conn, SimplePtrList *relations, { /* Current record pertains to a relation */ - RelationInfo *rel = (RelationInfo *) pg_malloc0(sizeof(RelationInfo)); + RelationInfo *rel = (RelationInfo *) pg_malloc0(sizeof(*rel)); Assert(OidIsValid(oid)); Assert((is_heap && !is_btree) || (is_btree && !is_heap)); diff --git a/src/bin/pg_basebackup/pg_basebackup.c b/src/bin/pg_basebackup/pg_basebackup.c index 0a3ca4315de..d8ca8781aea 100644 --- a/src/bin/pg_basebackup/pg_basebackup.c +++ b/src/bin/pg_basebackup/pg_basebackup.c @@ -320,7 +320,7 @@ kill_bgchild_atexit(void) static void tablespace_list_append(const char *arg) { - TablespaceListCell *cell = (TablespaceListCell *) pg_malloc0(sizeof(TablespaceListCell)); + TablespaceListCell *cell = (TablespaceListCell *) pg_malloc0(sizeof(*cell)); char *dst; char *dst_ptr; const char *arg_ptr; @@ -623,7 +623,7 @@ StartLogStreamer(char *startpos, uint32 timeline, char *sysidentifier, lo; char statusdir[MAXPGPATH]; - param = pg_malloc0(sizeof(logstreamer_param)); + param = pg_malloc0(sizeof(*param)); param->timeline = timeline; param->sysidentifier = sysidentifier; param->wal_compress_algorithm = wal_compress_algorithm; diff --git a/src/bin/pg_basebackup/walmethods.c b/src/bin/pg_basebackup/walmethods.c index eaaabc5f374..beca6c39b9d 100644 --- a/src/bin/pg_basebackup/walmethods.c +++ b/src/bin/pg_basebackup/walmethods.c @@ -102,7 +102,7 @@ static char * dir_get_file_name(WalWriteMethod *wwmethod, const char *pathname, const char *temp_suffix) { - char *filename = pg_malloc0(MAXPGPATH * sizeof(char)); + char *filename = pg_malloc0(MAXPGPATH * sizeof(*filename)); snprintf(filename, MAXPGPATH, "%s%s%s", pathname, @@ -275,7 +275,7 @@ dir_open_for_write(WalWriteMethod *wwmethod, const char *pathname, } } - f = pg_malloc0(sizeof(DirectoryMethodFile)); + f = pg_malloc0(sizeof(*f)); #ifdef HAVE_LIBZ if (wwmethod->compression_algorithm == PG_COMPRESSION_GZIP) f->gzfp = gzfp; @@ -643,7 +643,7 @@ CreateWalDirectoryMethod(const char *basedir, { DirectoryMethodData *wwmethod; - wwmethod = pg_malloc0(sizeof(DirectoryMethodData)); + wwmethod = pg_malloc0(sizeof(*wwmethod)); *((const WalWriteMethodOps **) &wwmethod->base.ops) = &WalDirectoryMethodOps; wwmethod->base.compression_algorithm = compression_algorithm; @@ -825,7 +825,7 @@ static char * tar_get_file_name(WalWriteMethod *wwmethod, const char *pathname, const char *temp_suffix) { - char *filename = pg_malloc0(MAXPGPATH * sizeof(char)); + char *filename = pg_malloc0(MAXPGPATH * sizeof(*filename)); snprintf(filename, MAXPGPATH, "%s%s", pathname, temp_suffix ? temp_suffix : ""); @@ -893,7 +893,7 @@ tar_open_for_write(WalWriteMethod *wwmethod, const char *pathname, return NULL; } - tar_data->currentfile = pg_malloc0(sizeof(TarMethodFile)); + tar_data->currentfile = pg_malloc0(sizeof(*tar_data->currentfile)); tar_data->currentfile->base.wwmethod = wwmethod; tmppath = tar_get_file_name(wwmethod, pathname, temp_suffix); @@ -1360,7 +1360,7 @@ CreateWalTarMethod(const char *tarbase, const char *suffix = (compression_algorithm == PG_COMPRESSION_GZIP) ? ".tar.gz" : ".tar"; - wwmethod = pg_malloc0(sizeof(TarMethodData)); + wwmethod = pg_malloc0(sizeof(*wwmethod)); *((const WalWriteMethodOps **) &wwmethod->base.ops) = &WalTarMethodOps; wwmethod->base.compression_algorithm = compression_algorithm; diff --git a/src/bin/pg_combinebackup/load_manifest.c b/src/bin/pg_combinebackup/load_manifest.c index 44db0d2b164..c60e82adde6 100644 --- a/src/bin/pg_combinebackup/load_manifest.c +++ b/src/bin/pg_combinebackup/load_manifest.c @@ -139,7 +139,7 @@ load_backup_manifest(char *backup_directory) /* Create the hash table. */ ht = manifest_files_create(initial_size, NULL); - result = pg_malloc0(sizeof(manifest_data)); + result = pg_malloc0(sizeof(*result)); result->files = ht; context.private_data = result; context.version_cb = combinebackup_version_cb; diff --git a/src/bin/pg_combinebackup/pg_combinebackup.c b/src/bin/pg_combinebackup/pg_combinebackup.c index c9bf0a9e105..0cb001fe9a5 100644 --- a/src/bin/pg_combinebackup/pg_combinebackup.c +++ b/src/bin/pg_combinebackup/pg_combinebackup.c @@ -455,7 +455,7 @@ main(int argc, char *argv[]) static void add_tablespace_mapping(cb_options *opt, char *arg) { - cb_tablespace_mapping *tsmap = pg_malloc0(sizeof(cb_tablespace_mapping)); + cb_tablespace_mapping *tsmap = pg_malloc0(sizeof(*tsmap)); char *dst; char *dst_ptr; char *arg_ptr; @@ -1171,7 +1171,7 @@ process_directory_recursively(Oid tsoid, static void remember_to_cleanup_directory(char *target_path, bool rmtopdir) { - cb_cleanup_dir *dir = pg_malloc(sizeof(cb_cleanup_dir)); + cb_cleanup_dir *dir = pg_malloc(sizeof(*dir)); dir->target_path = target_path; dir->rmtopdir = rmtopdir; @@ -1259,7 +1259,7 @@ scan_for_existing_tablespaces(char *pathname, cb_options *opt) } /* Create a new tablespace object. */ - ts = pg_malloc0(sizeof(cb_tablespace)); + ts = pg_malloc0(sizeof(*ts)); ts->oid = oid; /* diff --git a/src/bin/pg_combinebackup/reconstruct.c b/src/bin/pg_combinebackup/reconstruct.c index 38d8e8a2dc9..d0718aab3c7 100644 --- a/src/bin/pg_combinebackup/reconstruct.c +++ b/src/bin/pg_combinebackup/reconstruct.c @@ -120,7 +120,7 @@ reconstruct_from_incremental_file(char *input_filename, * Every block must come either from the latest version of the file or * from one of the prior backups. */ - source = pg_malloc0(sizeof(rfile *) * (1 + n_prior_backups)); + source = pg_malloc0(sizeof(*source) * (1 + n_prior_backups)); /* * Use the information from the latest incremental file to figure out how @@ -135,8 +135,8 @@ reconstruct_from_incremental_file(char *input_filename, * need to obtain it and at what offset in that file it's stored. * sourcemap gives us the first of these things, and offsetmap the latter. */ - sourcemap = pg_malloc0(sizeof(rfile *) * block_length); - offsetmap = pg_malloc0(sizeof(off_t) * block_length); + sourcemap = pg_malloc0(sizeof(*sourcemap) * block_length); + offsetmap = pg_malloc0(sizeof(*offsetmap) * block_length); /* * Every block that is present in the newest incremental file should be @@ -483,7 +483,7 @@ make_incremental_rfile(char *filename) if (rf->num_blocks > 0) { rf->relative_block_numbers = - pg_malloc0(sizeof(BlockNumber) * rf->num_blocks); + pg_malloc0(sizeof(*rf->relative_block_numbers) * rf->num_blocks); read_bytes(rf, rf->relative_block_numbers, sizeof(BlockNumber) * rf->num_blocks); } @@ -512,7 +512,7 @@ make_rfile(char *filename, bool missing_ok) { rfile *rf; - rf = pg_malloc0(sizeof(rfile)); + rf = pg_malloc0(sizeof(*rf)); rf->filename = pstrdup(filename); if ((rf->fd = open(filename, O_RDONLY | PG_BINARY, 0)) < 0) { diff --git a/src/bin/pg_combinebackup/write_manifest.c b/src/bin/pg_combinebackup/write_manifest.c index c845175a82c..43efb6c2696 100644 --- a/src/bin/pg_combinebackup/write_manifest.c +++ b/src/bin/pg_combinebackup/write_manifest.c @@ -47,7 +47,7 @@ static size_t hex_encode(const uint8 *src, size_t len, char *dst); manifest_writer * create_manifest_writer(char *directory, uint64 system_identifier) { - manifest_writer *mwriter = pg_malloc(sizeof(manifest_writer)); + manifest_writer *mwriter = pg_malloc(sizeof(*mwriter)); snprintf(mwriter->pathname, MAXPGPATH, "%s/backup_manifest", directory); mwriter->fd = -1; diff --git a/src/bin/pg_ctl/pg_ctl.c b/src/bin/pg_ctl/pg_ctl.c index dfe7b4d2f9e..cd8916d78f2 100644 --- a/src/bin/pg_ctl/pg_ctl.c +++ b/src/bin/pg_ctl/pg_ctl.c @@ -346,7 +346,7 @@ readfile(const char *path, int *numlines) { /* empty file */ close(fd); - result = (char **) pg_malloc(sizeof(char *)); + result = (char **) pg_malloc(sizeof(*result)); *result = NULL; return result; } @@ -374,7 +374,7 @@ readfile(const char *path, int *numlines) } /* set up the result buffer */ - result = (char **) pg_malloc((nlines + 1) * sizeof(char *)); + result = (char **) pg_malloc((nlines + 1) * sizeof(*result)); *numlines = nlines; /* now split the buffer into lines */ diff --git a/src/bin/pg_dump/compress_gzip.c b/src/bin/pg_dump/compress_gzip.c index be31209f811..99b5b2746f5 100644 --- a/src/bin/pg_dump/compress_gzip.c +++ b/src/bin/pg_dump/compress_gzip.c @@ -57,7 +57,7 @@ DeflateCompressorInit(CompressorState *cs) GzipCompressorState *gzipcs; z_streamp zp; - gzipcs = (GzipCompressorState *) pg_malloc0(sizeof(GzipCompressorState)); + gzipcs = (GzipCompressorState *) pg_malloc0(sizeof(*gzipcs)); zp = gzipcs->zp = (z_streamp) pg_malloc(sizeof(z_stream)); zp->zalloc = Z_NULL; zp->zfree = Z_NULL; diff --git a/src/bin/pg_dump/compress_io.c b/src/bin/pg_dump/compress_io.c index 9cadc6f2a3f..6faad249121 100644 --- a/src/bin/pg_dump/compress_io.c +++ b/src/bin/pg_dump/compress_io.c @@ -125,7 +125,7 @@ AllocateCompressor(const pg_compress_specification compression_spec, { CompressorState *cs; - cs = (CompressorState *) pg_malloc0(sizeof(CompressorState)); + cs = (CompressorState *) pg_malloc0(sizeof(*cs)); cs->readF = readF; cs->writeF = writeF; @@ -195,7 +195,7 @@ InitCompressFileHandle(const pg_compress_specification compression_spec) { CompressFileHandle *CFH; - CFH = pg_malloc0(sizeof(CompressFileHandle)); + CFH = pg_malloc0(sizeof(*CFH)); if (compression_spec.algorithm == PG_COMPRESSION_NONE) InitCompressFileHandleNone(CFH, compression_spec); diff --git a/src/bin/pg_dump/compress_none.c b/src/bin/pg_dump/compress_none.c index 94c155a572d..996acb775e2 100644 --- a/src/bin/pg_dump/compress_none.c +++ b/src/bin/pg_dump/compress_none.c @@ -124,7 +124,7 @@ InitCompressorNone(CompressorState *cs, { NoneCompressorState *nonecs; - nonecs = (NoneCompressorState *) pg_malloc(sizeof(NoneCompressorState)); + nonecs = (NoneCompressorState *) pg_malloc(sizeof(*nonecs)); nonecs->buflen = DEFAULT_IO_BUFFER_SIZE; nonecs->buffer = pg_malloc(nonecs->buflen); nonecs->bufdata = 0; diff --git a/src/bin/pg_dump/dumputils.c b/src/bin/pg_dump/dumputils.c index 2d22723aa91..55860259d9e 100644 --- a/src/bin/pg_dump/dumputils.c +++ b/src/bin/pg_dump/dumputils.c @@ -160,7 +160,7 @@ buildACLCommands(const char *name, const char *subname, const char *nspname, * Besides, a false mismatch will just cause the output to be a little * more verbose than it really needed to be. */ - grantitems = (char **) pg_malloc(naclitems * sizeof(char *)); + grantitems = (char **) pg_malloc(naclitems * sizeof(*grantitems)); for (i = 0; i < naclitems; i++) { bool found = false; @@ -176,7 +176,7 @@ buildACLCommands(const char *name, const char *subname, const char *nspname, if (!found) grantitems[ngrantitems++] = aclitems[i]; } - revokeitems = (char **) pg_malloc(nbaseitems * sizeof(char *)); + revokeitems = (char **) pg_malloc(nbaseitems * sizeof(*revokeitems)); for (i = 0; i < nbaseitems; i++) { bool found = false; @@ -774,7 +774,7 @@ SplitGUCList(char *rawstring, char separator, * list terminator. */ *namelist = nextptr = (char **) - pg_malloc((strlen(rawstring) / 2 + 2) * sizeof(char *)); + pg_malloc((strlen(rawstring) / 2 + 2) * sizeof(*nextptr)); *nextptr = NULL; while (isspace((unsigned char) *nextp)) diff --git a/src/bin/pg_dump/parallel.c b/src/bin/pg_dump/parallel.c index 086adcdc502..92ace7d5ddf 100644 --- a/src/bin/pg_dump/parallel.c +++ b/src/bin/pg_dump/parallel.c @@ -469,7 +469,7 @@ WaitForTerminatingWorkers(ParallelState *pstate) } #else /* WIN32 */ /* On Windows, we must use WaitForMultipleObjects() */ - HANDLE *lpHandles = pg_malloc(sizeof(HANDLE) * pstate->numWorkers); + HANDLE *lpHandles = pg_malloc(sizeof(*lpHandles) * pstate->numWorkers); int nrun = 0; DWORD ret; uintptr_t hThread; @@ -903,7 +903,7 @@ ParallelBackupStart(ArchiveHandle *AH) Assert(AH->public.numWorkers > 0); - pstate = (ParallelState *) pg_malloc(sizeof(ParallelState)); + pstate = (ParallelState *) pg_malloc(sizeof(*pstate)); pstate->numWorkers = AH->public.numWorkers; pstate->te = NULL; @@ -914,9 +914,9 @@ ParallelBackupStart(ArchiveHandle *AH) /* Create status arrays, being sure to initialize all fields to 0 */ pstate->te = (TocEntry **) - pg_malloc0(pstate->numWorkers * sizeof(TocEntry *)); + pg_malloc0(pstate->numWorkers * sizeof(*pstate->te)); pstate->parallelSlot = (ParallelSlot *) - pg_malloc0(pstate->numWorkers * sizeof(ParallelSlot)); + pg_malloc0(pstate->numWorkers * sizeof(*pstate->parallelSlot)); #ifdef WIN32 /* Make fmtId() and fmtQualifiedId() use thread-local storage */ @@ -969,7 +969,7 @@ ParallelBackupStart(ArchiveHandle *AH) #ifdef WIN32 /* Create transient structure to pass args to worker function */ - wi = (WorkerInfo *) pg_malloc(sizeof(WorkerInfo)); + wi = (WorkerInfo *) pg_malloc(sizeof(*wi)); wi->AH = AH; wi->slot = slot; diff --git a/src/bin/pg_dump/pg_backup_archiver.c b/src/bin/pg_dump/pg_backup_archiver.c index 4a63f7392ae..f7687627152 100644 --- a/src/bin/pg_dump/pg_backup_archiver.c +++ b/src/bin/pg_dump/pg_backup_archiver.c @@ -134,7 +134,7 @@ static void StrictNamesCheck(RestoreOptions *ropt); DumpOptions * NewDumpOptions(void) { - DumpOptions *opts = (DumpOptions *) pg_malloc(sizeof(DumpOptions)); + DumpOptions *opts = (DumpOptions *) pg_malloc(sizeof(*opts)); InitDumpOptions(opts); return opts; @@ -1107,7 +1107,7 @@ NewRestoreOptions(void) { RestoreOptions *opts; - opts = (RestoreOptions *) pg_malloc0(sizeof(RestoreOptions)); + opts = (RestoreOptions *) pg_malloc0(sizeof(*opts)); /* set any fields that shouldn't default to zeroes */ opts->format = archUnknown; @@ -1244,7 +1244,7 @@ ArchiveEntry(Archive *AHX, CatalogId catalogId, DumpId dumpId, ArchiveHandle *AH = (ArchiveHandle *) AHX; TocEntry *newToc; - newToc = (TocEntry *) pg_malloc0(sizeof(TocEntry)); + newToc = (TocEntry *) pg_malloc0(sizeof(*newToc)); AH->tocCount++; if (dumpId > AH->maxDumpId) @@ -1272,7 +1272,7 @@ ArchiveEntry(Archive *AHX, CatalogId catalogId, DumpId dumpId, if (opts->nDeps > 0) { - newToc->dependencies = (DumpId *) pg_malloc(opts->nDeps * sizeof(DumpId)); + newToc->dependencies = (DumpId *) pg_malloc(opts->nDeps * sizeof(*newToc->dependencies)); memcpy(newToc->dependencies, opts->deps, opts->nDeps * sizeof(DumpId)); newToc->nDeps = opts->nDeps; } @@ -1575,7 +1575,7 @@ SortTocFromFile(Archive *AHX) StringInfoData linebuf; /* Allocate space for the 'wanted' array, and init it */ - ropt->idWanted = (bool *) pg_malloc0(sizeof(bool) * AH->maxDumpId); + ropt->idWanted = (bool *) pg_malloc0(sizeof(*ropt->idWanted) * AH->maxDumpId); /* Setup the file */ fh = fopen(ropt->tocFile, PG_BINARY_R); @@ -1991,7 +1991,7 @@ buildTocEntryArrays(ArchiveHandle *AH) TocEntry *te; AH->tocsByDumpId = (TocEntry **) pg_malloc0((maxDumpId + 1) * sizeof(TocEntry *)); - AH->tableDataId = (DumpId *) pg_malloc0((maxDumpId + 1) * sizeof(DumpId)); + AH->tableDataId = (DumpId *) pg_malloc0((maxDumpId + 1) * sizeof(*AH->tableDataId)); for (te = AH->toc->next; te != AH->toc; te = te->next) { @@ -2385,7 +2385,7 @@ _allocAH(const char *FileSpec, const ArchiveFormat fmt, pg_log_debug("allocating AH for %s, format %d", FileSpec ? FileSpec : "(stdio)", fmt); - AH = (ArchiveHandle *) pg_malloc0(sizeof(ArchiveHandle)); + AH = (ArchiveHandle *) pg_malloc0(sizeof(*AH)); AH->version = K_VERS_SELF; @@ -2509,7 +2509,7 @@ WriteDataChunks(ArchiveHandle *AH, ParallelState *pstate) TocEntry **tes; int ntes; - tes = (TocEntry **) pg_malloc(AH->tocCount * sizeof(TocEntry *)); + tes = (TocEntry **) pg_malloc(AH->tocCount * sizeof(*tes)); ntes = 0; for (te = AH->toc->next; te != AH->toc; te = te->next) { @@ -2720,7 +2720,7 @@ ReadToc(ArchiveHandle *AH) for (i = 0; i < AH->tocCount; i++) { - te = (TocEntry *) pg_malloc0(sizeof(TocEntry)); + te = (TocEntry *) pg_malloc0(sizeof(*te)); te->dumpId = ReadInt(AH); if (te->dumpId > AH->maxDumpId) @@ -2817,7 +2817,7 @@ ReadToc(ArchiveHandle *AH) if (AH->version >= K_VERS_1_5) { depSize = 100; - deps = (DumpId *) pg_malloc(sizeof(DumpId) * depSize); + deps = (DumpId *) pg_malloc(sizeof(*deps) * depSize); depIdx = 0; for (;;) { @@ -4883,7 +4883,7 @@ fix_dependencies(ArchiveHandle *AH) { if (strcmp(te2->desc, "BLOBS") == 0) { - te->dependencies = (DumpId *) pg_malloc(sizeof(DumpId)); + te->dependencies = (DumpId *) pg_malloc(sizeof(*te->dependencies)); te->dependencies[0] = te2->dumpId; te->nDeps++; te->depCount++; @@ -4926,7 +4926,7 @@ fix_dependencies(ArchiveHandle *AH) for (te = AH->toc->next; te != AH->toc; te = te->next) { if (te->nRevDeps > 0) - te->revDeps = (DumpId *) pg_malloc(te->nRevDeps * sizeof(DumpId)); + te->revDeps = (DumpId *) pg_malloc(te->nRevDeps * sizeof(*te->revDeps)); te->nRevDeps = 0; } @@ -5041,7 +5041,7 @@ identify_locking_dependencies(ArchiveHandle *AH, TocEntry *te) * difference between a dependency on a table and a dependency on its * data, so that closer analysis would be needed here. */ - lockids = (DumpId *) pg_malloc(te->nDeps * sizeof(DumpId)); + lockids = (DumpId *) pg_malloc(te->nDeps * sizeof(*lockids)); nlockids = 0; for (i = 0; i < te->nDeps; i++) { @@ -5149,11 +5149,11 @@ CloneArchive(ArchiveHandle *AH) ArchiveHandle *clone; /* Make a "flat" copy */ - clone = (ArchiveHandle *) pg_malloc(sizeof(ArchiveHandle)); + clone = (ArchiveHandle *) pg_malloc(sizeof(*clone)); memcpy(clone, AH, sizeof(ArchiveHandle)); /* Likewise flat-copy the RestoreOptions, so we can alter them locally */ - clone->public.ropt = (RestoreOptions *) pg_malloc(sizeof(RestoreOptions)); + clone->public.ropt = (RestoreOptions *) pg_malloc(sizeof(*clone->public.ropt)); memcpy(clone->public.ropt, AH->public.ropt, sizeof(RestoreOptions)); /* Handle format-independent fields */ diff --git a/src/bin/pg_dump/pg_backup_custom.c b/src/bin/pg_dump/pg_backup_custom.c index 2226520dffc..985fc74d18d 100644 --- a/src/bin/pg_dump/pg_backup_custom.c +++ b/src/bin/pg_dump/pg_backup_custom.c @@ -136,7 +136,7 @@ InitArchiveFmt_Custom(ArchiveHandle *AH) AH->WorkerJobRestorePtr = _WorkerJobRestoreCustom; /* Set up a private area. */ - ctx = (lclContext *) pg_malloc0(sizeof(lclContext)); + ctx = (lclContext *) pg_malloc0(sizeof(*ctx)); AH->formatData = ctx; /* @@ -199,7 +199,7 @@ _ArchiveEntry(ArchiveHandle *AH, TocEntry *te) { lclTocEntry *ctx; - ctx = (lclTocEntry *) pg_malloc0(sizeof(lclTocEntry)); + ctx = (lclTocEntry *) pg_malloc0(sizeof(*ctx)); if (te->dataDumper) ctx->dataState = K_OFFSET_POS_NOT_SET; else @@ -240,7 +240,7 @@ _ReadExtraToc(ArchiveHandle *AH, TocEntry *te) if (ctx == NULL) { - ctx = (lclTocEntry *) pg_malloc0(sizeof(lclTocEntry)); + ctx = (lclTocEntry *) pg_malloc0(sizeof(*ctx)); te->formatData = ctx; } diff --git a/src/bin/pg_dump/pg_backup_directory.c b/src/bin/pg_dump/pg_backup_directory.c index 94d401d8a4e..cebc505ea40 100644 --- a/src/bin/pg_dump/pg_backup_directory.c +++ b/src/bin/pg_dump/pg_backup_directory.c @@ -140,7 +140,7 @@ InitArchiveFmt_Directory(ArchiveHandle *AH) AH->WorkerJobDumpPtr = _WorkerJobDumpDirectory; /* Set up our private context */ - ctx = (lclContext *) pg_malloc0(sizeof(lclContext)); + ctx = (lclContext *) pg_malloc0(sizeof(*ctx)); AH->formatData = ctx; ctx->dataFH = NULL; @@ -200,7 +200,7 @@ _ArchiveEntry(ArchiveHandle *AH, TocEntry *te) lclTocEntry *tctx; char fn[MAXPGPATH]; - tctx = (lclTocEntry *) pg_malloc0(sizeof(lclTocEntry)); + tctx = (lclTocEntry *) pg_malloc0(sizeof(*tctx)); if (strcmp(te->desc, "BLOBS") == 0) { snprintf(fn, MAXPGPATH, "blobs_%d.toc", te->dumpId); @@ -252,7 +252,7 @@ _ReadExtraToc(ArchiveHandle *AH, TocEntry *te) if (tctx == NULL) { - tctx = (lclTocEntry *) pg_malloc0(sizeof(lclTocEntry)); + tctx = (lclTocEntry *) pg_malloc0(sizeof(*tctx)); te->formatData = tctx; } diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c index 24ad201af2f..16f74738976 100644 --- a/src/bin/pg_dump/pg_dump.c +++ b/src/bin/pg_dump/pg_dump.c @@ -1542,7 +1542,7 @@ setup_connection(Archive *AH, const char *dumpencoding, * Initialize prepared-query state to "nothing prepared". We do this here * so that a parallel dump worker will have its own state. */ - AH->is_prepared = (bool *) pg_malloc0(NUM_PREP_QUERIES * sizeof(bool)); + AH->is_prepared = (bool *) pg_malloc0(NUM_PREP_QUERIES * sizeof(*AH->is_prepared)); /* * Start transaction-snapshot mode transaction to dump consistent data. @@ -2570,7 +2570,7 @@ dumpTableData_insert(Archive *fout, const void *dcontext) * actual column value --- but we can save a few cycles by fetching nulls * rather than the uninteresting-to-us value. */ - attgenerated = (char *) pg_malloc(tbinfo->numatts * sizeof(char)); + attgenerated = (char *) pg_malloc(tbinfo->numatts * sizeof(*attgenerated)); appendPQExpBufferStr(q, "DECLARE _pg_dump_cursor CURSOR FOR SELECT "); nfields = 0; for (i = 0; i < tbinfo->numatts; i++) @@ -3071,7 +3071,7 @@ makeTableDataInfo(DumpOptions *dopt, TableInfo *tbinfo) return; /* OK, let's dump it */ - tdinfo = (TableDataInfo *) pg_malloc(sizeof(TableDataInfo)); + tdinfo = (TableDataInfo *) pg_malloc(sizeof(*tdinfo)); if (tbinfo->relkind == RELKIND_MATVIEW) tdinfo->dobj.objType = DO_REFRESH_MATVIEW; @@ -4074,7 +4074,7 @@ getLOs(Archive *fout) * pg_largeobject_metadata so that any large object * comments/seclables are dumped after it. */ - loinfo->dobj.dependencies = (DumpId *) pg_malloc(sizeof(DumpId)); + loinfo->dobj.dependencies = (DumpId *) pg_malloc(sizeof(*loinfo->dobj.dependencies)); loinfo->dobj.dependencies[0] = lo_metadata_dumpId; loinfo->dobj.nDeps = loinfo->dobj.allocDeps = 1; } @@ -4086,14 +4086,14 @@ getLOs(Archive *fout) * Create a "BLOBS" data item for the group, too. This is just a * placeholder for sorting; it carries no data now. */ - lodata = (DumpableObject *) pg_malloc(sizeof(DumpableObject)); + lodata = (DumpableObject *) pg_malloc(sizeof(*lodata)); lodata->objType = DO_LARGE_OBJECT_DATA; lodata->catId = nilCatalogId; AssignDumpId(lodata); lodata->name = pg_strdup(namebuf); lodata->components |= DUMP_COMPONENT_DATA; /* Set up explicit dependency from data to metadata */ - lodata->dependencies = (DumpId *) pg_malloc(sizeof(DumpId)); + lodata->dependencies = (DumpId *) pg_malloc(sizeof(*lodata->dependencies)); lodata->dependencies[0] = loinfo->dobj.dumpId; lodata->nDeps = lodata->allocDeps = 1; } @@ -4309,7 +4309,7 @@ getPolicies(Archive *fout, TableInfo tblinfo[], int numTables) * Note: use tableoid 0 so that this object won't be mistaken for * something that pg_depend entries apply to. */ - polinfo = pg_malloc(sizeof(PolicyInfo)); + polinfo = pg_malloc(sizeof(*polinfo)); polinfo->dobj.objType = DO_POLICY; polinfo->dobj.catId.tableoid = 0; polinfo->dobj.catId.oid = tbinfo->dobj.catId.oid; @@ -4365,7 +4365,7 @@ getPolicies(Archive *fout, TableInfo tblinfo[], int numTables) i_polqual = PQfnumber(res, "polqual"); i_polwithcheck = PQfnumber(res, "polwithcheck"); - polinfo = pg_malloc(ntups * sizeof(PolicyInfo)); + polinfo = pg_malloc(ntups * sizeof(*polinfo)); for (j = 0; j < ntups; j++) { @@ -4607,7 +4607,7 @@ getPublications(Archive *fout) i_pubviaroot = PQfnumber(res, "pubviaroot"); i_pubgencols = PQfnumber(res, "pubgencols"); - pubinfo = pg_malloc(ntups * sizeof(PublicationInfo)); + pubinfo = pg_malloc(ntups * sizeof(*pubinfo)); for (i = 0; i < ntups; i++) { @@ -4786,7 +4786,7 @@ getPublicationNamespaces(Archive *fout) i_pnnspid = PQfnumber(res, "pnnspid"); /* this allocation may be more than we need */ - pubsinfo = pg_malloc(ntups * sizeof(PublicationSchemaInfo)); + pubsinfo = pg_malloc(ntups * sizeof(*pubsinfo)); j = 0; for (i = 0; i < ntups; i++) @@ -4885,7 +4885,7 @@ getPublicationTables(Archive *fout, TableInfo tblinfo[], int numTables) i_prattrs = PQfnumber(res, "prattrs"); /* this allocation may be more than we need */ - pubrinfo = pg_malloc(ntups * sizeof(PublicationRelInfo)); + pubrinfo = pg_malloc(ntups * sizeof(*pubrinfo)); j = 0; for (i = 0; i < ntups; i++) @@ -5262,7 +5262,7 @@ getSubscriptions(Archive *fout) i_suborigin = PQfnumber(res, "suborigin"); i_suboriginremotelsn = PQfnumber(res, "suboriginremotelsn"); - subinfo = pg_malloc(ntups * sizeof(SubscriptionInfo)); + subinfo = pg_malloc(ntups * sizeof(*subinfo)); for (i = 0; i < ntups; i++) { @@ -5356,7 +5356,7 @@ getSubscriptionRelations(Archive *fout) i_srsubstate = PQfnumber(res, "srsubstate"); i_srsublsn = PQfnumber(res, "srsublsn"); - subrinfo = pg_malloc(ntups * sizeof(SubRelInfo)); + subrinfo = pg_malloc(ntups * sizeof(*subrinfo)); for (int i = 0; i < ntups; i++) { Oid cur_srsubid = atooid(PQgetvalue(res, i, i_srsubid)); @@ -5837,7 +5837,7 @@ collectBinaryUpgradeClassOids(Archive *fout) nbinaryUpgradeClassOids = PQntuples(res); binaryUpgradeClassOids = (BinaryUpgradeClassOidItem *) - pg_malloc(nbinaryUpgradeClassOids * sizeof(BinaryUpgradeClassOidItem)); + pg_malloc(nbinaryUpgradeClassOids * sizeof(*binaryUpgradeClassOids)); for (int i = 0; i < nbinaryUpgradeClassOids; i++) { @@ -6018,7 +6018,7 @@ getNamespaces(Archive *fout) ntups = PQntuples(res); - nsinfo = (NamespaceInfo *) pg_malloc(ntups * sizeof(NamespaceInfo)); + nsinfo = (NamespaceInfo *) pg_malloc(ntups * sizeof(*nsinfo)); i_tableoid = PQfnumber(res, "tableoid"); i_oid = PQfnumber(res, "oid"); @@ -6150,7 +6150,7 @@ getExtensions(Archive *fout, int *numExtensions) if (ntups == 0) goto cleanup; - extinfo = (ExtensionInfo *) pg_malloc(ntups * sizeof(ExtensionInfo)); + extinfo = (ExtensionInfo *) pg_malloc(ntups * sizeof(*extinfo)); i_tableoid = PQfnumber(res, "tableoid"); i_oid = PQfnumber(res, "oid"); @@ -6249,7 +6249,7 @@ getTypes(Archive *fout) ntups = PQntuples(res); - tyinfo = (TypeInfo *) pg_malloc(ntups * sizeof(TypeInfo)); + tyinfo = (TypeInfo *) pg_malloc(ntups * sizeof(*tyinfo)); i_tableoid = PQfnumber(res, "tableoid"); i_oid = PQfnumber(res, "oid"); @@ -6335,7 +6335,7 @@ getTypes(Archive *fout) (tyinfo[i].typtype == TYPTYPE_BASE || tyinfo[i].typtype == TYPTYPE_RANGE)) { - stinfo = (ShellTypeInfo *) pg_malloc(sizeof(ShellTypeInfo)); + stinfo = (ShellTypeInfo *) pg_malloc(sizeof(*stinfo)); stinfo->dobj.objType = DO_SHELL_TYPE; stinfo->dobj.catId = nilCatalogId; AssignDumpId(&stinfo->dobj); @@ -6398,7 +6398,7 @@ getOperators(Archive *fout) ntups = PQntuples(res); - oprinfo = (OprInfo *) pg_malloc(ntups * sizeof(OprInfo)); + oprinfo = (OprInfo *) pg_malloc(ntups * sizeof(*oprinfo)); i_tableoid = PQfnumber(res, "tableoid"); i_oid = PQfnumber(res, "oid"); @@ -6470,7 +6470,7 @@ getCollations(Archive *fout) ntups = PQntuples(res); - collinfo = (CollInfo *) pg_malloc(ntups * sizeof(CollInfo)); + collinfo = (CollInfo *) pg_malloc(ntups * sizeof(*collinfo)); i_tableoid = PQfnumber(res, "tableoid"); i_oid = PQfnumber(res, "oid"); @@ -6534,7 +6534,7 @@ getConversions(Archive *fout) ntups = PQntuples(res); - convinfo = (ConvInfo *) pg_malloc(ntups * sizeof(ConvInfo)); + convinfo = (ConvInfo *) pg_malloc(ntups * sizeof(*convinfo)); i_tableoid = PQfnumber(res, "tableoid"); i_oid = PQfnumber(res, "oid"); @@ -6607,7 +6607,7 @@ getAccessMethods(Archive *fout) ntups = PQntuples(res); - aminfo = (AccessMethodInfo *) pg_malloc(ntups * sizeof(AccessMethodInfo)); + aminfo = (AccessMethodInfo *) pg_malloc(ntups * sizeof(*aminfo)); i_tableoid = PQfnumber(res, "tableoid"); i_oid = PQfnumber(res, "oid"); @@ -6669,7 +6669,7 @@ getOpclasses(Archive *fout) ntups = PQntuples(res); - opcinfo = (OpclassInfo *) pg_malloc(ntups * sizeof(OpclassInfo)); + opcinfo = (OpclassInfo *) pg_malloc(ntups * sizeof(*opcinfo)); i_tableoid = PQfnumber(res, "tableoid"); i_oid = PQfnumber(res, "oid"); @@ -6734,7 +6734,7 @@ getOpfamilies(Archive *fout) ntups = PQntuples(res); - opfinfo = (OpfamilyInfo *) pg_malloc(ntups * sizeof(OpfamilyInfo)); + opfinfo = (OpfamilyInfo *) pg_malloc(ntups * sizeof(*opfinfo)); i_tableoid = PQfnumber(res, "tableoid"); i_oid = PQfnumber(res, "oid"); @@ -6852,7 +6852,7 @@ getAggregates(Archive *fout) ntups = PQntuples(res); - agginfo = (AggInfo *) pg_malloc(ntups * sizeof(AggInfo)); + agginfo = (AggInfo *) pg_malloc(ntups * sizeof(*agginfo)); i_tableoid = PQfnumber(res, "tableoid"); i_oid = PQfnumber(res, "oid"); @@ -6885,7 +6885,7 @@ getAggregates(Archive *fout) agginfo[i].aggfn.argtypes = NULL; else { - agginfo[i].aggfn.argtypes = (Oid *) pg_malloc(agginfo[i].aggfn.nargs * sizeof(Oid)); + agginfo[i].aggfn.argtypes = (Oid *) pg_malloc(agginfo[i].aggfn.nargs * sizeof(*agginfo[i].aggfn.argtypes)); parseOidArray(PQgetvalue(res, i, i_proargtypes), agginfo[i].aggfn.argtypes, agginfo[i].aggfn.nargs); @@ -7043,7 +7043,7 @@ getFuncs(Archive *fout) ntups = PQntuples(res); - finfo = (FuncInfo *) pg_malloc0(ntups * sizeof(FuncInfo)); + finfo = (FuncInfo *) pg_malloc0(ntups * sizeof(*finfo)); i_tableoid = PQfnumber(res, "tableoid"); i_oid = PQfnumber(res, "oid"); @@ -7078,7 +7078,7 @@ getFuncs(Archive *fout) finfo[i].argtypes = NULL; else { - finfo[i].argtypes = (Oid *) pg_malloc(finfo[i].nargs * sizeof(Oid)); + finfo[i].argtypes = (Oid *) pg_malloc(finfo[i].nargs * sizeof(*finfo[i].argtypes)); parseOidArray(PQgetvalue(res, i, i_proargtypes), finfo[i].argtypes, finfo[i].nargs); } @@ -7120,14 +7120,14 @@ getRelationStatistics(Archive *fout, DumpableObject *rel, int32 relpages, (relkind == RELKIND_MATVIEW || relkind == RELKIND_FOREIGN_TABLE)) { - RelStatsInfo *info = pg_malloc0(sizeof(RelStatsInfo)); + RelStatsInfo *info = pg_malloc0(sizeof(*info)); DumpableObject *dobj = &info->dobj; dobj->objType = DO_REL_STATS; dobj->catId.tableoid = 0; dobj->catId.oid = 0; AssignDumpId(dobj); - dobj->dependencies = (DumpId *) pg_malloc(sizeof(DumpId)); + dobj->dependencies = (DumpId *) pg_malloc(sizeof(*dobj->dependencies)); dobj->dependencies[0] = rel->dumpId; dobj->nDeps = 1; dobj->allocDeps = 1; @@ -7412,7 +7412,7 @@ getTables(Archive *fout, int *numTables) * only one, because we don't yet know which tables might be inheritance * ancestors of the target table. */ - tblinfo = (TableInfo *) pg_malloc0(ntups * sizeof(TableInfo)); + tblinfo = (TableInfo *) pg_malloc0(ntups * sizeof(*tblinfo)); i_reltableoid = PQfnumber(res, "tableoid"); i_reloid = PQfnumber(res, "oid"); @@ -7744,7 +7744,7 @@ getInherits(Archive *fout, int *numInherits) *numInherits = ntups; - inhinfo = (InhInfo *) pg_malloc(ntups * sizeof(InhInfo)); + inhinfo = (InhInfo *) pg_malloc(ntups * sizeof(*inhinfo)); i_inhrelid = PQfnumber(res, "inhrelid"); i_inhparent = PQfnumber(res, "inhparent"); @@ -8056,7 +8056,7 @@ getIndexes(Archive *fout, TableInfo tblinfo[], int numTables) i_indstatcols = PQfnumber(res, "indstatcols"); i_indstatvals = PQfnumber(res, "indstatvals"); - indxinfo = (IndxInfo *) pg_malloc(ntups * sizeof(IndxInfo)); + indxinfo = (IndxInfo *) pg_malloc(ntups * sizeof(*indxinfo)); /* * Outer loop iterates once per table, not once per row. Incrementing of @@ -8122,7 +8122,7 @@ getIndexes(Archive *fout, TableInfo tblinfo[], int numTables) indxinfo[j].indreloptions = pg_strdup(PQgetvalue(res, j, i_indreloptions)); indxinfo[j].indstatcols = pg_strdup(PQgetvalue(res, j, i_indstatcols)); indxinfo[j].indstatvals = pg_strdup(PQgetvalue(res, j, i_indstatvals)); - indxinfo[j].indkeys = (Oid *) pg_malloc(indxinfo[j].indnattrs * sizeof(Oid)); + indxinfo[j].indkeys = (Oid *) pg_malloc(indxinfo[j].indnattrs * sizeof(*indxinfo[j].indkeys)); parseOidArray(PQgetvalue(res, j, i_indkey), indxinfo[j].indkeys, indxinfo[j].indnattrs); indxinfo[j].indisclustered = (PQgetvalue(res, j, i_indisclustered)[0] == 't'); @@ -8160,7 +8160,7 @@ getIndexes(Archive *fout, TableInfo tblinfo[], int numTables) */ ConstraintInfo *constrinfo; - constrinfo = (ConstraintInfo *) pg_malloc(sizeof(ConstraintInfo)); + constrinfo = (ConstraintInfo *) pg_malloc(sizeof(*constrinfo)); constrinfo->dobj.objType = DO_CONSTRAINT; constrinfo->dobj.catId.tableoid = atooid(PQgetvalue(res, j, i_contableoid)); constrinfo->dobj.catId.oid = atooid(PQgetvalue(res, j, i_conoid)); @@ -8251,7 +8251,7 @@ getExtendedStatistics(Archive *fout) i_stxrelid = PQfnumber(res, "stxrelid"); i_stattarget = PQfnumber(res, "stxstattarget"); - statsextinfo = (StatsExtInfo *) pg_malloc(ntups * sizeof(StatsExtInfo)); + statsextinfo = (StatsExtInfo *) pg_malloc(ntups * sizeof(*statsextinfo)); for (i = 0; i < ntups; i++) { @@ -8359,7 +8359,7 @@ getConstraints(Archive *fout, TableInfo tblinfo[], int numTables) i_conindid = PQfnumber(res, "conindid"); i_condef = PQfnumber(res, "condef"); - constrinfo = (ConstraintInfo *) pg_malloc(ntups * sizeof(ConstraintInfo)); + constrinfo = (ConstraintInfo *) pg_malloc(ntups * sizeof(*constrinfo)); curtblindx = -1; for (int j = 0; j < ntups; j++) @@ -8520,7 +8520,7 @@ getDomainConstraints(Archive *fout, TypeInfo *tyinfo) i_convalidated = PQfnumber(res, "convalidated"); i_contype = PQfnumber(res, "contype"); - constrinfo = (ConstraintInfo *) pg_malloc(ntups * sizeof(ConstraintInfo)); + constrinfo = (ConstraintInfo *) pg_malloc(ntups * sizeof(*constrinfo)); tyinfo->domChecks = constrinfo; /* 'i' tracks result rows; 'j' counts CHECK constraints */ @@ -8608,7 +8608,7 @@ getRules(Archive *fout) ntups = PQntuples(res); - ruleinfo = (RuleInfo *) pg_malloc(ntups * sizeof(RuleInfo)); + ruleinfo = (RuleInfo *) pg_malloc(ntups * sizeof(*ruleinfo)); i_tableoid = PQfnumber(res, "tableoid"); i_oid = PQfnumber(res, "oid"); @@ -8814,7 +8814,7 @@ getTriggers(Archive *fout, TableInfo tblinfo[], int numTables) i_tgispartition = PQfnumber(res, "tgispartition"); i_tgdef = PQfnumber(res, "tgdef"); - tginfo = (TriggerInfo *) pg_malloc(ntups * sizeof(TriggerInfo)); + tginfo = (TriggerInfo *) pg_malloc(ntups * sizeof(*tginfo)); /* * Outer loop iterates once per table, not once per row. Incrementing of @@ -8911,7 +8911,7 @@ getEventTriggers(Archive *fout) ntups = PQntuples(res); - evtinfo = (EventTriggerInfo *) pg_malloc(ntups * sizeof(EventTriggerInfo)); + evtinfo = (EventTriggerInfo *) pg_malloc(ntups * sizeof(*evtinfo)); i_tableoid = PQfnumber(res, "tableoid"); i_oid = PQfnumber(res, "oid"); @@ -8985,7 +8985,7 @@ getProcLangs(Archive *fout) ntups = PQntuples(res); - planginfo = (ProcLangInfo *) pg_malloc(ntups * sizeof(ProcLangInfo)); + planginfo = (ProcLangInfo *) pg_malloc(ntups * sizeof(*planginfo)); i_tableoid = PQfnumber(res, "tableoid"); i_oid = PQfnumber(res, "oid"); @@ -9077,7 +9077,7 @@ getCasts(Archive *fout) ntups = PQntuples(res); - castinfo = (CastInfo *) pg_malloc(ntups * sizeof(CastInfo)); + castinfo = (CastInfo *) pg_malloc(ntups * sizeof(*castinfo)); i_tableoid = PQfnumber(res, "tableoid"); i_oid = PQfnumber(res, "oid"); @@ -9176,7 +9176,7 @@ getTransforms(Archive *fout) ntups = PQntuples(res); - transforminfo = (TransformInfo *) pg_malloc(ntups * sizeof(TransformInfo)); + transforminfo = (TransformInfo *) pg_malloc(ntups * sizeof(*transforminfo)); i_tableoid = PQfnumber(res, "tableoid"); i_oid = PQfnumber(res, "oid"); @@ -9514,27 +9514,27 @@ getTableAttrs(Archive *fout, TableInfo *tblinfo, int numTables) /* Save data for this table */ tbinfo->numatts = numatts; - tbinfo->attnames = (char **) pg_malloc(numatts * sizeof(char *)); - tbinfo->atttypnames = (char **) pg_malloc(numatts * sizeof(char *)); - tbinfo->attstattarget = (int *) pg_malloc(numatts * sizeof(int)); - tbinfo->attstorage = (char *) pg_malloc(numatts * sizeof(char)); - tbinfo->typstorage = (char *) pg_malloc(numatts * sizeof(char)); - tbinfo->attidentity = (char *) pg_malloc(numatts * sizeof(char)); - tbinfo->attgenerated = (char *) pg_malloc(numatts * sizeof(char)); - tbinfo->attisdropped = (bool *) pg_malloc(numatts * sizeof(bool)); - tbinfo->attlen = (int *) pg_malloc(numatts * sizeof(int)); - tbinfo->attalign = (char *) pg_malloc(numatts * sizeof(char)); - tbinfo->attislocal = (bool *) pg_malloc(numatts * sizeof(bool)); - tbinfo->attoptions = (char **) pg_malloc(numatts * sizeof(char *)); - tbinfo->attcollation = (Oid *) pg_malloc(numatts * sizeof(Oid)); - tbinfo->attcompression = (char *) pg_malloc(numatts * sizeof(char)); - tbinfo->attfdwoptions = (char **) pg_malloc(numatts * sizeof(char *)); - tbinfo->attmissingval = (char **) pg_malloc(numatts * sizeof(char *)); - tbinfo->notnull_constrs = (char **) pg_malloc(numatts * sizeof(char *)); - tbinfo->notnull_comment = (char **) pg_malloc(numatts * sizeof(char *)); - tbinfo->notnull_invalid = (bool *) pg_malloc(numatts * sizeof(bool)); - tbinfo->notnull_noinh = (bool *) pg_malloc(numatts * sizeof(bool)); - tbinfo->notnull_islocal = (bool *) pg_malloc(numatts * sizeof(bool)); + tbinfo->attnames = (char **) pg_malloc(numatts * sizeof(*tbinfo->attnames)); + tbinfo->atttypnames = (char **) pg_malloc(numatts * sizeof(*tbinfo->atttypnames)); + tbinfo->attstattarget = (int *) pg_malloc(numatts * sizeof(*tbinfo->attstattarget)); + tbinfo->attstorage = (char *) pg_malloc(numatts * sizeof(*tbinfo->attstorage)); + tbinfo->typstorage = (char *) pg_malloc(numatts * sizeof(*tbinfo->typstorage)); + tbinfo->attidentity = (char *) pg_malloc(numatts * sizeof(*tbinfo->attidentity)); + tbinfo->attgenerated = (char *) pg_malloc(numatts * sizeof(*tbinfo->attgenerated)); + tbinfo->attisdropped = (bool *) pg_malloc(numatts * sizeof(*tbinfo->attisdropped)); + tbinfo->attlen = (int *) pg_malloc(numatts * sizeof(*tbinfo->attlen)); + tbinfo->attalign = (char *) pg_malloc(numatts * sizeof(*tbinfo->attalign)); + tbinfo->attislocal = (bool *) pg_malloc(numatts * sizeof(*tbinfo->attislocal)); + tbinfo->attoptions = (char **) pg_malloc(numatts * sizeof(*tbinfo->attoptions)); + tbinfo->attcollation = (Oid *) pg_malloc(numatts * sizeof(*tbinfo->attcollation)); + tbinfo->attcompression = (char *) pg_malloc(numatts * sizeof(*tbinfo->attcompression)); + tbinfo->attfdwoptions = (char **) pg_malloc(numatts * sizeof(*tbinfo->attfdwoptions)); + tbinfo->attmissingval = (char **) pg_malloc(numatts * sizeof(*tbinfo->attmissingval)); + tbinfo->notnull_constrs = (char **) pg_malloc(numatts * sizeof(*tbinfo->notnull_constrs)); + tbinfo->notnull_comment = (char **) pg_malloc(numatts * sizeof(*tbinfo->notnull_comment)); + tbinfo->notnull_invalid = (bool *) pg_malloc(numatts * sizeof(*tbinfo->notnull_invalid)); + tbinfo->notnull_noinh = (bool *) pg_malloc(numatts * sizeof(*tbinfo->notnull_noinh)); + tbinfo->notnull_islocal = (bool *) pg_malloc(numatts * sizeof(*tbinfo->notnull_islocal)); tbinfo->attrdefs = (AttrDefInfo **) pg_malloc(numatts * sizeof(AttrDefInfo *)); hasdefaults = false; @@ -9620,7 +9620,7 @@ getTableAttrs(Archive *fout, TableInfo *tblinfo, int numTables) res = ExecuteSqlQuery(fout, q->data, PGRES_TUPLES_OK); numDefaults = PQntuples(res); - attrdefs = (AttrDefInfo *) pg_malloc(numDefaults * sizeof(AttrDefInfo)); + attrdefs = (AttrDefInfo *) pg_malloc(numDefaults * sizeof(*attrdefs)); curtblindx = -1; for (int j = 0; j < numDefaults; j++) @@ -9756,7 +9756,7 @@ getTableAttrs(Archive *fout, TableInfo *tblinfo, int numTables) res = ExecuteSqlQuery(fout, q->data, PGRES_TUPLES_OK); numConstrs = PQntuples(res); - constrs = (ConstraintInfo *) pg_malloc(numConstrs * sizeof(ConstraintInfo)); + constrs = (ConstraintInfo *) pg_malloc(numConstrs * sizeof(*constrs)); i_tableoid = PQfnumber(res, "tableoid"); i_oid = PQfnumber(res, "oid"); @@ -9855,7 +9855,7 @@ getTableAttrs(Archive *fout, TableInfo *tblinfo, int numTables) res = ExecuteSqlQuery(fout, q->data, PGRES_TUPLES_OK); numConstrs = PQntuples(res); - constrs = (ConstraintInfo *) pg_malloc(numConstrs * sizeof(ConstraintInfo)); + constrs = (ConstraintInfo *) pg_malloc(numConstrs * sizeof(*constrs)); i_tableoid = PQfnumber(res, "tableoid"); i_oid = PQfnumber(res, "oid"); @@ -10183,7 +10183,7 @@ getTSParsers(Archive *fout) ntups = PQntuples(res); - prsinfo = (TSParserInfo *) pg_malloc(ntups * sizeof(TSParserInfo)); + prsinfo = (TSParserInfo *) pg_malloc(ntups * sizeof(*prsinfo)); i_tableoid = PQfnumber(res, "tableoid"); i_oid = PQfnumber(res, "oid"); @@ -10250,7 +10250,7 @@ getTSDictionaries(Archive *fout) ntups = PQntuples(res); - dictinfo = (TSDictInfo *) pg_malloc(ntups * sizeof(TSDictInfo)); + dictinfo = (TSDictInfo *) pg_malloc(ntups * sizeof(*dictinfo)); i_tableoid = PQfnumber(res, "tableoid"); i_oid = PQfnumber(res, "oid"); @@ -10314,7 +10314,7 @@ getTSTemplates(Archive *fout) ntups = PQntuples(res); - tmplinfo = (TSTemplateInfo *) pg_malloc(ntups * sizeof(TSTemplateInfo)); + tmplinfo = (TSTemplateInfo *) pg_malloc(ntups * sizeof(*tmplinfo)); i_tableoid = PQfnumber(res, "tableoid"); i_oid = PQfnumber(res, "oid"); @@ -10373,7 +10373,7 @@ getTSConfigurations(Archive *fout) ntups = PQntuples(res); - cfginfo = (TSConfigInfo *) pg_malloc(ntups * sizeof(TSConfigInfo)); + cfginfo = (TSConfigInfo *) pg_malloc(ntups * sizeof(*cfginfo)); i_tableoid = PQfnumber(res, "tableoid"); i_oid = PQfnumber(res, "oid"); @@ -10445,7 +10445,7 @@ getForeignDataWrappers(Archive *fout) ntups = PQntuples(res); - fdwinfo = (FdwInfo *) pg_malloc(ntups * sizeof(FdwInfo)); + fdwinfo = (FdwInfo *) pg_malloc(ntups * sizeof(*fdwinfo)); i_tableoid = PQfnumber(res, "tableoid"); i_oid = PQfnumber(res, "oid"); @@ -10528,7 +10528,7 @@ getForeignServers(Archive *fout) ntups = PQntuples(res); - srvinfo = (ForeignServerInfo *) pg_malloc(ntups * sizeof(ForeignServerInfo)); + srvinfo = (ForeignServerInfo *) pg_malloc(ntups * sizeof(*srvinfo)); i_tableoid = PQfnumber(res, "tableoid"); i_oid = PQfnumber(res, "oid"); @@ -10626,7 +10626,7 @@ getDefaultACLs(Archive *fout) ntups = PQntuples(res); - daclinfo = (DefaultACLInfo *) pg_malloc(ntups * sizeof(DefaultACLInfo)); + daclinfo = (DefaultACLInfo *) pg_malloc(ntups * sizeof(*daclinfo)); i_oid = PQfnumber(res, "oid"); i_tableoid = PQfnumber(res, "tableoid"); @@ -10725,7 +10725,7 @@ collectRoleNames(Archive *fout) nrolenames = PQntuples(res); - rolenames = (RoleNameItem *) pg_malloc(nrolenames * sizeof(RoleNameItem)); + rolenames = (RoleNameItem *) pg_malloc(nrolenames * sizeof(*rolenames)); for (i = 0; i < nrolenames; i++) { @@ -11602,7 +11602,7 @@ collectComments(Archive *fout) ntups = PQntuples(res); - comments = (CommentItem *) pg_malloc(ntups * sizeof(CommentItem)); + comments = (CommentItem *) pg_malloc(ntups * sizeof(*comments)); ncomments = 0; dobj = NULL; @@ -13678,7 +13678,7 @@ dumpFunc(Archive *fout, const FuncInfo *finfo) if (*protrftypes) { - Oid *typeids = pg_malloc(FUNC_MAX_ARGS * sizeof(Oid)); + Oid *typeids = pg_malloc(FUNC_MAX_ARGS * sizeof(*typeids)); int i; appendPQExpBufferStr(q, " TRANSFORM "); @@ -16805,7 +16805,7 @@ collectSecLabels(Archive *fout) ntups = PQntuples(res); - seclabels = (SecLabelItem *) pg_malloc(ntups * sizeof(SecLabelItem)); + seclabels = (SecLabelItem *) pg_malloc(ntups * sizeof(*seclabels)); nseclabels = 0; dobj = NULL; @@ -18945,7 +18945,7 @@ collectSequences(Archive *fout) res = ExecuteSqlQuery(fout, query, PGRES_TUPLES_OK); nsequences = PQntuples(res); - sequences = (SequenceItem *) pg_malloc(nsequences * sizeof(SequenceItem)); + sequences = (SequenceItem *) pg_malloc(nsequences * sizeof(*sequences)); for (int i = 0; i < nsequences; i++) { @@ -19022,7 +19022,7 @@ dumpSequence(Archive *fout, const TableInfo *tbinfo) PQntuples(res)), tbinfo->dobj.name, PQntuples(res)); - seq = pg_malloc0(sizeof(SequenceItem)); + seq = pg_malloc0(sizeof(*seq)); seq->seqtype = parse_sequence_type(PQgetvalue(res, 0, 0)); seq->startv = strtoi64(PQgetvalue(res, 0, 1), NULL, 10); seq->incby = strtoi64(PQgetvalue(res, 0, 2), NULL, 10); @@ -20114,7 +20114,7 @@ createBoundaryObjects(void) { DumpableObject *dobjs; - dobjs = (DumpableObject *) pg_malloc(2 * sizeof(DumpableObject)); + dobjs = (DumpableObject *) pg_malloc(2 * sizeof(*dobjs)); dobjs[0].objType = DO_PRE_DATA_BOUNDARY; dobjs[0].catId = nilCatalogId; @@ -20288,7 +20288,7 @@ BuildArchiveDependencies(Archive *fout) continue; /* Set up work array */ allocDeps = 64; - dependencies = (DumpId *) pg_malloc(allocDeps * sizeof(DumpId)); + dependencies = (DumpId *) pg_malloc(allocDeps * sizeof(*dependencies)); nDeps = 0; /* Recursively find all dumpable dependencies */ findDumpableDependencies(AH, dobj, diff --git a/src/bin/pg_dump/pg_dump_sort.c b/src/bin/pg_dump/pg_dump_sort.c index 164c76e0864..a35e98b0ac7 100644 --- a/src/bin/pg_dump/pg_dump_sort.c +++ b/src/bin/pg_dump/pg_dump_sort.c @@ -561,7 +561,7 @@ sortDumpableObjects(DumpableObject **objs, int numObjs, preDataBoundId = preBoundaryId; postDataBoundId = postBoundaryId; - ordering = (DumpableObject **) pg_malloc(numObjs * sizeof(DumpableObject *)); + ordering = (DumpableObject **) pg_malloc(numObjs * sizeof(*ordering)); while (!TopoSort(objs, numObjs, ordering, &nOrdering)) findDependencyLoops(ordering, nOrdering, numObjs); @@ -640,8 +640,8 @@ TopoSort(DumpableObject **objs, * We also make a map showing the input-order index of the item with * dumpId j. */ - beforeConstraints = (int *) pg_malloc0((maxDumpId + 1) * sizeof(int)); - idMap = (int *) pg_malloc((maxDumpId + 1) * sizeof(int)); + beforeConstraints = (int *) pg_malloc0((maxDumpId + 1) * sizeof(*beforeConstraints)); + idMap = (int *) pg_malloc((maxDumpId + 1) * sizeof(*idMap)); for (i = 0; i < numObjs; i++) { obj = objs[i]; @@ -776,9 +776,9 @@ findDependencyLoops(DumpableObject **objs, int nObjs, int totObjs) bool fixedloop; int i; - processed = (bool *) pg_malloc0((getMaxDumpId() + 1) * sizeof(bool)); - searchFailed = (DumpId *) pg_malloc0((getMaxDumpId() + 1) * sizeof(DumpId)); - workspace = (DumpableObject **) pg_malloc(totObjs * sizeof(DumpableObject *)); + processed = (bool *) pg_malloc0((getMaxDumpId() + 1) * sizeof(*processed)); + searchFailed = (DumpId *) pg_malloc0((getMaxDumpId() + 1) * sizeof(*searchFailed)); + workspace = (DumpableObject **) pg_malloc(totObjs * sizeof(*workspace)); fixedloop = false; for (i = 0; i < nObjs; i++) diff --git a/src/bin/pg_dump/pg_dumpall.c b/src/bin/pg_dump/pg_dumpall.c index 8fa04930399..f5b76475bcb 100644 --- a/src/bin/pg_dump/pg_dumpall.c +++ b/src/bin/pg_dump/pg_dumpall.c @@ -1140,7 +1140,7 @@ dumpRoleMembership(PGconn *conn) } remaining = end - start; - done = pg_malloc0(remaining * sizeof(bool)); + done = pg_malloc0(remaining * sizeof(*done)); ht = rolename_create(remaining, NULL); /* diff --git a/src/bin/pg_rewind/datapagemap.c b/src/bin/pg_rewind/datapagemap.c index a0645afc83b..4110ab77d41 100644 --- a/src/bin/pg_rewind/datapagemap.c +++ b/src/bin/pg_rewind/datapagemap.c @@ -76,7 +76,7 @@ datapagemap_iterate(datapagemap_t *map) { datapagemap_iterator_t *iter; - iter = pg_malloc(sizeof(datapagemap_iterator_t)); + iter = pg_malloc(sizeof(*iter)); iter->map = map; iter->nextblkno = 0; diff --git a/src/bin/pg_rewind/libpq_source.c b/src/bin/pg_rewind/libpq_source.c index 575585357b7..6cc5b5467d2 100644 --- a/src/bin/pg_rewind/libpq_source.c +++ b/src/bin/pg_rewind/libpq_source.c @@ -84,7 +84,7 @@ init_libpq_source(PGconn *conn) init_libpq_conn(conn); - src = pg_malloc0(sizeof(libpq_source)); + src = pg_malloc0(sizeof(*src)); src->common.traverse_files = libpq_traverse_files; src->common.fetch_file = libpq_fetch_file; diff --git a/src/bin/pg_rewind/local_source.c b/src/bin/pg_rewind/local_source.c index 8db1a8c44aa..f84017a1831 100644 --- a/src/bin/pg_rewind/local_source.c +++ b/src/bin/pg_rewind/local_source.c @@ -39,7 +39,7 @@ init_local_source(const char *datadir) { local_source *src; - src = pg_malloc0(sizeof(local_source)); + src = pg_malloc0(sizeof(*src)); src->common.traverse_files = local_traverse_files; src->common.fetch_file = local_fetch_file; diff --git a/src/bin/pg_rewind/pg_rewind.c b/src/bin/pg_rewind/pg_rewind.c index 06c464f6ac5..d32631b4f67 100644 --- a/src/bin/pg_rewind/pg_rewind.c +++ b/src/bin/pg_rewind/pg_rewind.c @@ -874,7 +874,7 @@ getTimelineHistory(TimeLineID tli, bool is_source, int *nentries) */ if (tli == 1) { - history = (TimeLineHistoryEntry *) pg_malloc(sizeof(TimeLineHistoryEntry)); + history = (TimeLineHistoryEntry *) pg_malloc(sizeof(*history)); history->tli = tli; history->begin = history->end = InvalidXLogRecPtr; *nentries = 1; diff --git a/src/bin/pg_rewind/timeline.c b/src/bin/pg_rewind/timeline.c index 6784969951f..804d882819f 100644 --- a/src/bin/pg_rewind/timeline.c +++ b/src/bin/pg_rewind/timeline.c @@ -117,7 +117,7 @@ rewind_parseTimeLineHistory(char *buffer, TimeLineID targetTLI, int *nentries) if (entries) entries = pg_realloc(entries, nlines * sizeof(TimeLineHistoryEntry)); else - entries = pg_malloc(1 * sizeof(TimeLineHistoryEntry)); + entries = pg_malloc(1 * sizeof(*entries)); entry = &entries[nlines - 1]; entry->tli = targetTLI; diff --git a/src/bin/pg_upgrade/check.c b/src/bin/pg_upgrade/check.c index 1e17d64b3ec..2cb1d1b69f4 100644 --- a/src/bin/pg_upgrade/check.c +++ b/src/bin/pg_upgrade/check.c @@ -481,8 +481,8 @@ check_for_data_types_usage(ClusterInfo *cluster) } /* Allocate memory for queries and for task states */ - queries = pg_malloc0(sizeof(char *) * n_data_types_usage_checks); - states = pg_malloc0(sizeof(struct data_type_check_state) * n_data_types_usage_checks); + queries = pg_malloc0(sizeof(*queries) * n_data_types_usage_checks); + states = pg_malloc0(sizeof(*states) * n_data_types_usage_checks); for (int i = 0; i < n_data_types_usage_checks; i++) { diff --git a/src/bin/pg_upgrade/function.c b/src/bin/pg_upgrade/function.c index 9ad53caeebc..2e31bf4539f 100644 --- a/src/bin/pg_upgrade/function.c +++ b/src/bin/pg_upgrade/function.c @@ -85,7 +85,7 @@ get_loadable_libraries(void) struct loadable_libraries_state state; char *query; - state.ress = (PGresult **) pg_malloc(old_cluster.dbarr.ndbs * sizeof(PGresult *)); + state.ress = (PGresult **) pg_malloc(old_cluster.dbarr.ndbs * sizeof(*state.ress)); state.totaltups = 0; query = psprintf("SELECT DISTINCT probin " @@ -107,7 +107,7 @@ get_loadable_libraries(void) * plugins. */ n_libinfos = state.totaltups + count_old_cluster_logical_slots(); - os_info.libraries = (LibraryInfo *) pg_malloc(sizeof(LibraryInfo) * n_libinfos); + os_info.libraries = (LibraryInfo *) pg_malloc(sizeof(*os_info.libraries) * n_libinfos); totaltups = 0; for (dbnum = 0; dbnum < old_cluster.dbarr.ndbs; dbnum++) diff --git a/src/bin/pg_upgrade/info.c b/src/bin/pg_upgrade/info.c index 7ce08270168..db9a40931e7 100644 --- a/src/bin/pg_upgrade/info.c +++ b/src/bin/pg_upgrade/info.c @@ -53,7 +53,7 @@ gen_db_file_maps(DbInfo *old_db, DbInfo *new_db, bool all_matched = true; /* There will certainly not be more mappings than there are old rels */ - maps = (FileNameMap *) pg_malloc(sizeof(FileNameMap) * + maps = (FileNameMap *) pg_malloc(sizeof(*maps) * old_db->rel_arr.nrels); /* @@ -370,7 +370,7 @@ get_template0_info(ClusterInfo *cluster) if (PQntuples(dbres) != 1) pg_fatal("template0 not found"); - locale = pg_malloc(sizeof(DbLocaleInfo)); + locale = pg_malloc(sizeof(*locale)); i_datencoding = PQfnumber(dbres, "encoding"); i_datlocprovider = PQfnumber(dbres, "datlocprovider"); @@ -439,7 +439,7 @@ get_db_infos(ClusterInfo *cluster) i_spclocation = PQfnumber(res, "spclocation"); ntups = PQntuples(res); - dbinfos = (DbInfo *) pg_malloc0(sizeof(DbInfo) * ntups); + dbinfos = (DbInfo *) pg_malloc0(sizeof(*dbinfos) * ntups); for (tupnum = 0; tupnum < ntups; tupnum++) { @@ -585,7 +585,7 @@ static void process_rel_infos(DbInfo *dbinfo, PGresult *res, void *arg) { int ntups = PQntuples(res); - RelInfo *relinfos = (RelInfo *) pg_malloc(sizeof(RelInfo) * ntups); + RelInfo *relinfos = (RelInfo *) pg_malloc(sizeof(*relinfos) * ntups); int i_reloid = PQfnumber(res, "reloid"); int i_indtable = PQfnumber(res, "indtable"); int i_toastheap = PQfnumber(res, "toastheap"); @@ -739,7 +739,7 @@ process_old_cluster_logical_slot_infos(DbInfo *dbinfo, PGresult *res, void *arg) int i_caught_up; int i_invalid; - slotinfos = (LogicalSlotInfo *) pg_malloc(sizeof(LogicalSlotInfo) * num_slots); + slotinfos = (LogicalSlotInfo *) pg_malloc(sizeof(*slotinfos) * num_slots); i_slotname = PQfnumber(res, "slot_name"); i_plugin = PQfnumber(res, "plugin"); diff --git a/src/bin/pg_upgrade/parallel.c b/src/bin/pg_upgrade/parallel.c index 6d7941844a7..d5ff58ad323 100644 --- a/src/bin/pg_upgrade/parallel.c +++ b/src/bin/pg_upgrade/parallel.c @@ -85,13 +85,13 @@ parallel_exec_prog(const char *log_file, const char *opt_log_file, /* parallel */ #ifdef WIN32 if (thread_handles == NULL) - thread_handles = pg_malloc(user_opts.jobs * sizeof(HANDLE)); + thread_handles = pg_malloc(user_opts.jobs * sizeof(*thread_handles)); if (exec_thread_args == NULL) { int i; - exec_thread_args = pg_malloc(user_opts.jobs * sizeof(exec_thread_arg *)); + exec_thread_args = pg_malloc(user_opts.jobs * sizeof(*exec_thread_args)); /* * For safety and performance, we keep the args allocated during @@ -99,7 +99,7 @@ parallel_exec_prog(const char *log_file, const char *opt_log_file, * thread different from the one that allocated it. */ for (i = 0; i < user_opts.jobs; i++) - exec_thread_args[i] = pg_malloc0(sizeof(exec_thread_arg)); + exec_thread_args[i] = pg_malloc0(sizeof(*exec_thread_args[i])); } cur_thread_args = (void **) exec_thread_args; @@ -188,13 +188,13 @@ parallel_transfer_all_new_dbs(DbInfoArr *old_db_arr, DbInfoArr *new_db_arr, /* parallel */ #ifdef WIN32 if (thread_handles == NULL) - thread_handles = pg_malloc(user_opts.jobs * sizeof(HANDLE)); + thread_handles = pg_malloc(user_opts.jobs * sizeof(*thread_handles)); if (transfer_thread_args == NULL) { int i; - transfer_thread_args = pg_malloc(user_opts.jobs * sizeof(transfer_thread_arg *)); + transfer_thread_args = pg_malloc(user_opts.jobs * sizeof(*transfer_thread_args)); /* * For safety and performance, we keep the args allocated during @@ -202,7 +202,7 @@ parallel_transfer_all_new_dbs(DbInfoArr *old_db_arr, DbInfoArr *new_db_arr, * thread different from the one that allocated it. */ for (i = 0; i < user_opts.jobs; i++) - transfer_thread_args[i] = pg_malloc0(sizeof(transfer_thread_arg)); + transfer_thread_args[i] = pg_malloc0(sizeof(*transfer_thread_args[i])); } cur_thread_args = (void **) transfer_thread_args; diff --git a/src/bin/pg_upgrade/tablespace.c b/src/bin/pg_upgrade/tablespace.c index 151d74e1734..f73e04c3135 100644 --- a/src/bin/pg_upgrade/tablespace.c +++ b/src/bin/pg_upgrade/tablespace.c @@ -69,9 +69,9 @@ get_tablespace_paths(void) if (PQntuples(res) != 0) { old_cluster.tablespaces = - (char **) pg_malloc(old_cluster.num_tablespaces * sizeof(char *)); + (char **) pg_malloc(old_cluster.num_tablespaces * sizeof(*old_cluster.tablespaces)); new_cluster.tablespaces = - (char **) pg_malloc(new_cluster.num_tablespaces * sizeof(char *)); + (char **) pg_malloc(new_cluster.num_tablespaces * sizeof(*new_cluster.tablespaces)); } else { diff --git a/src/bin/pg_upgrade/task.c b/src/bin/pg_upgrade/task.c index ee0e2457152..aba82a05e39 100644 --- a/src/bin/pg_upgrade/task.c +++ b/src/bin/pg_upgrade/task.c @@ -116,7 +116,7 @@ typedef struct UpgradeTaskSlot UpgradeTask * upgrade_task_create(void) { - UpgradeTask *task = pg_malloc0(sizeof(UpgradeTask)); + UpgradeTask *task = pg_malloc0(sizeof(*task)); task->queries = createPQExpBuffer(); @@ -419,7 +419,7 @@ void upgrade_task_run(const UpgradeTask *task, const ClusterInfo *cluster) { int jobs = Max(1, user_opts.jobs); - UpgradeTaskSlot *slots = pg_malloc0(sizeof(UpgradeTaskSlot) * jobs); + UpgradeTaskSlot *slots = pg_malloc0(sizeof(*slots) * jobs); dbs_complete = 0; dbs_processing = 0; diff --git a/src/bin/pg_verifybackup/astreamer_verify.c b/src/bin/pg_verifybackup/astreamer_verify.c index e503a3ec487..4ef1f166f7c 100644 --- a/src/bin/pg_verifybackup/astreamer_verify.c +++ b/src/bin/pg_verifybackup/astreamer_verify.c @@ -79,7 +79,7 @@ astreamer_verify_content_new(astreamer *next, verifier_context *context, streamer->tblspc_oid = tblspc_oid; if (!context->skip_checksums) - streamer->checksum_ctx = pg_malloc(sizeof(pg_checksum_context)); + streamer->checksum_ctx = pg_malloc(sizeof(*streamer->checksum_ctx)); return &streamer->base; } diff --git a/src/bin/pg_verifybackup/pg_verifybackup.c b/src/bin/pg_verifybackup/pg_verifybackup.c index 1cd5fa791c0..6f4a8fcd622 100644 --- a/src/bin/pg_verifybackup/pg_verifybackup.c +++ b/src/bin/pg_verifybackup/pg_verifybackup.c @@ -418,7 +418,7 @@ parse_manifest_file(char *manifest_path) /* Create the hash table. */ ht = manifest_files_create(initial_size, NULL); - result = pg_malloc0(sizeof(manifest_data)); + result = pg_malloc0(sizeof(*result)); result->files = ht; context.private_data = result; context.version_cb = verifybackup_version_cb; @@ -970,7 +970,7 @@ precheck_tar_backup_file(verifier_context *context, char *relpath, * Append the information to the list for complete verification at a later * stage. */ - tar = pg_malloc(sizeof(tar_file)); + tar = pg_malloc(sizeof(*tar)); tar->relpath = pstrdup(relpath); tar->tblspc_oid = tblspc_oid; tar->compress_algorithm = compress_algorithm; @@ -1007,7 +1007,7 @@ verify_tar_file(verifier_context *context, char *relpath, char *fullpath, return; } - buffer = pg_malloc(READ_CHUNK_SIZE * sizeof(char)); + buffer = pg_malloc(READ_CHUNK_SIZE * sizeof(*buffer)); /* Perform the reads */ while ((rc = read(fd, buffer, READ_CHUNK_SIZE)) > 0) @@ -1065,7 +1065,7 @@ verify_backup_checksums(verifier_context *context) progress_report(false); - buffer = pg_malloc(READ_CHUNK_SIZE * sizeof(uint8)); + buffer = pg_malloc(READ_CHUNK_SIZE * sizeof(*buffer)); manifest_files_start_iterate(manifest->files, &it); while ((m = manifest_files_iterate(manifest->files, &it)) != NULL) diff --git a/src/bin/pgbench/pgbench.c b/src/bin/pgbench/pgbench.c index 45b340d3da5..86b6e24a56a 100644 --- a/src/bin/pgbench/pgbench.c +++ b/src/bin/pgbench/pgbench.c @@ -3067,7 +3067,7 @@ allocCStatePrepared(CState *st) { Assert(st->prepared == NULL); - st->prepared = pg_malloc(sizeof(bool *) * num_scripts); + st->prepared = pg_malloc(sizeof(*st->prepared) * num_scripts); for (int i = 0; i < num_scripts; i++) { ParsedScript *script = &sql_script[i]; @@ -3075,7 +3075,7 @@ allocCStatePrepared(CState *st) for (numcmds = 0; script->commands[numcmds] != NULL; numcmds++) ; - st->prepared[i] = pg_malloc0(sizeof(bool) * numcmds); + st->prepared[i] = pg_malloc0(sizeof(*st->prepared[i]) * numcmds); } } @@ -5659,7 +5659,7 @@ create_sql_command(PQExpBuffer buf) return NULL; /* Allocate and initialize Command structure */ - my_command = (Command *) pg_malloc(sizeof(Command)); + my_command = (Command *) pg_malloc(sizeof(*my_command)); initPQExpBuffer(&my_command->lines); appendPQExpBufferStr(&my_command->lines, p); my_command->first_line = NULL; /* this is set later */ @@ -5755,7 +5755,7 @@ process_backslash_command(PsqlScanState sstate, const char *source, } /* Allocate and initialize Command structure */ - my_command = (Command *) pg_malloc0(sizeof(Command)); + my_command = (Command *) pg_malloc0(sizeof(*my_command)); my_command->type = META_COMMAND; my_command->argc = 0; initSimpleStats(&my_command->stats); @@ -6011,7 +6011,7 @@ ParseScript(const char *script, const char *desc, int weight) /* Initialize all fields of ps */ ps.desc = desc; ps.weight = weight; - ps.commands = (Command **) pg_malloc(sizeof(Command *) * alloc_num); + ps.commands = (Command **) pg_malloc(sizeof(*ps.commands) * alloc_num); initStats(&ps.stats, 0); /* Prepare to parse script */ @@ -6844,7 +6844,7 @@ main(int argc, char **argv) } } - state = (CState *) pg_malloc0(sizeof(CState)); + state = (CState *) pg_malloc0(sizeof(*state)); /* set random seed early, because it may be used while parsing scripts. */ if (!set_random_seed(getenv("PGBENCH_RANDOM_SEED"))) @@ -7412,7 +7412,7 @@ main(int argc, char **argv) PQfinish(con); /* set up thread data structures */ - threads = (TState *) pg_malloc(sizeof(TState) * nthreads); + threads = (TState *) pg_malloc(sizeof(*threads) * nthreads); nclients_dealt = 0; for (i = 0; i < nthreads; i++) diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c index 4a2976dddf0..feac14892d4 100644 --- a/src/bin/psql/command.c +++ b/src/bin/psql/command.c @@ -5665,7 +5665,7 @@ savePsetInfo(const printQueryOpt *popt) { printQueryOpt *save; - save = (printQueryOpt *) pg_malloc(sizeof(printQueryOpt)); + save = (printQueryOpt *) pg_malloc(sizeof(*save)); /* Flat-copy all the scalar fields, then duplicate sub-structures. */ memcpy(save, popt, sizeof(printQueryOpt)); diff --git a/src/bin/psql/copy.c b/src/bin/psql/copy.c index 92c955b637a..f4f945ff258 100644 --- a/src/bin/psql/copy.c +++ b/src/bin/psql/copy.c @@ -99,7 +99,7 @@ parse_slash_copy(const char *args) return NULL; } - result = pg_malloc0(sizeof(struct copy_options)); + result = pg_malloc0(sizeof(*result)); result->before_tofrom = pg_strdup(""); /* initialize for appending */ diff --git a/src/bin/psql/crosstabview.c b/src/bin/psql/crosstabview.c index 3e5cd0a96d4..2f50a9d3fdf 100644 --- a/src/bin/psql/crosstabview.c +++ b/src/bin/psql/crosstabview.c @@ -246,10 +246,10 @@ PrintResultInCrosstab(const PGresult *res) num_rows = piv_rows.count; array_columns = (pivot_field *) - pg_malloc(sizeof(pivot_field) * num_columns); + pg_malloc(sizeof(*array_columns) * num_columns); array_rows = (pivot_field *) - pg_malloc(sizeof(pivot_field) * num_rows); + pg_malloc(sizeof(*array_rows) * num_rows); avlCollectFields(&piv_columns, piv_columns.root, array_columns, 0); avlCollectFields(&piv_rows, piv_rows.root, array_rows, 0); @@ -312,7 +312,7 @@ printCrosstab(const PGresult *result, * map associating each piv_columns[].rank to its index in piv_columns. * This avoids an O(N^2) loop later. */ - horiz_map = (int *) pg_malloc(sizeof(int) * num_columns); + horiz_map = (int *) pg_malloc(sizeof(*horiz_map) * num_columns); for (i = 0; i < num_columns; i++) horiz_map[piv_columns[i].rank] = i; @@ -437,7 +437,7 @@ error: static void avlInit(avl_tree *tree) { - tree->end = (avl_node *) pg_malloc0(sizeof(avl_node)); + tree->end = (avl_node *) pg_malloc0(sizeof(*tree->end)); tree->end->children[0] = tree->end->children[1] = tree->end; tree->count = 0; tree->root = tree->end; @@ -533,7 +533,7 @@ avlInsertNode(avl_tree *tree, avl_node **node, pivot_field field) if (current == tree->end) { avl_node *new_node = (avl_node *) - pg_malloc(sizeof(avl_node)); + pg_malloc(sizeof(*new_node)); new_node->height = 1; new_node->field = field; diff --git a/src/bin/psql/describe.c b/src/bin/psql/describe.c index 36f24502842..85693e01eea 100644 --- a/src/bin/psql/describe.c +++ b/src/bin/psql/describe.c @@ -5306,7 +5306,7 @@ listSchemas(const char *pattern, bool verbose, bool showSystem) * storing "Publications:" string) + publication schema mapping * count + 1 (for storing NULL). */ - footers = (char **) pg_malloc((1 + pub_schema_tuples + 1) * sizeof(char *)); + footers = (char **) pg_malloc((1 + pub_schema_tuples + 1) * sizeof(*footers)); footers[0] = pg_strdup(_("Publications:")); /* Might be an empty set - that's ok */ diff --git a/src/bin/psql/tab-complete.in.c b/src/bin/psql/tab-complete.in.c index 20d7a65c614..b6e4e976d36 100644 --- a/src/bin/psql/tab-complete.in.c +++ b/src/bin/psql/tab-complete.in.c @@ -6295,7 +6295,7 @@ complete_from_variables(const char *text, const char *prefix, const char *suffix int i; struct _variable *ptr; - varnames = (char **) pg_malloc((maxvars + 1) * sizeof(char *)); + varnames = (char **) pg_malloc((maxvars + 1) * sizeof(*varnames)); for (ptr = pset.vars->next; ptr; ptr = ptr->next) { @@ -6873,7 +6873,7 @@ get_previous_words(int point, char **buffer, int *nwords) * This is usually much more space than we need, but it's cheaper than * doing a separate malloc() for each word. */ - previous_words = (char **) pg_malloc(point * sizeof(char *)); + previous_words = (char **) pg_malloc(point * sizeof(*previous_words)); *buffer = outptr = (char *) pg_malloc(point * 2); /* diff --git a/src/bin/scripts/reindexdb.c b/src/bin/scripts/reindexdb.c index 8ddcc5312f7..cc06b7d1d3d 100644 --- a/src/bin/scripts/reindexdb.c +++ b/src/bin/scripts/reindexdb.c @@ -322,7 +322,7 @@ reindex_one_database(ConnParams *cparams, ReindexType type, * database itself, so build a list with a single entry. */ Assert(user_list == NULL); - process_list = pg_malloc0(sizeof(SimpleStringList)); + process_list = pg_malloc0(sizeof(*process_list)); simple_string_list_append(process_list, PQdb(conn)); break; @@ -713,7 +713,7 @@ get_parallel_tables_list(PGconn *conn, ReindexType type, return NULL; } - tables = pg_malloc0(sizeof(SimpleStringList)); + tables = pg_malloc0(sizeof(*tables)); /* Build qualified identifiers for each table */ for (int i = 0; i < ntups; i++) @@ -809,7 +809,7 @@ get_parallel_tabidx_list(PGconn *conn, return; } - *table_list = pg_malloc0(sizeof(SimpleOidList)); + *table_list = pg_malloc0(sizeof(**table_list)); /* * Build two lists, one with table OIDs and the other with fully-qualified diff --git a/src/bin/scripts/vacuuming.c b/src/bin/scripts/vacuuming.c index 5d2d8a64961..b5cf00defcf 100644 --- a/src/bin/scripts/vacuuming.c +++ b/src/bin/scripts/vacuuming.c @@ -459,7 +459,7 @@ vacuum_all_databases(ConnParams *cparams, SimpleStringList **found_objs = NULL; if (vacopts->missing_stats_only) - found_objs = palloc0(numdbs * sizeof(SimpleStringList *)); + found_objs = palloc0(numdbs * sizeof(*found_objs)); /* * When analyzing all databases in stages, we analyze them all in the diff --git a/src/common/blkreftable.c b/src/common/blkreftable.c index 0e08f4e40ed..c886a8d460b 100644 --- a/src/common/blkreftable.c +++ b/src/common/blkreftable.c @@ -1069,7 +1069,7 @@ BlockRefTableEntryMarkBlockModified(BlockRefTableEntry *entry, unsigned j; /* Allocate a new chunk. */ - newchunk = palloc0(MAX_ENTRIES_PER_CHUNK * sizeof(uint16)); + newchunk = palloc0(MAX_ENTRIES_PER_CHUNK * sizeof(*newchunk)); /* Set the bit for each existing entry. */ for (j = 0; j < entry->chunk_usage[chunkno]; ++j) diff --git a/src/fe_utils/conditional.c b/src/fe_utils/conditional.c index 9e1ad687f08..1cb2b72f9ed 100644 --- a/src/fe_utils/conditional.c +++ b/src/fe_utils/conditional.c @@ -52,7 +52,7 @@ conditional_stack_destroy(ConditionalStack cstack) void conditional_stack_push(ConditionalStack cstack, ifState new_state) { - IfStackElem *p = (IfStackElem *) pg_malloc(sizeof(IfStackElem)); + IfStackElem *p = (IfStackElem *) pg_malloc(sizeof(*p)); p->if_state = new_state; p->query_len = -1; diff --git a/src/fe_utils/print.c b/src/fe_utils/print.c index 4d97ad2ddeb..8e4cca433b1 100644 --- a/src/fe_utils/print.c +++ b/src/fe_utils/print.c @@ -3305,7 +3305,7 @@ printTableAddCell(printTableContent *const content, char *cell, { if (content->cellmustfree == NULL) content->cellmustfree = - pg_malloc0((total_cells + 1) * sizeof(bool)); + pg_malloc0((total_cells + 1) * sizeof(*content->cellmustfree)); content->cellmustfree[content->cellsadded] = true; } @@ -3477,7 +3477,7 @@ count_table_lines(const printTableContent *cont, * Scan all column headers and determine their heights. Cache the values * since vertical mode repeats the headers for every record. */ - header_height = (int *) pg_malloc(cont->ncolumns * sizeof(int)); + header_height = (int *) pg_malloc(cont->ncolumns * sizeof(*header_height)); for (i = 0; i < cont->ncolumns; i++) { pg_wcssize((const unsigned char *) cont->headers[i], diff --git a/src/fe_utils/simple_list.c b/src/fe_utils/simple_list.c index 483d5455594..15103968bb9 100644 --- a/src/fe_utils/simple_list.c +++ b/src/fe_utils/simple_list.c @@ -27,7 +27,7 @@ simple_oid_list_append(SimpleOidList *list, Oid val) { SimpleOidListCell *cell; - cell = (SimpleOidListCell *) pg_malloc(sizeof(SimpleOidListCell)); + cell = (SimpleOidListCell *) pg_malloc(sizeof(*cell)); cell->next = NULL; cell->val = val; @@ -163,7 +163,7 @@ simple_ptr_list_append(SimplePtrList *list, void *ptr) { SimplePtrListCell *cell; - cell = (SimplePtrListCell *) pg_malloc(sizeof(SimplePtrListCell)); + cell = (SimplePtrListCell *) pg_malloc(sizeof(*cell)); cell->next = NULL; cell->ptr = ptr; diff --git a/src/interfaces/ecpg/ecpglib/misc.c b/src/interfaces/ecpg/ecpglib/misc.c index 1885732a652..35371bcfaab 100644 --- a/src/interfaces/ecpg/ecpglib/misc.c +++ b/src/interfaces/ecpg/ecpglib/misc.c @@ -114,7 +114,7 @@ ECPGget_sqlca(void) sqlca = pthread_getspecific(sqlca_key); if (sqlca == NULL) { - sqlca = malloc(sizeof(struct sqlca_t)); + sqlca = malloc(sizeof(*sqlca)); if (sqlca == NULL) return NULL; ecpg_init_sqlca(sqlca); diff --git a/src/interfaces/libpq/fe-auth-scram.c b/src/interfaces/libpq/fe-auth-scram.c index f6d6a5aa977..38543b306b9 100644 --- a/src/interfaces/libpq/fe-auth-scram.c +++ b/src/interfaces/libpq/fe-auth-scram.c @@ -104,7 +104,7 @@ scram_init(PGconn *conn, Assert(sasl_mechanism != NULL); - state = (fe_scram_state *) malloc(sizeof(fe_scram_state)); + state = (fe_scram_state *) malloc(sizeof(*state)); if (!state) return NULL; memset(state, 0, sizeof(fe_scram_state)); diff --git a/src/interfaces/libpq/fe-auth.c b/src/interfaces/libpq/fe-auth.c index 84a042269de..dacdd963a7c 100644 --- a/src/interfaces/libpq/fe-auth.c +++ b/src/interfaces/libpq/fe-auth.c @@ -302,7 +302,7 @@ pg_SSPI_continue(PGconn *conn, int payloadlen) if (conn->sspictx == NULL) { /* On first run, transfer retrieved context handle */ - conn->sspictx = malloc(sizeof(CtxtHandle)); + conn->sspictx = malloc(sizeof(*conn->sspictx)); if (conn->sspictx == NULL) { libpq_append_conn_error(conn, "out of memory"); diff --git a/src/interfaces/libpq/fe-connect.c b/src/interfaces/libpq/fe-connect.c index 03eeb3dcdb5..68841217710 100644 --- a/src/interfaces/libpq/fe-connect.c +++ b/src/interfaces/libpq/fe-connect.c @@ -1153,7 +1153,7 @@ parse_comma_separated_list(char **startptr, bool *more) *more = (*e == ','); len = e - s; - p = (char *) malloc(sizeof(char) * (len + 1)); + p = (char *) malloc(sizeof(*p) * (len + 1)); if (p) { memcpy(p, s, len); @@ -4979,7 +4979,7 @@ pqMakeEmptyPGconn(void) WSASetLastError(0); #endif /* WIN32 */ - conn = (PGconn *) malloc(sizeof(PGconn)); + conn = (PGconn *) malloc(sizeof(*conn)); if (conn == NULL) return conn; @@ -5023,7 +5023,7 @@ pqMakeEmptyPGconn(void) conn->outBufSize = 16 * 1024; conn->outBuffer = (char *) malloc(conn->outBufSize); conn->rowBufLen = 32; - conn->rowBuf = (PGdataValue *) malloc(conn->rowBufLen * sizeof(PGdataValue)); + conn->rowBuf = (PGdataValue *) malloc(conn->rowBufLen * sizeof(*conn->rowBuf)); initPQExpBuffer(&conn->errorMessage); initPQExpBuffer(&conn->workBuffer); diff --git a/src/interfaces/libpq/fe-exec.c b/src/interfaces/libpq/fe-exec.c index 7ab33930a39..658f5a92001 100644 --- a/src/interfaces/libpq/fe-exec.c +++ b/src/interfaces/libpq/fe-exec.c @@ -161,7 +161,7 @@ PQmakeEmptyPGresult(PGconn *conn, ExecStatusType status) { PGresult *result; - result = (PGresult *) malloc(sizeof(PGresult)); + result = (PGresult *) malloc(sizeof(*result)); if (!result) return NULL; @@ -1043,7 +1043,7 @@ pqAddTuple(PGresult *res, PGresAttValue *tup, const char **errmsgp) if (res->tuples == NULL) newTuples = (PGresAttValue **) - malloc(newSize * sizeof(PGresAttValue *)); + malloc(newSize * sizeof(*newTuples)); else newTuples = (PGresAttValue **) realloc(res->tuples, newSize * sizeof(PGresAttValue *)); @@ -1326,7 +1326,7 @@ pqAllocCmdQueueEntry(PGconn *conn) if (conn->cmd_queue_recycle == NULL) { - entry = (PGcmdQueueEntry *) malloc(sizeof(PGcmdQueueEntry)); + entry = (PGcmdQueueEntry *) malloc(sizeof(*entry)); if (entry == NULL) { libpq_append_conn_error(conn, "out of memory"); diff --git a/src/interfaces/libpq/fe-lobj.c b/src/interfaces/libpq/fe-lobj.c index 05e17bed508..303263664f1 100644 --- a/src/interfaces/libpq/fe-lobj.c +++ b/src/interfaces/libpq/fe-lobj.c @@ -864,7 +864,7 @@ lo_initialize(PGconn *conn) * Allocate the structure to hold the function OIDs. We don't store it * into the PGconn until it's successfully filled. */ - lobjfuncs = (PGlobjfuncs *) malloc(sizeof(PGlobjfuncs)); + lobjfuncs = (PGlobjfuncs *) malloc(sizeof(*lobjfuncs)); if (lobjfuncs == NULL) { libpq_append_conn_error(conn, "out of memory"); diff --git a/src/interfaces/libpq/fe-print.c b/src/interfaces/libpq/fe-print.c index fc153bee630..fc9d604ba58 100644 --- a/src/interfaces/libpq/fe-print.c +++ b/src/interfaces/libpq/fe-print.c @@ -632,7 +632,7 @@ PQdisplayTuples(const PGresult *res, /* will be somewhat time consuming for very large results */ if (fillAlign) { - fLength = (int *) malloc(nFields * sizeof(int)); + fLength = (int *) malloc(nFields * sizeof(*fLength)); if (!fLength) { fprintf(stderr, libpq_gettext("out of memory\n")); diff --git a/src/interfaces/libpq/fe-protocol3.c b/src/interfaces/libpq/fe-protocol3.c index 16f504a867d..676683126fd 100644 --- a/src/interfaces/libpq/fe-protocol3.c +++ b/src/interfaces/libpq/fe-protocol3.c @@ -1252,13 +1252,13 @@ reportErrorPosition(PQExpBuffer msg, const char *query, int loc, int encoding) return; } - qidx = (int *) malloc(slen * sizeof(int)); + qidx = (int *) malloc(slen * sizeof(*qidx)); if (qidx == NULL) { free(wquery); return; } - scridx = (int *) malloc(slen * sizeof(int)); + scridx = (int *) malloc(slen * sizeof(*scridx)); if (scridx == NULL) { free(qidx); diff --git a/src/interfaces/libpq/libpq-events.c b/src/interfaces/libpq/libpq-events.c index a96e3694f1f..e59af3917d6 100644 --- a/src/interfaces/libpq/libpq-events.c +++ b/src/interfaces/libpq/libpq-events.c @@ -61,7 +61,7 @@ PQregisterEventProc(PGconn *conn, PGEventProc proc, if (conn->events) e = (PGEvent *) realloc(conn->events, newSize * sizeof(PGEvent)); else - e = (PGEvent *) malloc(newSize * sizeof(PGEvent)); + e = (PGEvent *) malloc(newSize * sizeof(*e)); if (!e) return false; diff --git a/src/pl/plperl/plperl.c b/src/pl/plperl/plperl.c index 02eced3b2c5..67e6727f377 100644 --- a/src/pl/plperl/plperl.c +++ b/src/pl/plperl/plperl.c @@ -1788,9 +1788,9 @@ plperl_modify_tuple(HV *hvTD, TriggerData *tdata, HeapTuple otup) tupdesc = tdata->tg_relation->rd_att; natts = tupdesc->natts; - modvalues = (Datum *) palloc0(natts * sizeof(Datum)); - modnulls = (bool *) palloc0(natts * sizeof(bool)); - modrepls = (bool *) palloc0(natts * sizeof(bool)); + modvalues = (Datum *) palloc0(natts * sizeof(*modvalues)); + modnulls = (bool *) palloc0(natts * sizeof(*modnulls)); + modrepls = (bool *) palloc0(natts * sizeof(*modrepls)); hv_iterinit(hvNew); while ((he = hv_iternext(hvNew))) @@ -2805,9 +2805,9 @@ compile_plperl_function(Oid fn_oid, bool is_trigger, bool is_event_trigger) prodesc->fn_xmin = HeapTupleHeaderGetRawXmin(procTup->t_data); prodesc->fn_tid = procTup->t_self; prodesc->nargs = procStruct->pronargs; - prodesc->arg_out_func = (FmgrInfo *) palloc0(prodesc->nargs * sizeof(FmgrInfo)); - prodesc->arg_is_rowtype = (bool *) palloc0(prodesc->nargs * sizeof(bool)); - prodesc->arg_arraytype = (Oid *) palloc0(prodesc->nargs * sizeof(Oid)); + prodesc->arg_out_func = (FmgrInfo *) palloc0(prodesc->nargs * sizeof(*prodesc->arg_out_func)); + prodesc->arg_is_rowtype = (bool *) palloc0(prodesc->nargs * sizeof(*prodesc->arg_is_rowtype)); + prodesc->arg_arraytype = (Oid *) palloc0(prodesc->nargs * sizeof(*prodesc->arg_arraytype)); MemoryContextSwitchTo(oldcontext); /* Remember if function is STABLE/IMMUTABLE */ @@ -3600,9 +3600,9 @@ plperl_spi_prepare(char *query, int argc, SV **argv) snprintf(qdesc->qname, sizeof(qdesc->qname), "%p", qdesc); qdesc->plan_cxt = plan_cxt; qdesc->nargs = argc; - qdesc->argtypes = (Oid *) palloc(argc * sizeof(Oid)); - qdesc->arginfuncs = (FmgrInfo *) palloc(argc * sizeof(FmgrInfo)); - qdesc->argtypioparams = (Oid *) palloc(argc * sizeof(Oid)); + qdesc->argtypes = (Oid *) palloc(argc * sizeof(*qdesc->argtypes)); + qdesc->arginfuncs = (FmgrInfo *) palloc(argc * sizeof(*qdesc->arginfuncs)); + qdesc->argtypioparams = (Oid *) palloc(argc * sizeof(*qdesc->argtypioparams)); MemoryContextSwitchTo(oldcontext); /************************************************************ @@ -3774,7 +3774,7 @@ plperl_spi_exec_prepared(char *query, HV *attr, int argc, SV **argv) if (argc > 0) { nulls = (char *) palloc(argc); - argvalues = (Datum *) palloc(argc * sizeof(Datum)); + argvalues = (Datum *) palloc(argc * sizeof(*argvalues)); } else { @@ -3887,7 +3887,7 @@ plperl_spi_query_prepared(char *query, int argc, SV **argv) if (argc > 0) { nulls = (char *) palloc(argc); - argvalues = (Datum *) palloc(argc * sizeof(Datum)); + argvalues = (Datum *) palloc(argc * sizeof(*argvalues)); } else { diff --git a/src/pl/plpython/plpy_cursorobject.c b/src/pl/plpython/plpy_cursorobject.c index cc74c4df6ba..068d9ddb982 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 = (Datum *) palloc(nargs * sizeof(*values)); + nulls = (char *) palloc(nargs * sizeof(*nulls)); } else { diff --git a/src/pl/plpython/plpy_exec.c b/src/pl/plpython/plpy_exec.c index 0117f1e77ef..934e13243e9 100644 --- a/src/pl/plpython/plpy_exec.c +++ b/src/pl/plpython/plpy_exec.c @@ -1001,9 +1001,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 = (Datum *) palloc0(tupdesc->natts * sizeof(*modvalues)); + modnulls = (bool *) palloc0(tupdesc->natts * sizeof(*modnulls)); + modrepls = (bool *) palloc0(tupdesc->natts * sizeof(*modrepls)); for (i = 0; i < nkeys; i++) { diff --git a/src/pl/plpython/plpy_spi.c b/src/pl/plpython/plpy_spi.c index 46f2ca0f792..5f7b369aad5 100644 --- a/src/pl/plpython/plpy_spi.c +++ b/src/pl/plpython/plpy_spi.c @@ -233,8 +233,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 = (Datum *) palloc(nargs * sizeof(*values)); + nulls = (char *) palloc(nargs * sizeof(*nulls)); } else { diff --git a/src/pl/tcl/pltcl.c b/src/pl/tcl/pltcl.c index 187698ccdd2..95f25f672fa 100644 --- a/src/pl/tcl/pltcl.c +++ b/src/pl/tcl/pltcl.c @@ -1595,8 +1595,8 @@ compile_pltcl_function(Oid fn_oid, Oid tgreloid, prodesc->fn_xmin = HeapTupleHeaderGetRawXmin(procTup->t_data); prodesc->fn_tid = procTup->t_self; prodesc->nargs = procStruct->pronargs; - prodesc->arg_out_func = (FmgrInfo *) palloc0(prodesc->nargs * sizeof(FmgrInfo)); - prodesc->arg_is_rowtype = (bool *) palloc0(prodesc->nargs * sizeof(bool)); + prodesc->arg_out_func = (FmgrInfo *) palloc0(prodesc->nargs * sizeof(*prodesc->arg_out_func)); + prodesc->arg_is_rowtype = (bool *) palloc0(prodesc->nargs * sizeof(*prodesc->arg_is_rowtype)); MemoryContextSwitchTo(oldcontext); /* Remember if function is STABLE/IMMUTABLE */ @@ -2671,9 +2671,9 @@ pltcl_SPI_prepare(ClientData cdata, Tcl_Interp *interp, qdesc = palloc0_object(pltcl_query_desc); snprintf(qdesc->qname, sizeof(qdesc->qname), "%p", qdesc); qdesc->nargs = nargs; - qdesc->argtypes = (Oid *) palloc(nargs * sizeof(Oid)); - qdesc->arginfuncs = (FmgrInfo *) palloc(nargs * sizeof(FmgrInfo)); - qdesc->argtypioparams = (Oid *) palloc(nargs * sizeof(Oid)); + qdesc->argtypes = (Oid *) palloc(nargs * sizeof(*qdesc->argtypes)); + qdesc->arginfuncs = (FmgrInfo *) palloc(nargs * sizeof(*qdesc->arginfuncs)); + qdesc->argtypioparams = (Oid *) palloc(nargs * sizeof(*qdesc->argtypioparams)); MemoryContextSwitchTo(oldcontext); /************************************************************ @@ -2916,7 +2916,7 @@ pltcl_SPI_execute_plan(ClientData cdata, Tcl_Interp *interp, * Setup the value array for SPI_execute_plan() using * the type specific input functions ************************************************************/ - argvalues = (Datum *) palloc(callObjc * sizeof(Datum)); + argvalues = (Datum *) palloc(callObjc * sizeof(*argvalues)); for (j = 0; j < callObjc; j++) { @@ -3290,7 +3290,7 @@ pltcl_build_tuple_result(Tcl_Interp *interp, Tcl_Obj **kvObjv, int kvObjc, attinmeta = NULL; } - values = (char **) palloc0(tupdesc->natts * sizeof(char *)); + values = (char **) palloc0(tupdesc->natts * sizeof(*values)); if (kvObjc % 2 != 0) ereport(ERROR, diff --git a/src/port/dirent.c b/src/port/dirent.c index a10484ea32c..9d6924e8365 100644 --- a/src/port/dirent.c +++ b/src/port/dirent.c @@ -48,7 +48,7 @@ opendir(const char *dirname) return NULL; } - d = malloc(sizeof(DIR)); + d = malloc(sizeof(*d)); if (!d) { errno = ENOMEM; diff --git a/src/timezone/localtime.c b/src/timezone/localtime.c index 20147f1a2c2..7a97bfd0d72 100644 --- a/src/timezone/localtime.c +++ b/src/timezone/localtime.c @@ -1366,7 +1366,7 @@ gmtsub(pg_time_t const *timep, int_fast32_t offset, if (gmtptr == NULL) { /* Allocate on first use */ - gmtptr = (struct state *) malloc(sizeof(struct state)); + gmtptr = (struct state *) malloc(sizeof(*gmtptr)); if (gmtptr == NULL) return NULL; /* errno should be set by malloc */ gmtload(gmtptr); -- 2.34.1