Problem building on LinuxMint 19

[Blake M. <bl...@mc...>]

Greetings,

I am trying to build the latest GIT clone of CLISP from
https://gitlab.com/gnu-clisp/clisp.git on a 64 bit LinuxMint 19 box.  What
I am getting on a clean checkout is:

$ sh -vx configure --with-threads=POSIX_THREADS with-gcc
[...]
Configure findings:
  FFI:        ${cl_cv_have_ffcall} (user requested: ${do_ffi})
  readline:   ${ac_cv_have_readline} (user requested: ${ac_cv_use_readline})
  libsigsegv: ${gl_cv_lib_sigsegv}
EOF
+ cat
Configure findings:
  FFI:        yes (user requested: default)
  readline:   yes (user requested: default)
  libsigsegv: yes

# The user can set MAKE. In particular, on IRIX, VPATH builds require GNU
make.
if test -z "${MAKE}"; then
  MAKE=make
fi
+ test -z
+ MAKE=make

# are any FFI modules requested?
ffi_modules=''
+ ffi_modules=
for module in ${all_modules}; do
  mdir=${ABS_SRCDIR}/modules/${module}
  test -d ${mdir} || fail "$0: ${mdir} is not an existing directory"
  if test -r ${mdir}/configure.in; then
    grep 'CL_MODULE_COMMON_CHECKS.*ffi' ${mdir}/configure.in > /dev/null
2>&1 && \
      ffi_modules=${ffi_modules}" ${module}"
  elif grep '.*\.c.*\.fas.*:\|.*\.fas.*\.c.*:' ${mdir}/Makefile > /dev/null
