Not able to compile PG16 with custom flags in freebsd 14.1 - Please Help

Hi I am trying to install Postgresql 16 on my freebsd 14.1 by compiling it
hosted in an ec2 machine on AWS.

I am using GCC13 to compile the binaries and I keep on running into

*gcc13: fatal error: cannot read spec file './specs': Is a directory *Please
Help

here is the code of my bash script I have also uploaded the same code in
github gist :-

https://gist.github.com/mokshchadha/6c5590e339959a91dc6985b96dee25cb

Code in the above mentioned gist

#!/bin/sh

# Configuration variables
POSTGRES_VERSION="16.3"
POSTGRES_PREFIX="/usr/local/pgsql"
DATA_DIR="$POSTGRES_PREFIX/data"
LOGFILE="$POSTGRES_PREFIX/logfile"
BUILD_DIR="/tmp/postgresql-build"
PYTHON3_PATH=$(which python3)

# Helper functions
error_exit() {
echo "Error: $1" >&2
cleanup
exit 1
}

warning_message() {
echo "Warning: $1" >&2
}

cleanup() {
echo "Cleaning up..."
[ -d "$BUILD_DIR" ] && rm -rf "$BUILD_DIR" || warning_message
"Failed to remove build directory."
}

check_prerequisites() {
# Check for GCC 13
if ! command -v gcc13 >/dev/null 2>&1; then
echo "GCC 13 is not installed. Installing GCC 13..."
pkg install -y gcc13 || error_exit "Failed to install GCC 13.
Please install it manually using 'pkg install gcc13'."
else
echo "GCC 13 is installed. Checking version and configuration..."
gcc13 --version
gcc13 -v 2>&1 | grep "Configured with"

# Check for specs file issue
GCC_LIBDIR="/usr/local/lib/gcc13"
SPECS_FILE="$GCC_LIBDIR/specs"

if [ ! -f "$SPECS_FILE" ]; then
echo "specs file not found. Attempting to create..."
if ! gcc13 -dumpspecs > "$SPECS_FILE" 2>/dev/null; then
error_exit "Failed to create specs file. Please check
GCC 13 installation."
fi
fi

# Verify GCC functionality
if ! gcc13 -v >/dev/null 2>&1; then
error_exit "GCC 13 is not functioning correctly. Please
check your GCC installation."
fi
fi

# Check for GNU Make
if ! command -v gmake >/dev/null 2>&1; then
echo "GNU Make is not installed. Installing GNU Make..."
pkg install -y gmake || error_exit "Failed to install GNU
Make. Please install it manually using 'pkg install gmake'."
fi

command -v fetch >/dev/null 2>&1 || error_exit "fetch is required
but not installed. Please install it using 'pkg install fetch'."
command -v python3 >/dev/null 2>&1 || error_exit "Python3 is
required but not installed. Please install it using 'pkg install
python3'."
command -v openssl >/dev/null 2>&1 || error_exit "OpenSSL is
required but not installed. Please install it using 'pkg install
openssl'."

# Check for pkg-config
if ! command -v pkg-config >/dev/null 2>&1; then
echo "pkg-config is not installed. Installing pkg-config..."
pkg install -y pkgconf || error_exit "Failed to install
pkg-config. Please install it manually using 'pkg install pkgconf'."
fi

# Check for LZ4
if ! pkg info -e liblz4 >/dev/null 2>&1; then
echo "LZ4 is not installed. Installing LZ4..."
pkg install -y liblz4 || error_exit "Failed to install LZ4.
Please install it manually using 'pkg install liblz4'."
fi

# Verify LZ4 installation
if ! pkg-config --exists liblz4; then
error_exit "LZ4 library not found by pkg-config. Please check
your LZ4 installation."
fi

# Check for ICU
if ! pkg info -e icu >/dev/null 2>&1; then
echo "ICU is not installed. Installing ICU..."
pkg install -y icu || error_exit "Failed to install ICU.
Please install it manually using 'pkg install icu'."
fi

# Verify ICU installation
if [ -f /usr/local/lib/libicuuc.so ]; then
echo "ICU library found at /usr/local/lib/libicuuc.so"
else
error_exit "ICU library not found at expected location. Please
check your ICU installation."
fi

# Print ICU version
echo "ICU version:"
pkg info icu | grep Version

# Print LZ4 version
echo "LZ4 version:"
pkg info liblz4 | grep Version
}

ensure_install_directory() {
if [ ! -d "$POSTGRES_PREFIX" ]; then
mkdir -p "$POSTGRES_PREFIX" || error_exit "Failed to create
installation directory."
elif [ ! -w "$POSTGRES_PREFIX" ]; then
chmod u+w "$POSTGRES_PREFIX" || error_exit "Failed to set
permissions on installation directory."
fi
}

