config-scripts/cups-compiler.m4

   1 dnl
   2 dnl "$Id: cups-compiler.m4 6976 2007-09-18 20:39:31Z mike $"
   3 dnl
   4 dnl   Compiler stuff for the Common UNIX Printing System (CUPS).
   5 dnl
   6 dnl   Copyright 2007 by Apple Inc.
   7 dnl   Copyright 1997-2007 by Easy Software Products, all rights reserved.
   8 dnl
   9 dnl   These coded instructions, statements, and computer programs are the
  10 dnl   property of Apple Inc. and are protected by Federal copyright
  11 dnl   law.  Distribution and use rights are outlined in the file "LICENSE.txt"
  12 dnl   which should have been included with this file.  If this file is
  13 dnl   file is missing or damaged, see the license at "http://www.cups.org/".
  14 dnl
  15
  16 dnl Clear the debugging and non-shared library options unless the user asks
  17 dnl for them...
  18 OPTIM=""
  19 AC_SUBST(OPTIM)
  20
  21 AC_ARG_WITH(optim, [  --with-optim="flags"    set optimization flags ])
  22 AC_ARG_ENABLE(debug, [  --enable-debug          turn on debugging, default=no],
  23         [if test x$enable_debug = xyes; then
  24                 OPTIM="-g"
  25         fi])
  26
  27 dnl Setup general architecture flags...
  28 AC_ARG_WITH(archflags, [  --with-archflags="flags"
  29                           set default architecture flags ])
  30
  31 if test -z "$with_archflags"; then
  32         ARCHFLAGS=""
  33         LDARCHFLAGS=""
  34 else
  35         ARCHFLAGS="$with_archflags"
  36         if test "$uname" = Darwin; then
  37                 # Only link 32-bit programs - 64-bit is for the shared
  38                 # libraries...
  39                 LDARCHFLAGS="`echo $ARCHFLAGS | sed -e '1,$s/-arch x86_64//' -e '1,$s/-arch ppc64//'`"
  40         else
  41                 LDARCHFLAGS="$ARCHFLAGS"
  42         fi
  43 fi
  44
  45 AC_SUBST(ARCHFLAGS)
  46 AC_SUBST(LDARCHFLAGS)
  47
  48 dnl Setup support for separate 32/64-bit library generation...
  49 AC_ARG_WITH(arch32flags, [  --with-arch32flags="flags"
  50                           specifies 32-bit architecture flags])
  51 ARCH32FLAGS=""
  52 AC_SUBST(ARCH32FLAGS)
  53
  54 AC_ARG_WITH(arch64flags, [  --with-arch64flags="flags"
  55                           specifies 64-bit architecture flags])
  56 ARCH64FLAGS=""
  57 AC_SUBST(ARCH64FLAGS)
  58
  59 dnl Position-Independent Executable support on Linux...
  60 AC_ARG_ENABLE(pie, [  --enable-pie            use GCC -fPIE option, default=no])
  61
  62 dnl Read-only data/program support on Linux...
  63 AC_ARG_ENABLE(relro, [  --enable-relro          use GCC relro option, default=no])
  64
  65 dnl Update compiler options...
  66 CXXLIBS=""
  67 AC_SUBST(CXXLIBS)
  68
  69 PIEFLAGS=""
  70 AC_SUBST(PIEFLAGS)
  71
  72 RELROFLAGS=""
  73 AC_SUBST(RELROFLAGS)
  74
  75 LIBCUPSORDER="libcups.order"
  76 AC_ARG_WITH(libcupsorder, [  --with-libcupsorder     libcups secorder file, default=libcups.order],
  77         if test -f "$withval"; then
  78                 LIBCUPSORDER="$withval"
  79         fi)
  80 AC_SUBST(LIBCUPSORDER)
  81
  82 LIBCUPSIMAGEORDER="libcupsimage.order"
  83 AC_ARG_WITH(libcupsimageorder, [  --with-libcupsimagesorder
  84                           libcupsimage secorder file, default=libcupsimage.order],
  85         if test -f "$withval"; then
  86                 LIBCUPSIMAGEORDER="$withval"
  87         fi)
  88 AC_SUBST(LIBCUPSIMAGEORDER)
  89
  90 if test -n "$GCC"; then
  91         # Add GCC-specific compiler options...
  92         if test -z "$OPTIM"; then
  93                 if test "x$with_optim" = x; then
  94                         # Default to optimize-for-size and debug
  95                         OPTIM="-Os -g"
  96                 else
  97                         OPTIM="$with_optim $OPTIM"
  98                 fi
  99         fi
 100
 101         if test $PICFLAG = 1 -a $uname != AIX; then
 102                 OPTIM="-fPIC $OPTIM"
 103         fi
 104
 105         case $uname in
 106                 Linux*)
 107                         if test x$enable_pie = xyes; then
 108                                 PIEFLAGS="-pie -fPIE"
 109                         fi
 110
 111                         if test x$enable_relro = xyes; then
 112                                 RELROFLAGS="-Wl,-z,relro"
 113                         fi
 114                         ;;
 115
 116                 *)
 117                         if test x$enable_pie = xyes; then
 118                                 echo "Sorry, --enable-pie is not supported on this OS!"
 119                         fi
 120                         ;;
 121         esac
 122
 123         if test "x$with_optim" = x; then
 124                 # Add useful warning options for tracking down problems...
 125                 OPTIM="-Wall -Wno-format-y2k $OPTIM"
 126                 # Additional warning options for alpha testing...
 127                 OPTIM="-Wshadow -Wunused $OPTIM"
 128         fi
 129
 130         case "$uname" in
 131                 HP-UX*)
 132                         if test "x$enable_32bit" = xyes; then
 133                                 # Build 32-bit libraries, 64-bit base...
 134                                 if test -z "$with_arch32flags"; then
 135                                         ARCH32FLAGS="-milp32"
 136                                 else
 137                                         ARCH32FLAGS="$with_arch32flags"
 138                                 fi
 139
 140                                 if test -z "$with_archflags"; then
 141                                         if test -z "$with_arch64flags"; then
 142                                                 ARCHFLAGS="-mlp64"
 143                                         else
 144                                                 ARCHFLAGS="$with_arch64flags"
 145                                         fi
 146                                 fi
 147                         fi
 148
 149                         if test "x$enable_64bit" = xyes; then
 150                                 # Build 64-bit libraries, 32-bit base...
 151                                 if test -z "$with_arch64flags"; then
 152                                         ARCH64FLAGS="-mlp64"
 153                                 else
 154                                         ARCH64FLAGS="$with_arch64flags"
 155                                 fi
 156
 157                                 if test -z "$with_archflags"; then
 158                                         if test -z "$with_arch32flags"; then
 159                                                 ARCHFLAGS="-milp32"
 160                                         else
 161                                                 ARCHFLAGS="$with_arch32flags"
 162                                         fi
 163                                 fi
 164                         fi
 165                         ;;
 166
 167                 IRIX)
 168                         if test "x$enable_32bit" = xyes; then
 169                                 # Build 32-bit libraries, 64-bit base...
 170                                 if test -z "$with_arch32flags"; then
 171                                         ARCH32FLAGS="-n32 -mips3"
 172                                 else
 173                                         ARCH32FLAGS="$with_arch32flags"
 174                                 fi
 175
 176                                 if test -z "$with_archflags"; then
 177                                         if test -z "$with_arch64flags"; then
 178                                                 ARCHFLAGS="-64 -mips4"
 179                                         else
 180                                                 ARCHFLAGS="$with_arch64flags"
 181                                         fi
 182                                 fi
 183                         fi
 184
 185                         if test "x$enable_64bit" = xyes; then
 186                                 # Build 64-bit libraries, 32-bit base...
 187                                 if test -z "$with_arch64flags"; then
 188                                         ARCH64FLAGS="-64 -mips4"
 189                                 else
 190                                         ARCH64FLAGS="$with_arch64flags"
 191                                 fi
 192
 193                                 if test -z "$with_archflags"; then
 194                                         if test -z "$with_arch32flags"; then
 195                                                 ARCHFLAGS="-n32 -mips3"
 196                                         else
 197                                                 ARCHFLAGS="$with_arch32flags"
 198                                         fi
 199                                 fi
 200                         fi
 201                         ;;
 202
 203                 Linux*)
 204                         if test "x$enable_32bit" = xyes; then
 205                                 # Build 32-bit libraries, 64-bit base...
 206                                 if test -z "$with_arch32flags"; then
 207                                         ARCH32FLAGS="-m32"
 208                                 else
 209                                         ARCH32FLAGS="$with_arch32flags"
 210                                 fi
 211
 212                                 if test -z "$with_archflags"; then
 213                                         if test -z "$with_arch64flags"; then
 214                                                 ARCHFLAGS="-m64"
 215                                         else
 216                                                 ARCHFLAGS="$with_arch64flags"
 217                                         fi
 218                                 fi
 219                         fi
 220
 221                         if test "x$enable_64bit" = xyes; then
 222                                 # Build 64-bit libraries, 32-bit base...
 223                                 if test -z "$with_arch64flags"; then
 224                                         ARCH64FLAGS="-m64"
 225                                 else
 226                                         ARCH64FLAGS="$with_arch64flags"
 227                                 fi
 228
 229                                 if test -z "$with_archflags"; then
 230                                         if test -z "$with_arch32flags"; then
 231                                                 ARCHFLAGS="-m32"
 232                                         else
 233                                                 ARCHFLAGS="$with_arch32flags"
 234                                         fi
 235                                 fi
 236                         fi
 237                         ;;
 238
 239                 SunOS*)
 240                         if test "x$enable_32bit" = xyes; then
 241                                 # Build 32-bit libraries, 64-bit base...
 242                                 if test -z "$with_arch32flags"; then
 243                                         ARCH32FLAGS="-m32"
 244                                 else
 245                                         ARCH32FLAGS="$with_arch32flags"
 246                                 fi
 247
 248                                 if test -z "$with_archflags"; then
 249                                         if test -z "$with_arch64flags"; then
 250                                                 ARCHFLAGS="-m64"
 251                                         else
 252                                                 ARCHFLAGS="$with_arch64flags"
 253                                         fi
 254                                 fi
 255                         fi
 256
 257                         if test "x$enable_64bit" = xyes; then
 258                                 # Build 64-bit libraries, 32-bit base...
 259                                 if test -z "$with_arch64flags"; then
 260                                         ARCH64FLAGS="-m64"
 261                                 else
 262                                         ARCH64FLAGS="$with_arch64flags"
 263                                 fi
 264
 265                                 if test -z "$with_archflags"; then
 266                                         if test -z "$with_arch32flags"; then
 267                                                 ARCHFLAGS="-m32"
 268                                         else
 269                                                 ARCHFLAGS="$with_arch32flags"
 270                                         fi
 271                                 fi
 272                         fi
 273                         ;;
 274         esac
 275 else
 276         # Add vendor-specific compiler options...
 277         case $uname in
 278                 AIX*)
 279                         if test -z "$OPTIM"; then
 280                                 if test "x$with_optim" = x; then
 281                                         OPTIM="-O2 -qmaxmem=6000"
 282                                 else
 283                                         OPTIM="$with_optim $OPTIM"
 284                                 fi
 285                         fi
 286                         ;;
 287                 HP-UX*)
 288                         if test -z "$OPTIM"; then
 289                                 if test "x$with_optim" = x; then
 290                                         OPTIM="+O2"
 291                                 else
 292                                         OPTIM="$with_optim $OPTIM"
 293                                 fi
 294                         fi
 295
 296                         CFLAGS="-Ae $CFLAGS"
 297                         # Warning 336 is "empty translation unit"
 298                         # Warning 829 is passing constant string as char *
 299                         CXXFLAGS="+W336,829 $CXXFLAGS"
 300
 301                         if test $PICFLAG = 1; then
 302                                 OPTIM="+z $OPTIM"
 303                         fi
 304
 305                         if test "x$enable_32bit" = xyes; then
 306                                 # Build 32-bit libraries, 64-bit base...
 307                                 if test -z "$with_arch32flags"; then
 308                                         ARCH32FLAGS="+DD32"
 309                                 else
 310                                         ARCH32FLAGS="$with_arch32flags"
 311                                 fi
 312
 313                                 if test -z "$with_archflags"; then
 314                                         if test -z "$with_arch64flags"; then
 315                                                 ARCHFLAGS="+DD64"
 316                                         else
 317                                                 ARCHFLAGS="$with_arch64flags"
 318                                         fi
 319                                 fi
 320                         fi
 321
 322                         if test "x$enable_64bit" = xyes; then
 323                                 # Build 64-bit libraries, 32-bit base...
 324                                 if test -z "$with_arch64flags"; then
 325                                         ARCH64FLAGS="+DD64"
 326                                 else
 327                                         ARCH64FLAGS="$with_arch64flags"
 328                                 fi
 329
 330                                 if test -z "$with_archflags"; then
 331                                         if test -z "$with_arch32flags"; then
 332                                                 ARCHFLAGS="+DD32"
 333                                         else
 334                                                 ARCHFLAGS="$with_arch32flags"
 335                                         fi
 336                                 fi
 337                         fi
 338                         ;;
 339                 IRIX)
 340                         if test -z "$OPTIM"; then
 341                                 if test "x$with_optim" = x; then
 342                                         OPTIM="-O2"
 343                                 else
 344                                         OPTIM="$with_optim $OPTIM"
 345                                 fi
 346                         fi
 347
 348                         if test "x$with_optim" = x; then
 349                                 OPTIM="-fullwarn -woff 1183,1209,1349,1506,3201 $OPTIM"
 350                         fi
 351
 352                         if test "x$enable_32bit" = xyes; then
 353                                 # Build 32-bit libraries, 64-bit base...
 354                                 if test -z "$with_arch32flags"; then
 355                                         ARCH32FLAGS="-n32 -mips3"
 356                                 else
 357                                         ARCH32FLAGS="$with_arch32flags"
 358                                 fi
 359
 360                                 if test -z "$with_archflags"; then
 361                                         if test -z "$with_arch64flags"; then
 362                                                 ARCHFLAGS="-64 -mips4"
 363                                         else
 364                                                 ARCHFLAGS="$with_arch64flags"
 365                                         fi
 366                                 fi
 367                         fi
 368
 369                         if test "x$enable_64bit" = xyes; then
 370                                 # Build 64-bit libraries, 32-bit base...
 371                                 if test -z "$with_arch64flags"; then
 372                                         ARCH64FLAGS="-64 -mips4"
 373                                 else
 374                                         ARCH64FLAGS="$with_arch64flags"
 375                                 fi
 376
 377                                 if test -z "$with_archflags"; then
 378                                         if test -z "$with_arch32flags"; then
 379                                                 ARCHFLAGS="-n32 -mips3"
 380                                         else
 381                                                 ARCHFLAGS="$with_arch32flags"
 382                                         fi
 383                                 fi
 384                         fi
 385                         ;;
 386                 OSF*)
 387                         # Tru64 UNIX aka Digital UNIX aka OSF/1
 388                         if test -z "$OPTIM"; then
 389                                 if test "x$with_optim" = x; then
 390                                         OPTIM="-O"
 391                                 else
 392                                         OPTIM="$with_optim"
 393                                 fi
 394                         fi
 395                         ;;
 396                 SunOS*)
 397                         # Solaris
 398                         if test -z "$OPTIM"; then
 399                                 if test "x$with_optim" = x; then
 400                                         OPTIM="-xO2"
 401                                 else
 402                                         OPTIM="$with_optim $OPTIM"
 403                                 fi
 404                         fi
 405
 406                         if test $PICFLAG = 1; then
 407                                 OPTIM="-KPIC $OPTIM"
 408                         fi
 409
 410                         if test "x$enable_32bit" = xyes; then
 411                                 # Compiling on a Solaris system, build 64-bit
 412                                 # binaries with separate 32-bit libraries...
 413                                 ARCH32FLAGS="-xarch=generic"
 414
 415                                 if test "x$with_optim" = x; then
 416                                         # Suppress all of Sun's questionable
 417                                         # warning messages, and default to
 418                                         # 64-bit compiles of everything else...
 419                                         OPTIM="-w $OPTIM"
 420                                 fi
 421
 422                                 if test -z "$with_archflags"; then
 423                                         if test -z "$with_arch64flags"; then
 424                                                 ARCHFLAGS="-xarch=generic64"
 425                                         else
 426                                                 ARCHFLAGS="$with_arch64flags"
 427                                         fi
 428                                 fi
 429                         else
 430                                 if test "x$enable_64bit" = xyes; then
 431                                         # Build 64-bit libraries...
 432                                         ARCH64FLAGS="-xarch=generic64"
 433                                 fi
 434
 435                                 if test "x$with_optim" = x; then
 436                                         # Suppress all of Sun's questionable
 437                                         # warning messages, and default to
 438                                         # 32-bit compiles of everything else...
 439                                         OPTIM="-w $OPTIM"
 440                                 fi
 441
 442                                 if test -z "$with_archflags"; then
 443                                         if test -z "$with_arch32flags"; then
 444                                                 ARCHFLAGS="-xarch=generic"
 445                                         else
 446                                                 ARCHFLAGS="$with_arch32flags"
 447                                         fi
 448                                 fi
 449                         fi
 450                         ;;
 451                 UNIX_SVR*)
 452                         # UnixWare
 453                         if test -z "$OPTIM"; then
 454                                 if test "x$with_optim" = x; then
 455                                         OPTIM="-O"
 456                                 else
 457                                         OPTIM="$with_optim $OPTIM"
 458                                 fi
 459                         fi
 460
 461                         if test $PICFLAG = 1; then
 462                                 OPTIM="-KPIC $OPTIM"
 463                         fi
 464                         ;;
 465                 *)
 466                         # Running some other operating system; inform the user they
 467                         # should contribute the necessary options to
 468                         # cups-support@cups.org...
 469                         echo "Building CUPS with default compiler optimizations; contact"
 470                         echo "cups-bugs@cups.org with uname and compiler options needed"
 471                         echo "for your platform, or set the CFLAGS and CXXFLAGS"
 472                         echo "environment variable before running configure."
 473                         ;;
 474         esac
 475 fi
 476
 477 # Add general compiler options per platform...
 478 case $uname in
 479         HP-UX*)
 480                 # HP-UX 10.20 (at least) needs this definition to get the
 481                 # h_errno global...
 482                 OPTIM="$OPTIM -D_XOPEN_SOURCE_EXTENDED"
 483
 484                 # HP-UX 11.00 (at least) needs this definition to get the
 485                 # u_short type used by the IP headers...
 486                 OPTIM="$OPTIM -D_INCLUDE_HPUX_SOURCE"
 487
 488                 # HP-UX 11.23 (at least) needs this definition to get the
 489                 # IPv6 header to work...
 490                 OPTIM="$OPTIM -D_HPUX_SOURCE"
 491                 ;;
 492
 493         OSF*)
 494                 # Tru64 UNIX aka Digital UNIX aka OSF/1 need to be told
 495                 # to be POSIX-compliant...
 496                 OPTIM="$OPTIM -D_XOPEN_SOURCE=500 -D_XOPEN_SOURCE_EXTENDED -D_OSF_SOURCE"
 497                 ;;
 498 esac
 499
 500 dnl
 501 dnl End of "$Id: cups-compiler.m4 6976 2007-09-18 20:39:31Z mike $".
 502 dnl