2>&1 ; then
    ffi_modules=${ffi_modules}" ${module}"
  elif grep ':use.*"FFI"' ${mdir}/*.lisp > /dev/null 2>&1; then
    ffi_modules=${ffi_modules}" ${module}"
  fi
done
if test -n "${ffi_modules}"; then
  test ${do_ffi} = no && \
    fail "$0: --without-ffcall is incompatible with requested
module(s):${ffi_modules}"
  test "${cl_cv_have_ffcall}" = yes || \
    fail "$0: modules${ffi_modules} require FFI"
fi
+ test -n
if [ ${do_ffi} != no -a "${cl_cv_have_ffcall}" = yes ]; then
  makemake_args="--with-dynamic-ffi ${makemake_args}"
fi
+ [ default != no -a yes = yes ]
+ makemake_args=--with-dynamic-ffi  --with-threads=POSIX_THREADS

if [ "${gl_cv_lib_sigsegv}" != "yes" ]; then
  if [ "${ignore_absence_of_libsigsegv}" = "yes" ]; then
    echo "As you requested, we will proceed without libsigsegv..."
  else
    if [ "$ac_cv_build" = "$ac_cv_host" ]; then host_arg="";
    else host_arg=" --host=$ac_cv_host --build=$ac_cv_build";
    fi
    cat <<EOF 1>&2
$0: libsigsegv was not detected, thus some features, such as
  generational garbage collection and
  stack overflow detection in interpreted Lisp code
cannot be provided.
Please install libsigsegv like this:
EOF
    if [ "${CC+set}" = "set" ]; then
      echo "  CC='$CC'; export CC" 1>&2
    fi
    libsigsegv_targz=`echo "$libsigsegv_url" | sed -e 's|^.*/||'`
    libsigsegv_dirname=`echo "$libsigsegv_targz" | sed -e 's|\.tar\.gz$||'`
    cat <<EOF 1>&2
  mkdir prerequisites; cd prerequisites; prefix=\`pwd\`/${ac_cv_host}
  wget ${libsigsegv_url}
  tar xfz ${libsigsegv_targz}
  cd ${libsigsegv_dirname}
  ./configure${host_arg} --prefix=\${prefix} && ${MAKE} && ${MAKE} check &&
${MAKE} install
  cd ../..
  rm -f ${DIRNAME}/config.cache
  ./configure --with-libsigsegv-prefix=\${prefix} $*
If you insist on building without libsigsegv, please pass
  --ignore-absence-of-libsigsegv
to this script:
  ./configure --ignore-absence-of-libsigsegv $*
If you have installed libsigsegv, but clisp does not detect it,
you might have installed it incorrectly, see section 2 in in unix/INSTALL.
EOF
    exit 1;
  fi
fi
+ [ yes != yes ]

# CLISP needs a lot of stack space for bootstrapping,
# and insufficient stack space manifests itself via arbitrary GC errors.
# It was believed that 8192 is enough until power5 came along:
# https://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=166347
# But this affects only the powerpc CPU, because it has lots of reserved
space
# in its stack frame layout (see section 2.2.2 of
# "Power Architecture 64-Bit ELF V2 ABI Specification"
# https://members.openpowerfoundation.org/document/dl/576 ).
case ${ac_cv_host} in
  *-*-rs6000 | *-*-rs6000-* | *-*-powerpc* | *-*-ppc*)
    STACK_LIMIT=16384 ;;
  *)
    STACK_LIMIT=8192 ;;
esac
+ STACK_LIMIT=8192
stacksizelimit=`ulimit -s 2>/dev/null || :` # cygwin /bin/sh ulimit is
broken
+ ulimit -s
+ stacksizelimit=8192
# need 3 separate test calls because of "integer expression expected" errors
# when $stacksizelimit is "" or "unlimited" (no short-circuiting!)
set +e;
+ set +e
test -z "$stacksizelimit" || { test "$stacksizelimit" != unlimited && test
"$stacksizelimit" -lt ${STACK_LIMIT}; }
+ test -z 8192
+ test 8192 != unlimited
+ test 8192 -lt 8192
STACK_TOO_SMALL=$?      # 0=true => need to reset; 1=false => big enough
+ STACK_TOO_SMALL=1
set -e
+ set -e

cd "$ABS_DIRNAME"
+ cd /home/blake/Backups/clisp.git/with-gcc
echo "./makemake $makemake_args > Makefile"
+ echo ./makemake --with-dynamic-ffi  --with-threads=POSIX_THREADS >
Makefile
./makemake --with-dynamic-ffi  --with-threads=POSIX_THREADS > Makefile
./makemake $makemake_args > Makefile
+ ./makemake --with-dynamic-ffi --with-threads=POSIX_THREADS
${MAKE} config.lisp
+ make config.lisp
cp -p ../src/cfgunix.lisp config.lisp
chmod +w config.lisp
echo '(setq *clhs-root-default* "
http://www.ai.mit.edu/projects/iiip/doc/CommonLISP/HyperSpec/")' >>
config.lisp

if test -z "$do_cbc"; then
  echo
  echo "To continue building CLISP, the following commands are recommended"
  echo "  (cf. unix/INSTALL step 4 ff):"
  if test "$DIRNAME" != "."; then
    echo "    cd $DIRNAME"
  fi
  echo "    ${EDITOR:-vi} config.lisp"
  if [ "${STACK_TOO_SMALL}" = 0 ]; then
    cat <<EOF
# The default stack size on your platform is insufficient
# and must be increased to at least ${STACK_LIMIT}.  You must do either
# 'ulimit -s ${STACK_LIMIT}' (for Bourne shell derivatives, e.g., bash and
zsh)
# or 'limit stacksize ${STACK_LIMIT}' (for C shell derivarives, e.g., tcsh)
EOF
  fi
  cat <<EOF
    ${MAKE}
# CLISP self-test:
    ${MAKE} check
# Test non-portable features and modules
    ${MAKE} extracheck mod-check
EOF
else
  if [ -n "${edit_config}" ]; then
    ${MAKE} config.lisp
    ${EDITOR:-vi} config.lisp
  fi
  if [ "${STACK_TOO_SMALL}" = 0 ]; then
    set +e; ulimit -s ${STACK_LIMIT} 2>/dev/null; set -e;
  fi
  run 2 ${MAKE}
  run 3 ${MAKE} check
  if test "$do_cbc" = 2; then
    run 4 ${MAKE} extracheck
    run 5 ${MAKE} base-mod-check
    # Disabled because the rawsock tests hang on Solaris.
    # run 6 ${MAKE} full-mod-check
  fi
  # report results:
  for log in 1 2 3 4 5 # 6
  do
    stepresult=`sed -n -e '$p' cbcstep${log}.log`
    echo "Step ${log} ${stepresult}"
  done
  # Fail if one of the commands "make" or "make check" failed.
  # "make extracheck" and "make mod-check" are allowed to fail.
  sed -n -e '$p' cbcstep2.log | grep ' SUCCEEDED$' >/dev/null || exit 1
  sed -n -e '$p' cbcstep3.log | grep ' SUCCEEDED$' >/dev/null || exit 1
  if test "$do_cbc" != 2; then
    cat <<EOF
# Now you can test non-portable features and modules:
    ${MAKE} extracheck mod-check
EOF
  fi
fi
+ test -z
+ echo

+ echo To continue building CLISP, the following commands are recommended
To continue building CLISP, the following commands are recommended
+ echo   (cf. unix/INSTALL step 4 ff):
  (cf. unix/INSTALL step 4 ff):
+ test with-gcc != .
+ echo     cd with-gcc
    cd with-gcc
+ echo     vi config.lisp
    vi config.lisp
+ [ 1 = 0 ]
+ cat
    make
# CLISP self-test:
    make check
# Test non-portable features and modules
    make extracheck mod-check
$ cd with-gcc
$ make
[...]
mkdir data
cd data && ln -s ../../utils/unicode/UnicodeDataFull.txt .
cd data && ln -s ../../doc/Symbol-Table.text .
gcc -g -O2 -no-integrated-cpp -W -Wswitch -Wcomment -Wpointer-arith
-Wreturn-type -Wmissing-declarations -Wimplicit -Wno-sign-compare
-Wno-format-nonliteral -Wno-shift-negative-value -O -fwrapv -pthread
-fno-strict-aliasing -DNO_ASM -DENABLE_UNICODE -DMULTITHREAD
-DPOSIX_THREADS -DDYNAMIC_FFI -DDYNAMIC_MODULES  -Wl,--export-dynamic
spvw.o spvwtabf.o spvwtabs.o spvwtabo.o eval.o control.o encoding.o
pathname.o stream.o socket.o io.o funarg.o array.o hashtabl.o list.o
package.o record.o weak.o sequence.o charstrg.o debug.o error.o misc.o
time.o predtype.o symbol.o lisparit.o i18n.o foreign.o unixaux.o zthread.o
built.o modules.o libgnu.a  -lreadline -ltermcap -ldl -lffcall  -lsigsegv
 -o lisp.run
./lisp.run -marc > marc.out
./lisp.run -B . -N locale -E UTF-8 -Emisc 1:1 -Epathname 1:1 -norc -m 2MW
-lp ../src/ -x '(and (load "../src/init.lisp") (sys::%saveinitmem)
(ext::exit)) (ext::exit t)'
  i i i i i i i       ooooo    o        ooooooo   ooooo   ooooo
  I I I I I I I      8     8   8           8     8     o  8    8
  I  \ `+' /  I      8         8           8     8        8    8
   \  `-+-'  /       8         8           8      ooooo   8oooo
    `-__|__-'        8         8           8           8  8
        |            8     o   8           8     o     8  8
  ------+------       ooooo    8oooooo  ooo8ooo   ooooo   8