create_postgres_user() {
if ! pw groupshow postgres >/dev/null 2>&1; then
echo "Creating 'postgres' group..."
pw groupadd postgres || error_exit "Failed to create 'postgres' group."
fi

if ! pw usershow postgres >/dev/null 2>&1; then
echo "Creating 'postgres' user..."
pw useradd postgres -g postgres -m -s /usr/local/bin/bash ||
error_exit "Failed to create 'postgres' user."
else
echo "'postgres' user already exists."
fi
}

download_postgresql() {
echo "Downloading PostgreSQL $POSTGRES_VERSION..."
mkdir -p "$BUILD_DIR" || error_exit "Failed to create build directory."
cd "$BUILD_DIR" || error_exit "Failed to enter build directory."

if [ ! -f "postgresql-$POSTGRES_VERSION.tar.bz2" ]; then
fetch "https://ftp.postgresql.org/pub/source/v$POSTGRES_VERSION/postgresql-$POSTGRES_VERSION.tar.bz2"
|| error_exit "Failed to download PostgreSQL source."
else
echo "Source tarball already exists, skipping download."
fi

if [ ! -d "postgresql-$POSTGRES_VERSION" ]; then
tar -xvf "postgresql-$POSTGRES_VERSION.tar.bz2" || error_exit
"Failed to extract PostgreSQL source."
else
echo "Source directory already exists, skipping extraction."
fi

cd "postgresql-$POSTGRES_VERSION" || error_exit "Failed to enter
PostgreSQL source directory."
}

