diff --git a/contrib/pgcrypto/imath.c b/contrib/pgcrypto/imath.c
index 6936d2cdca..30dd4c9313 100644
--- a/contrib/pgcrypto/imath.c
+++ b/contrib/pgcrypto/imath.c
@@ -723,7 +723,7 @@ mp_int_add(mp_int a, mp_int b, mp_int c)
 	else
 	{
 		/* Different signs -- subtract magnitudes, preserve sign of greater */
-		int			cmp = s_ucmp(a, b); /* magnitude comparision, sign ignored */
+		int			cmp = s_ucmp(a, b); /* magnitude comparison, sign ignored */
 
 		/*
 		 * Set x to max(a, b), y to min(a, b) to simplify later code. A
@@ -3373,7 +3373,7 @@ s_udiv_knuth(mp_int u, mp_int v)
 		 * decrease qhat one more time before we get a value that is smaller
 		 * than r.
 		 *
-		 * This way is less efficent than Knuth becuase we do more multiplies,
+		 * This way is less efficent than Knuth because we do more multiplies,
 		 * but we do not need to worry about underflow this way.
 		 */
 		/* t = qhat * v */
diff --git a/contrib/pgcrypto/imath.h b/contrib/pgcrypto/imath.h
index 0e1676d04e..7b4497b3c6 100644
--- a/contrib/pgcrypto/imath.h
+++ b/contrib/pgcrypto/imath.h
@@ -107,7 +107,7 @@ extern const mp_result MP_MINERR;
 void		mp_int_default_precision(mp_size ndigits);
 
 /** Sets the number of digits below which multiplication will use the standard
-	quadratic "schoolbook" multiplcation algorithm rather than Karatsuba-Ofman.
+	quadratic "schoolbook" multiplication algorithm rather than Karatsuba-Ofman.
 	Requires `ndigits >= sizeof(mp_word)`. */
 void		mp_int_multiply_threshold(mp_size ndigits);
 
diff --git a/contrib/postgres_fdw/postgres_fdw.c b/contrib/postgres_fdw/postgres_fdw.c
index 02c81ce7a9..1b09aa5a01 100644
--- a/contrib/postgres_fdw/postgres_fdw.c
+++ b/contrib/postgres_fdw/postgres_fdw.c
@@ -3064,7 +3064,7 @@ estimate_path_cost_size(PlannerInfo *root,
 	total_cost += cpu_tuple_cost * retrieved_rows;
 
 	/*
-	 * If we have LIMIT, we should perfer performing the restriction remotely
+	 * If we have LIMIT, we should prefer performing the restriction remotely
 	 * rather than locally, as the former avoids extra row fetches from the
 	 * remote that the latter might cause.  But since the core code doesn't
 	 * account for such fetches when estimating the costs of the local
diff --git a/doc/src/sgml/charset.sgml b/doc/src/sgml/charset.sgml
index 555d1b4ac6..a2a46c6ab3 100644
--- a/doc/src/sgml/charset.sgml
+++ b/doc/src/sgml/charset.sgml
@@ -896,7 +896,7 @@ CREATE COLLATION french FROM "fr-x-icu";
      equal only if they consist of the same byte sequence.  Nondeterministic
      comparison may determine strings to be equal even if they consist of
      different bytes.  Typical situations include case-insensitive comparison,
-     accent-insensitive comparison, as well as comparion of strings in
+     accent-insensitive comparison, as well as comparison of strings in
      different Unicode normal forms.  It is up to the collation provider to
      actually implement such insensitive comparisons; the deterministic flag
      only determines whether ties are to be broken using bytewise comparison.
diff --git a/doc/src/sgml/monitoring.sgml b/doc/src/sgml/monitoring.sgml
index a179d6111e..570ac5e06f 100644
--- a/doc/src/sgml/monitoring.sgml
+++ b/doc/src/sgml/monitoring.sgml
@@ -3556,7 +3556,7 @@ SELECT pg_stat_get_backend_pid(s.backendid) AS pid,
       </entry>
      </row>
      <row>
-      <entry><structfield>current_locked_pid</structfield></entry>
+      <entry><structfield>current_locker_pid</structfield></entry>
       <entry><type>bigint</type></entry>
       <entry>
         Process ID of the locker currently being waited for.
diff --git a/doc/src/sgml/storage.sgml b/doc/src/sgml/storage.sgml
index c4bac87e80..1047c77a63 100644
--- a/doc/src/sgml/storage.sgml
+++ b/doc/src/sgml/storage.sgml
@@ -960,7 +960,7 @@ data. Empty in ordinary tables.</entry>
   (that is, <structfield>t_natts</structfield> bits altogether). In this list of bits, a
   1 bit indicates not-null, a 0 bit is a null.  When the bitmap is not
   present, all columns are assumed not-null.
-  The object ID is only present if the <firstterm>HEAP_HASOID</firstterm> bit
+  The object ID is only present if the <firstterm>HEAP_HASOID_OLD</firstterm> bit
   is set in <structfield>t_infomask</structfield>.  If present, it appears just
   before the <structfield>t_hoff</structfield> boundary.  Any padding needed to make
   <structfield>t_hoff</structfield> a MAXALIGN multiple will appear between the null
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index 2eccc99023..602f8849d4 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -663,7 +663,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
  *		(In a !heapkeyspace index, there can be multiple pages with the same
  *		high key, where the new tuple could legitimately be placed on.  In
  *		that case, the caller passes the first page containing duplicates,
- *		just like when checkinunique=true.  If that page doesn't have enough
+ *		just like when checkingunique=true.  If that page doesn't have enough
  *		room for the new tuple, this function moves right, trying to find a
  *		legal page that does.)
  *
diff --git a/src/backend/access/nbtree/nbtutils.c b/src/backend/access/nbtree/nbtutils.c
index 431b8477e9..93fab264ae 100644
--- a/src/backend/access/nbtree/nbtutils.c
+++ b/src/backend/access/nbtree/nbtutils.c
@@ -1344,7 +1344,7 @@ _bt_mark_scankey_required(ScanKey skey)
  * _bt_preprocess_keys(), above, about how this is done.
  *
  * Forward scan callers can pass a high key tuple in the hopes of having
- * us set *continuescanthat to false, and avoiding an unnecessary visit to
+ * us set *continuescan to false, and avoiding an unnecessary visit to
  * the page to the right.
  *
  * scan: index scan descriptor (containing a search-type scankey)
diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index a8ff304909..eca0be1ff9 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -2934,7 +2934,7 @@ CopyFrom(CopyState cstate)
 	else if (contain_volatile_functions(cstate->whereClause))
 	{
 		/*
-		 * Can't support multi-inserts if there are any volatile funcation
+		 * Can't support multi-inserts if there are any volatile function
 		 * expressions in WHERE clause.  Similarly to the trigger case above,
 		 * such expressions may query the table we're inserting into.
 		 */
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index c9b8857d30..e34d4ccc14 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -3574,7 +3574,7 @@ AlterTableGetLockLevel(List *cmds)
 
 				/*
 				 * Removing constraints can affect SELECTs that have been
-				 * optimised assuming the constraint holds true. See also
+				 * optimized assuming the constraint holds true. See also
 				 * CloneFkReferenced.
 				 */
 			case AT_DropConstraint: /* as DROP INDEX */
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index 8c8528b134..a2bd9a7859 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -2432,7 +2432,7 @@ ExecBuildAuxRowMark(ExecRowMark *erm, List *targetlist)
  *	inputslot - tuple for processing - this can be the slot from
  *		EvalPlanQualSlot(), for the increased efficiency.
  *
- * This tests whether the tuple in inputslot still matches the relvant
+ * This tests whether the tuple in inputslot still matches the relevant
  * quals. For that result to be useful, typically the input tuple has to be
  * last row version (otherwise the result isn't particularly useful) and
  * locked (otherwise the result might be out of date). That's typically
diff --git a/src/backend/executor/execTuples.c b/src/backend/executor/execTuples.c
index 968e2039d1..f785efae65 100644
--- a/src/backend/executor/execTuples.c
+++ b/src/backend/executor/execTuples.c
@@ -1602,7 +1602,7 @@ ExecStoreHeapTupleDatum(Datum data, TupleTableSlot *slot)
  * NB: If materialize is true, modifications of the returned tuple are
  * allowed. But it depends on the type of the slot whether such modifications
  * will also affect the slot's contents. While that is not the nicest
- * behaviour, all such modifcations are in the process of being removed.
+ * behaviour, all such modifications are in the process of being removed.
  */
 HeapTuple
 ExecFetchSlotHeapTuple(TupleTableSlot *slot, bool materialize, bool *shouldFree)
@@ -1645,7 +1645,7 @@ ExecFetchSlotHeapTuple(TupleTableSlot *slot, bool materialize, bool *shouldFree)
  *		tuple should be considered as read-only.
  *
  *		If that callback is not supported, it calls copy_minimal_tuple callback
- *		which is expected to return a copy of minimal tuple represnting the
+ *		which is expected to return a copy of minimal tuple representing the
  *		contents of the slot. In this case *shouldFree is set to true,
  *		indicating the caller that it should free the memory consumed by the
  *		minimal tuple. In this case the returned minimal tuple may be written
diff --git a/src/backend/jit/llvm/llvmjit_deform.c b/src/backend/jit/llvm/llvmjit_deform.c
index 33dc6f630c..835aea83e9 100644
--- a/src/backend/jit/llvm/llvmjit_deform.c
+++ b/src/backend/jit/llvm/llvmjit_deform.c
@@ -202,7 +202,7 @@ slot_compile_deform(LLVMJitContext *context, TupleDesc desc,
 			LLVMBuildBitCast(b,
 							 v_slot,
 							 l_ptr(StructMinimalTupleTableSlot),
-							 "minimalslotslot");
+							 "minimalslot");
 		v_slotoffp = LLVMBuildStructGEP(b, v_minimalslot, FIELDNO_MINIMALTUPLETABLESLOT_OFF, "");
 		v_tupleheaderp =
 			l_load_struct_gep(b, v_minimalslot, FIELDNO_MINIMALTUPLETABLESLOT_TUPLE,
diff --git a/src/backend/libpq/hba.c b/src/backend/libpq/hba.c
index 52ac0d78f7..563d251019 100644
--- a/src/backend/libpq/hba.c
+++ b/src/backend/libpq/hba.c
@@ -1429,7 +1429,7 @@ parse_hba_line(TokenizedLine *tok_line, int elevel)
 				 errmsg("GSSAPI encryption only supports gss, trust, or reject authentication"),
 				 errcontext("line %d of configuration file \"%s\"",
 							line_num, HbaFileName)));
-		*err_msg = "GSSAPI encryption only supports gss, trust, or reject authenticaion";
+		*err_msg = "GSSAPI encryption only supports gss, trust, or reject authentication";
 		return NULL;
 	}
 
diff --git a/src/backend/postmaster/syslogger.c b/src/backend/postmaster/syslogger.c
index 5e934e9bfd..bafd31d22b 100644
--- a/src/backend/postmaster/syslogger.c
+++ b/src/backend/postmaster/syslogger.c
@@ -1546,7 +1546,7 @@ CheckLogrotateSignal(void)
 }
 
 /*
- * Remove the file signaling a log rotateion request.
+ * Remove the file signaling a log rotation request.
  */
 void
 RemoveLogrotateSignalFiles(void)