Welcome to GNU CLISP 2.49.93+ (2018-02-18) <http://clisp.org/>

Copyright (c) Bruno Haible, Michael Stoll 1992-1993
Copyright (c) Bruno Haible, Marcus Daniels 1994-1997
Copyright (c) Bruno Haible, Pierpaolo Bernardi, Sam Steingold 1998
Copyright (c) Bruno Haible, Sam Steingold 1999-2000
Copyright (c) Sam Steingold, Bruno Haible 2001-2018

Type :h and hit Enter for context help.

;; Loading file ../src/defseq.lisp ...
;; Loaded file ../src/defseq.lisp
;; Loading file ../src/backquote.lisp ...
;; Loaded file ../src/backquote.lisp
;; Loading file ../src/defmacro.lisp ...
*** - handle_fault error2 ! address = 0x8 not in
[0x1000000c0000,0x1000000c0000) !
SIGSEGV cannot be cured. Fault address = 0x8.
GC count: 2
Space collected by GC: 324488
Run time: 0 83247
Real time: 0 834816
GC time: 0 2327
Permanently allocated: 192224 bytes.
Currently in use: 724080 bytes.
Free space: 0 bytes.
Makefile:1472: recipe for target 'interpreted.mem' failed
make: *** [interpreted.mem] Segmentation fault (core dumped)
$ ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 31583
max locked memory       (kbytes, -l) 16384
max memory size         (kbytes, -m) unlimited
open files                      (-n) 1024
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) unlimited
cpu time               (seconds, -t) unlimited
max user processes              (-u) 31583
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited


Thanks!

Blake McBride