configure_postgresql() {
echo "Configuring PostgreSQL with custom options..."
PYTHON_INCLUDE_DIR=$($PYTHON3_PATH -c "from distutils.sysconfig
import get_python_inc; print(get_python_inc())")
PYTHON_LIB_DIR=$($PYTHON3_PATH -c "from distutils.sysconfig import
get_config_var; print(get_config_var('LIBDIR'))")

# Add ICU library and include paths
ICU_LIBS="-L/usr/local/lib -licui18n -licuuc -licudata"
ICU_CFLAGS="-I/usr/local/include"

# Add LZ4 library and include paths
LZ4_LIBS=$(pkg-config --libs liblz4)
LZ4_CFLAGS=$(pkg-config --cflags liblz4)

export CC=gcc13
export LDFLAGS="-L/usr/local/lib -L$PYTHON_LIB_DIR $ICU_LIBS $LZ4_LIBS"
export CPPFLAGS="-I/usr/local/include -I$PYTHON_INCLUDE_DIR
$ICU_CFLAGS $LZ4_CFLAGS"
export ICU_LIBS
export ICU_CFLAGS
export LZ4_LIBS
export LZ4_CFLAGS
export LD_LIBRARY_PATH="/usr/local/lib:$LD_LIBRARY_PATH"
export LIBRARY_PATH="/usr/local/lib:$LIBRARY_PATH"
export PKG_CONFIG_PATH="/usr/local/lib/pkgconfig:$PKG_CONFIG_PATH"

config_command="./configure \
CC=gcc13 \
--prefix=\"$POSTGRES_PREFIX\" \
--with-blocksize=32 \
--with-segsize=8 \
--with-openssl \
--with-ssl=openssl \
--with-lz4 \
--with-python \
--with-icu \
--with-includes=\"/usr/local/include $PYTHON_INCLUDE_DIR\" \
--with-libraries=\"/usr/local/lib $PYTHON_LIB_DIR\""
echo "Configuration command: $config_command"
echo "LDFLAGS: $LDFLAGS"
echo "CPPFLAGS: $CPPFLAGS"
echo "ICU_LIBS: $ICU_LIBS"
echo "ICU_CFLAGS: $ICU_CFLAGS"
echo "LZ4_LIBS: $LZ4_LIBS"
echo "LZ4_CFLAGS: $LZ4_CFLAGS"
echo "LD_LIBRARY_PATH: $LD_LIBRARY_PATH"
echo "LIBRARY_PATH: $LIBRARY_PATH"
echo "PKG_CONFIG_PATH: $PKG_CONFIG_PATH"

# Run configure and capture output
if ! eval $config_command > configure_output.log 2>&1; then
echo "Configuration failed. Last 50 lines of output:"
tail -n 50 configure_output.log
error_exit "Configuration failed. See configure_output.log for details."
fi
}

verify_compilation_options() {
echo "Verifying compilation options..."
grep -E "BLCKSZ|RELSEG_SIZE" src/include/pg_config.h
}

compile_postgresql() {
echo "Compiling PostgreSQL..."
gmake || error_exit "Compilation failed."

echo "Compiling contrib modules (including pg_trgm)..."
cd contrib || error_exit "Failed to enter contrib directory."
gmake || error_exit "Compilation of contrib modules failed."

cd .. || error_exit "Failed to return to main PostgreSQL directory."
verify_compilation_options
}

install_postgresql() {
echo "Installing PostgreSQL..."
gmake install || error_exit "Installation failed."

echo "Installing contrib modules (including pg_trgm)..."
cd contrib || error_exit "Failed to enter contrib directory."
gmake install || error_exit "Installation of contrib modules failed."

cd .. || error_exit "Failed to return to main PostgreSQL directory."
}

setup_environment() {
echo "Setting up environment variables..."
if ! grep -q "$POSTGRES_PREFIX/bin" /etc/profile; then
echo "export PATH=\"$POSTGRES_PREFIX/bin:\$PATH\"" >>
/etc/profile || warning_message "Failed to update /etc/profile."
. /etc/profile || warning_message "Failed to source /etc/profile."
else
echo "PATH already includes $POSTGRES_PREFIX/bin."
fi
}

initialize_database() {
echo "Initializing the PostgreSQL database..."
mkdir -p "$DATA_DIR" || error_exit "Failed to create data directory."
chown postgres:postgres "$DATA_DIR"
su -m postgres -c "$POSTGRES_PREFIX/bin/initdb -D $DATA_DIR" ||
error_exit "Database initialization failed."
}

create_extension_pg_trgm() {
echo "Creating pg_trgm extension..."
su -m postgres -c "$POSTGRES_PREFIX/bin/psql -d postgres -c
'CREATE EXTENSION IF NOT EXISTS pg_trgm;'" || warning_message "Failed
to create pg_trgm extension. You may need to create it manually in
your databases."
}

start_postgresql() {
echo "Starting PostgreSQL..."
su -m postgres -c "$POSTGRES_PREFIX/bin/pg_ctl -D $DATA_DIR -l
$LOGFILE -w start"
sleep 5 # Give the server a moment to start up
if ! su -m postgres -c "$POSTGRES_PREFIX/bin/pg_isready -q"; then
check_log_file
error_exit "Failed to start PostgreSQL."
fi
echo "PostgreSQL started successfully."
}

check_log_file() {
echo "Checking PostgreSQL log file for errors..."
if [ -f "$LOGFILE" ]; then
tail -n 50 "$LOGFILE"
else
echo "Log file not found at $LOGFILE"
fi
}

verify_custom_options() {
echo "Verifying custom build options..."
su -m postgres -c "$POSTGRES_PREFIX/bin/psql -d postgres -c \"SHOW
block_size;\"" || warning_message "Failed to verify block size."
su -m postgres -c "$POSTGRES_PREFIX/bin/psql -d postgres -c \"SHOW
segment_size;\"" || warning_message "Failed to verify segment size."
echo "Checking PostgreSQL version and compile-time options:"
su -m postgres -c "$POSTGRES_PREFIX/bin/postgres -V"
su -m postgres -c "$POSTGRES_PREFIX/bin/pg_config --configure"

echo "Verifying pg_trgm extension installation:"
su -m postgres -c "$POSTGRES_PREFIX/bin/psql -d postgres -c
\"SELECT * FROM pg_extension WHERE extname = 'pg_trgm';\"" ||
warning_message "Failed to verify pg_trgm extension."
}

stop_postgresql() {
echo "Stopping PostgreSQL..."
if command -v "$POSTGRES_PREFIX/bin/pg_ctl" > /dev/null 2>&1; then
su -m postgres -c "$POSTGRES_PREFIX/bin/pg_ctl -D $DATA_DIR
stop -m fast" || warning_message "Failed to stop PostgreSQL."
else
echo "pg_ctl command not found; assuming PostgreSQL is not running."
fi
}

uninstall_postgresql() {
echo "Uninstalling PostgreSQL..."
stop_postgresql
if [ -d "$POSTGRES_PREFIX" ]; then
rm -rf "$POSTGRES_PREFIX" || warning_message "Failed to remove
PostgreSQL directories."
echo "PostgreSQL uninstalled successfully."
else
echo "No PostgreSQL installation detected."
fi
}

perform_installation() {
check_prerequisites
create_postgres_user
ensure_install_directory
download_postgresql
configure_postgresql
compile_postgresql
install_postgresql
setup_environment
initialize_database
start_postgresql
create_extension_pg_trgm
check_log_file
verify_custom_options
echo "PostgreSQL installed and configured successfully with
pg_trgm extension!"
}

# Ensure cleanup happens on script exit
trap cleanup EXIT

# Main function
case "$1" in
stop)
stop_postgresql
;;
uninstall)
uninstall_postgresql
;;
install)
perform_installation
;;
*)
echo "Usage: $0 {install|stop|uninstall}"
exit 1
;;
esac