diff --git a/src/backend/statistics/mcv.c b/src/backend/statistics/mcv.c
index c8c44a53bf..d1f0fd55e8 100644
--- a/src/backend/statistics/mcv.c
+++ b/src/backend/statistics/mcv.c
@@ -714,7 +714,7 @@ statext_mcv_serialize(MCVList *mcvlist, VacAttrStats **stats)
 				memcpy(ptr, &tmp, info[dim].typlen);
 				ptr += info[dim].typlen;
 			}
-			else if (info[dim].typlen > 0)	/* pased by reference */
+			else if (info[dim].typlen > 0)	/* passed by reference */
 			{
 				/* no special alignment needed, treated as char array */
 				memcpy(ptr, DatumGetPointer(value), info[dim].typlen);
diff --git a/src/backend/utils/adt/float.c b/src/backend/utils/adt/float.c
index 23649c1000..7540ca22ef 100644
--- a/src/backend/utils/adt/float.c
+++ b/src/backend/utils/adt/float.c
@@ -506,7 +506,7 @@ float8in_internal_opt_error(char *num, char **endptr_p,
 }
 
 /*
- * Interfact to float8in_internal_opt_error() without "have_error" argument.
+ * Interface to float8in_internal_opt_error() without "have_error" argument.
  */
 double
 float8in_internal(char *num, char **endptr_p,
diff --git a/src/backend/utils/adt/jsonpath_scan.l b/src/backend/utils/adt/jsonpath_scan.l
index 84d4f297a8..2165ffcc25 100644
--- a/src/backend/utils/adt/jsonpath_scan.l
+++ b/src/backend/utils/adt/jsonpath_scan.l
@@ -603,7 +603,7 @@ parseUnicode(char *s, int l)
 		{
 			while (s[++i] != '}' && i < l)
 				ch = (ch << 4) | hexval(s[i]);
-			i++;	/* ski p '}' */
+			i++;	/* skip '}' */
 		}
 		else		/* parse '\uXXXX' */
 		{
diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c
index 0516940f74..1208eb9a68 100644
--- a/src/backend/utils/misc/guc.c
+++ b/src/backend/utils/misc/guc.c
@@ -8968,7 +8968,7 @@ get_explain_guc_options(int *num)
 				break;
 
 			default:
-				elog(ERROR, "unexcpected GUC type: %d", conf->vartype);
+				elog(ERROR, "unexpected GUC type: %d", conf->vartype);
 		}
 
 		/* skip GUC variables that match the built-in default */
diff --git a/src/bin/pg_dump/t/002_pg_dump.pl b/src/bin/pg_dump/t/002_pg_dump.pl
index cb9181e156..ea6283c51a 100644
--- a/src/bin/pg_dump/t/002_pg_dump.pl
+++ b/src/bin/pg_dump/t/002_pg_dump.pl
@@ -3131,7 +3131,7 @@ my %tests = (
 	# AM occurs. To achieve that we create a table with the standard
 	# AM, test AM, standard AM. That guarantees that there needs to be
 	# a SET interspersed.  Then use a regex that prevents interspersed
-	# SET ...; statements, followed by the exptected CREATE TABLE. Not
+	# SET ...; statements, followed by the expected CREATE TABLE. Not
 	# pretty, but seems hard to do better in this framework.
 	'CREATE TABLE regress_pg_dump_table_am' => {
 		create_order => 12,
diff --git a/src/include/statistics/statistics.h b/src/include/statistics/statistics.h
index d0ab04c0ae..cb7bc630e9 100644
--- a/src/include/statistics/statistics.h
+++ b/src/include/statistics/statistics.h
@@ -82,7 +82,7 @@ typedef struct MCVItem
 	Datum	   *values;			/* item values */
 } MCVItem;
 
-/* multivariate MCV list - essentally an array of MCV items */
+/* multivariate MCV list - essentially an array of MCV items */
 typedef struct MCVList
 {
 	uint32		magic;			/* magic constant marker */
diff --git a/src/include/utils/jsonpath.h b/src/include/utils/jsonpath.h
index 0732fe2ba9..3e9d60cb76 100644
--- a/src/include/utils/jsonpath.h
+++ b/src/include/utils/jsonpath.h
@@ -96,7 +96,7 @@ typedef enum JsonPathItemType
  * Support functions to parse/construct binary value.
  * Unlike many other representation of expression the first/main
  * node is not an operation but left operand of expression. That
- * allows to implement cheep follow-path descending in jsonb
+ * allows to implement cheap follow-path descending in jsonb
  * structure and then execute operator with right operand
  */
 
diff --git a/src/interfaces/libpq/pqexpbuffer.c b/src/interfaces/libpq/pqexpbuffer.c
index b3c53b0cda..a9af6f8d83 100644
--- a/src/interfaces/libpq/pqexpbuffer.c
+++ b/src/interfaces/libpq/pqexpbuffer.c
@@ -37,7 +37,7 @@
 /* All "broken" PQExpBuffers point to this string. */
 static const char oom_buffer[1] = "";
 
-/* Need a char * for unconstify() compatiblity */
+/* Need a char * for unconstify() compatibility */
 static const char *oom_buffer_ptr = oom_buffer;
 
 static bool appendPQExpBufferVA(PQExpBuffer str, const char *fmt, va_list args) pg_attribute_printf(2, 0);
