hints/catamount.sh

   1 #
   2 # Hints for the Cray XT4 Catamount/Qk system:
   3 # cross-compilation host is a SuSE x86_64-linux,
   4 # execution at the target with the 'yod' utility,
   5 # linux.sh will run this hints file when necessary.
   6 #
   7 # cc.sh: compiles the code with the cross-compiler, patches main/exit/_exit
   8 # (and traps signals) to be wrappers that echo the exit code.
   9 #
  10 # run.sh: runs the executable with yod and collects the exit status,
  11 # and exits with that status.
  12 #
  13 # You probably should do the compilation in non-Lustre filesystem
  14 # because Lustre does not support all the POSIX system calls, which may
  15 # cause weird errors during the Perl build:
  16 # 1182003549.604836:3-24:(super.c:1516:llu_iop_fcntl()): unsupported fcntl cmd 2
  17 #
  18 # As of 2007-Sep (pre-5.10) miniperl, libperl.a, and perl can be successfully
  19 # built; no extensions are built.  It would be hard since Perl cannot run
  20 # anything external (pipes, system(), backticks or fork/exec, or globbing)
  21 # (which breaks MakeMaker, and confuses ext/util/make_ext).
  22 #
  23 # To build:
  24 #
  25 #   sh Configure -des
  26 #   make perl
  27 #
  28 # "make install" won't work since it assumes file globbing (see above).
  29 # You can try the following manual way:
  30 #
  31 # mkdir -p /opt/perl-catamount
  32 # mkdir -p /opt/perl-catamount/include
  33 # mkdir -p /opt/perl-catamount/lib
  34 # mkdir -p /opt/perl-catamount/lib/perl5/5.33.3
  35 # mkdir -p /opt/perl-catamount/bin
  36 # cp *.h /opt/perl-catamount/include
  37 # cp libperl.a /opt/perl-catamount/lib
  38 # cp -pr lib/* /opt/perl-catamount/lib/perl5/5.33.3
  39 # cp miniperl perl run.sh cc.sh /opt/perl-catamount/lib
  40 #
  41 # With the headers and the libperl.a you can embed Perl to your Catamount
  42 # application, see pod/perlembed.pod.  You can do for example:
  43 #
  44 # cc -I/opt/perl-catamount/include -L/opt/perl-catamount/lib -o embed embed.c
  45 # yod -sz 1 ./embed -le 'print sqrt(2)'
  46 #
  47 # You might want to have the run.sh execution wrapper around (it gets created
  48 # in the Perl build directory) if you want to run the miniperl or perl in
  49 # the XT4.  It collects the exit status (note that yod is run with "-sz 1",
  50 # so only one instance is run), and possible crash status (bare yod does
  51 # not collect the exit status).  For example:
  52 #
  53 #   sh /opt/perl-catamount/bin/run.sh /opt/perl-catamount/bin/perl -le 'print 42'
  54 #
  55 # or if you are still in the build directory:
  56 #
  57 #   sh run.sh ./perl -le 'print 2*3*7'
  58 #
  59 # The cc.sh is a wrapper for the Catamount cc used when building Perl
  60 # (and before that, when running Configure), it arranges for the main()
  61 # exit(), _exit() to be wrapped so that the exit/crash status can be
  62 # collected (by run.sh).
  63 #
  64
  65 case "$prefix" in
  66 '') prefix=/opt/perl-catamount ;;
  67 esac
  68 cat >&4 <<__EOF1__
  69 ***
  70 *** You seem to be compiling in Linux for the Catamount/Qk environment.
  71 *** I'm therefore not going to install perl as /usr/bin/perl.
  72 *** Perl will be installed under $prefix.
  73 ***
  74 __EOF1__
  75
  76 archname='x86_64-catamount'
  77 archobjs='catalib.o'
  78 d_mmap='undef'
  79 d_setlocale='undef' # There is setlocale() but no locales.
  80 hintfile='catamount'
  81 i_arpainet='undef'
  82 i_db='undef'
  83 i_netdb='undef'
  84 i_niin='undef'
  85 incpth=' '
  86 installusrbinperl='undef'
  87 libswanted="m crypt c"
  88 libpth=' '
  89 locincpth=' '
  90 nonxs_ext=' '
  91 osname='catamount'
  92 procselfexe='undef'
  93 static_ext=' '
  94 usedl='undef'
  95 useithreads='undef'
  96 uselargefiles='define'
  97 usenm='undef'
  98 usethreads='undef'
  99 use64bitall='define'
 100
 101 BUILD=$PWD
 102
 103 case "`yod -Version 2>&1`" in
 104 Red*) ;; # E.g. "Red Storm Protocol Release 2.1.0"
 105 *) echo >&4 "Could not find 'yod', aborting."
 106    exit 1 ;;
 107 esac
 108 run=$BUILD/run.sh
 109 cat > $run <<'__EOF2__'
 110 #!/bin/sh
 111 #
 112 # $run
 113 #
 114 yod -sz 1 "$@" 2> .yod$$e > .yod$$o
 115 status=`awk '/^cata: exe .* pid [0-9][0-9]* (main|exit|_exit) [0-9][0-9]*$/ {print $NF}' .yod$$o|tail -1`
 116 grep -v "sz is 1" .yod$$e
 117 grep -v "^cata: exe .* pid [0-9][0-9]* " .yod$$o
 118 grep "^cata: exe .* signal " .yod$$o
 119 rm -f .yod$$o .yod$$e
 120 exit $status
 121 __EOF2__
 122 chmod 755 $run
 123 case "`cc -V 2>&1`" in
 124 *catamount*) ;; # E.g. "/opt/xt-pe/1.5.41/bin/snos64/cc: INFO: catamount target is being used"
 125 *) echo "Could not find 'cc' for catamount, aborting."
 126    exit 1 ;;
 127 esac
 128
 129 cc=$BUILD/cc.sh
 130 cat > $cc <<__EOF3a__
 131 #!/bin/sh
 132 #
 133 # $0
 134 #
 135 # This is essentially a frontend driver for the Catamount cc.
 136 # We arrange for
 137 # (1) the main(), exit(), _exit() being wrapped (cpp-defined)
 138 #     catamain(), cataexit(), and _cataexit()
 139 # (2) the actual main() etc. are in cata.c, and cata*.o are
 140 #     linked in when needed
 141 # (3) signals being caught
 142 # All this mostly for being able to catch the exit status (or crash cause).
 143 #
 144 argv=''
 145 srco=''
 146 srct=''
 147 exe=''
 148 defs='-Dmain=catamain -Dexit=cataexit -D_exit=_cataexit'
 149 argv=''
 150 BUILD=$BUILD
 151 __EOF3a__
 152 cat >> $cc <<'__EOF3b__'
 153 case "$1" in
 154 --cata_o) ;;
 155 *) if test ! -f catalib.o
 156    then
 157      if test ! -f catalib.c
 158      then
 159        if test -f ../catalib.c # If compiling in UU during Configure.
 160        then
 161          cp ../catalib.c catalib.c
 162          cp ../catamain.c catamain.c
 163          cp ../cata.h cata.h
 164        fi
 165      fi
 166      $0 --cata_o -c catalib.c || exit 1
 167      $0 --cata_o -c catamain.c || exit 1
 168    fi
 169    ;;
 170 esac
 171 while test $# -ne 0
 172 do
 173   i=$1
 174   shift
 175   case "$i" in
 176   --cata_o) ;;
 177   *.c)
 178     argv="$argv $defs"
 179     defs=""
 180     if test ! -f $i
 181     then
 182       echo "$0: $i: No such file or directory"
 183       exit 1
 184     fi
 185     j=$i$$.c
 186     rm -f $j
 187     if grep -q -s '#include "cata.h"' $i
 188     then
 189       :
 190     else
 191       cat >>$j<<__EOF4__
 192 #include "cata.h"
 193 # 1 "$i"
 194 __EOF4__
 195     fi
 196     cat $i >>$j
 197     if grep -q -s 'int main()' $i
 198     then
 199       argv="$argv -Dmain0"
 200     else
 201       if grep -q -s 'int main([^,]*,[^,]*)' $i
 202       then
 203         argv="$argv -Dmain2"
 204       else
 205         if grep -q -s 'int main([^,]*,[^,]*,[^,]*)' $i
 206         then
 207           argv="$argv -Dmain3"
 208         fi
 209       fi
 210     fi
 211     argv="$argv $j"
 212     srct="$j"
 213     srco="$i"
 214     ;;
 215   *.o)
 216     if test ! -f "$i"
 217     then
 218       c=$(echo $i|sed 's/\.o$/.c/')
 219       $0 -c $c || exit 1
 220     fi
 221     argv="$argv $i"
 222     ;;
 223   -o)
 224     exe="$1"
 225     argv="$argv -o $exe -Dargv0=$exe"
 226     shift
 227     ;;
 228   *)
 229     argv="$argv $i"
 230     ;;
 231   esac
 232 done
 233 case "$exe" in
 234 '') ;;
 235 *) case "$argv" in
 236    *catalib.o*|*" perlmain.o "*) ;;
 237    *) argv="$argv catalib.o" ;;
 238    esac
 239    case "$argv" in
 240    *catamain.o*) ;;
 241    *) argv="$argv catamain.o" ;;
 242    esac
 243    ;;
 244 esac
 245 cc -I$BUILD $argv 2> .cc$$e > .cc$$o
 246 status=$?
 247 egrep -v 'catamount target|'$$'\.c:$' .cc$$e 1>&2
 248 case "`grep "is not implemented" .cc$$e`" in
 249 *"will always fail"*) status=1 ;;
 250 esac
 251 cat .cc$$o
 252 rm -f .cc$$o
 253 case "$status" in
 254 0) rm -f .cc$$e $srct
 255    ;;
 256 esac
 257 objt=`echo $srct|sed -e 's/\.c$/.o/'`
 258 objo=`echo $srco|sed -e 's/\.c$/.o/'`
 259 if test -n "$objt" -a -f "$objt"
 260 then
 261   mv -f $objt $objo
 262 fi
 263 exit $status
 264 __EOF3b__
 265 chmod 755 $cc
 266
 267 cat >cata.h<<__EOF6__
 268 #ifndef CATA_H
 269 #define CATA_H
 270 void cataexit(int status);
 271 void _cataexit(int status);
 272 void catasigsetup();
 273 void catasighandle(int signum);
 274 #ifdef main0
 275 int catamain();
 276 #else
 277 #ifdef main2
 278 int main(int argc, char **argv);
 279 #else
 280 int main(int argc, char **argv, char **env);
 281 #endif
 282 #endif
 283 #endif
 284 #ifdef argv0
 285 #define ARGV0 STRINGIFY(argv0)
 286 #else
 287 #define ARGV0 argv0
 288 #endif
 289 __EOF6__
 290
 291 cat >catalib.c<<__EOF7__
 292 #include <stdio.h>
 293 #include <signal.h>
 294 #undef printf
 295 #undef main
 296 #undef exit
 297 #undef _exit
 298 #include "cata.h"
 299 char* argv0;
 300 void cataexit(int status) {
 301   printf("cata: exe %s pid %d exit %d\n", ARGV0, getpid(), status);
 302   exit(status);
 303 }
 304 void _cataexit(int status) {
 305   printf("cata: exe %s pid %d _exit %d\n", ARGV0, getpid(), status);
 306   _exit(status);
 307 }
 308 void catasighandle(int signum) {
 309   int core = 0;
 310   printf("cata: exe %s pid %d signal %d\n", ARGV0, getpid(), signum);
 311   switch (signum) {
 312   case SIGQUIT:
 313   case SIGILL:
 314   case SIGTRAP:
 315   case SIGABRT:
 316   case SIGBUS:
 317   case SIGSEGV:
 318   case SIGXCPU:
 319   case SIGXFSZ:
 320     core = 0200;
 321     break;
 322   default:
 323     break;
 324   }
 325   cataexit(core << 8 | signum);
 326 }
 327 void catasigsetup() {
 328   signal(SIGHUP, catasighandle);
 329   signal(SIGINT, catasighandle);
 330   signal(SIGQUIT, catasighandle);
 331   signal(SIGILL, catasighandle);
 332   signal(SIGTRAP, catasighandle);
 333   signal(SIGABRT, catasighandle);
 334   signal(SIGIOT, catasighandle);
 335   /* KILL */
 336   signal(SIGBUS, catasighandle);
 337   signal(SIGFPE, catasighandle);
 338   signal(SIGUSR1, catasighandle);
 339   signal(SIGUSR2, catasighandle);
 340   signal(SIGSEGV, catasighandle);
 341   signal(SIGPIPE, catasighandle);
 342   signal(SIGALRM, catasighandle);
 343   signal(SIGTERM, catasighandle);
 344   signal(SIGSTKFLT, catasighandle);
 345   signal(SIGCHLD, catasighandle);
 346   signal(SIGCONT, catasighandle);
 347   /* STOP */
 348   signal(SIGTSTP, catasighandle);
 349   signal(SIGTTIN, catasighandle);
 350   signal(SIGTTOU, catasighandle);
 351   signal(SIGURG, catasighandle);
 352   signal(SIGXCPU, catasighandle);
 353   signal(SIGXFSZ, catasighandle);
 354   signal(SIGVTALRM, catasighandle);
 355   signal(SIGPROF, catasighandle);
 356   signal(SIGWINCH, catasighandle);
 357   signal(SIGIO, catasighandle);
 358   signal(SIGPWR, catasighandle);
 359   signal(SIGSYS, catasighandle);
 360 }
 361 void boot_DynaLoader (void* cv) { }
 362 __EOF7__
 363 cat >catamain.c<<__EOF8__
 364 #include <stdio.h>
 365 #undef printf
 366 #undef main
 367 #undef exit
 368 #undef _exit
 369 #include "cata.h"
 370 extern char* argv0;
 371 int main(int argc, char *argv[], char *envv[]) {
 372   int status;
 373 #ifndef argv0
 374   argv0 = argv[0];
 375 #endif
 376   catasigsetup();
 377   status =
 378 #ifdef main0
 379     catamain();
 380 #else
 381 #ifdef main2
 382     catamain(argc, argv);
 383 #else
 384     catamain(argc, argv, envv);
 385 #endif
 386 #endif
 387   printf("cata: exe %s pid %d main %d\n", ARGV0, getpid(), status);
 388   return status;
 389 }
 390 __EOF8__
 391
 392 echo "Faking DynaLoader"
 393 touch DynaLoader.o # Oh, the agony.
 394
 395 # That's it.