3
# Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
5
# This program is free software; you can redistribute it and/or
6
# modify it under the terms of the GNU Library General Public
7
# License as published by the Free Software Foundation; version 2
10
# This program is distributed in the hope that it will be useful,
11
# but WITHOUT ANY WARRANTY; without even the implied warranty of
12
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13
# Library General Public License for more details.
15
# You should have received a copy of the GNU Library General Public
16
# License along with this library; if not, write to the Free
17
# Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
5
22
echo "ERROR: $@"; exit 1;
65
82
This script can be used to build MySQL Cluster Carrier Grade Edition
66
based on a source code release you received from MySQL.
83
based on a source code release you received from MySQL. It can also
84
be used to build many variants other variants of MySQL, in particular
85
various performance-optimised versions of MySQL.
68
87
It is assumed that you are building on a computer which is of the
69
same type as that on which you intend to run MySQL Cluster.
88
same type as that on which you intend to run MySQL/MySQL Cluster.
71
90
The simplest possible way to run this script is to allow it to use the
72
built-in defaults everywhere, invoking it simply as:
91
built-in defaults everywhere, invoking it simply as (from top-level
74
shell> ./build_mccge.sh
94
shell> BUILD/build_mccge.sh
76
96
This performs the following operations:
77
97
1) Detects the operating system. Currently, Linux, FreeBSD, Solaris
78
10/11, and Mac OS X are supported by this script.
98
8/9/10/11, and Mac OS X are supported by this script.
79
99
2) Detect the type of CPU being used. Currently supported processors
80
100
are: x86 for all supported operating systems, Itanium for Linux
81
with GCC, and SPARC for Solaris using the Forte compiler.
101
with GCC, and x86 + SPARC for Solaris using the Forte compiler and
102
finally x86 on Linux using the Intel compiler.
82
103
3) Invokes the GCC compiler.
83
4) Builds a set of MySQL Cluster Carrier Grade Edition binaries; for
104
4) Builds a set of MySQL/MySQL Cluster binaries; for
84
105
more information about these, see --extended-help.
106
5) Default compiler is always gcc.
86
108
The default version assumes that you have a source code tarball from
87
109
which you are building, and thus autoconf and automake do not need to
88
110
be run. If you have downloaded a BitKeeper tree then you should read
91
If you are building MySQL Cluster Carrier Grade Edition for commercial
113
If you are building MySQL/MySQL Cluster for commercial
92
114
use then you need to set the --commercial flag to ensure that the
93
115
commercial libraries are compiled in, rather than the GPL-only
94
116
libraries. The default is to build a GPL version of MySQL Cluster
95
117
Carrier Grade Edition.
97
If your building on a Solaris SPARC machine you must set
119
If your building on a Solaris SPARC machine and you want to compile
120
using SunStudio you must set
98
121
--compiler=forte; if you want to build using the Intel compiler on
99
122
Linux, you need to set --compiler=icc.
124
A synonym for forte is SunStudio, so one can also use
125
--compiler=SunStudio.
101
127
If you want to make sure that a 64-bit version is built then you
102
128
should add the flag --64. This is always set on Solaris machines and
103
129
when check-cpu is able to discover that a 64-bit CPU is being used. If
133
159
--help Show this help message.
134
160
--sysadmin-help Show help for system administrators wishing
135
161
to build MySQL Cluster Carrier Grade Edition
162
or other MySQL versions.
136
163
--developer-help Show help for developers trying to build MySQL
137
164
--with-help Show extended help on --with-xxx options to
139
166
--extended-help Show extended help message
140
167
--without-debug Build non-debug version
168
--use-comment Set the comment in the build
169
--with-fast-mutexes Use try/retry method of acquiring mutex
141
170
--with-debug Build debug version
142
171
--with-debug=full Build with full debug.
172
--with-link-time-optimizer
173
Link time optimizations enabled (Requires GCC 4.5
174
if GCC used), available for icc as well. This flag
175
is only considered if also fast is set.
143
176
--configure-only Stop after running configure.
144
177
--use-autotools Start by running autoconf, automake,.. tools
145
178
--no-autotools Start from configure
186
220
Extended help text for this script:
187
221
-----------------------------------
188
222
This script is intended to make it easier for customers using MySQL
189
Cluster Carrier Grade Edition to build the product from source on
190
these platforms/compilers: Linux/x86 (32-bit and 64-bit),
191
Solaris 10 and 11/x86/gcc, Solaris 9/Sparc/Forte, and MacOSX/x86/gcc.
192
The script automatically detects CPU type and operating system; in
193
most cases this also determines which compiler to use, the exception
194
being Linux/x86 where you can choose between gcc and icc (gcc is the
223
Cluster Carrier Grade Edition, customers using performance-optimised
224
MySQL versions and developers to build the product from source on
225
these platforms/compilers: Linux/x86 (32-bit and 64-bit) (either using
226
gcc or icc), Linux Itanium, Solaris 8,9,10 and 11 x86 and SPARC using
227
gcc or SunStudio and MacOSX/x86/gcc.
229
The script automatically detects CPU type and operating system; The
230
default compiler is always gcc.
197
232
To build on other platforms you can use the --print-only option on a
198
233
supported platform and edit the output for a proper set of commands on
365
401
--with-mysqld-libs=-lmtmalloc
366
402
Used on Solaris to ensure that the proper malloc library is used.
403
Investigations have shown mtmalloc to be the best choice on Solaris,
404
also umem has good performance on Solaris but better debugging
368
407
Compiler options:
369
408
-----------------
371
This section describes the compiler options for each of the different
372
platforms supported by thisscript.
374
The --fast option adds -mtune=cpu_arg to the C/C++ flags (provides
375
support for Nocona, K8, and other processors).
377
Use of the --debug option adds -g to the C/C++ flags.
410
This section describes the compiler options for each of the different
411
platforms supported by this script.
413
The --fast option adds -mtune=cpu_arg to the C/C++ flags (provides
414
support for Nocona, K8, and other processors).
416
Use of the --debug option adds -g to the C/C++ flags.
418
In all cases it is possible to override the definition of CC and CXX
419
by calling the script as follows:
420
CC="/usr/local/bin/gcc" CXX="/usr/local/bin/gcc" BUILD/build_mccge.sh
393
435
Linux/x86+Itanium/icc
396
CC = icc -static-libgcc -static-libcxa -i-static
397
C++ = icpc -static-libgcc -static-libcxa -i-static
438
CC = icc -static-libgcc -static-intel
439
C++ = icpc -static-libgcc -static-intel
398
440
C/C++ flags = -mp -restrict
400
On Itanium we also add -no-ftz and -no-prefetch to CC and C++ flags.
402
The non-debug versions also add the following:
403
C/C++ flags += -O3 unroll2 -ip
405
The fast version adds:
408
On discovery of a Core 2 Duo architecture while using icc, -xT is also
409
added to the C/C++ flags; this provides optimisations specific to Core
410
2 Duo. This is added only when the --fast flag is set.
442
On Itanium we also add -no-ftz and to CC and C++ flags.
444
Note that if the user of this script sets CC or CXX explicitly then
445
also -static-libgcc and -static-intel needs to be set in the CC and
448
The non-debug versions also add the following:
449
C/C++ flags += -O3 unroll2 -ip
451
The fast version adds (if --with-link-time-optimizer is used):
454
On discovery of a Core 2 Duo architecture while using icc, -xT is also
455
added to the C/C++ flags; this provides optimisations specific to Core
456
2 Duo. This is added only when the --fast flag is set.
414
All builds on Solaris are 64-bit, so -m64 is always used in the
415
C/C++ flags. LDFLAGS is set to -m64 -static-libgcc -O/-O2.
460
All builds on Solaris are by default 64-bit, so -m64 is always used in
461
the C/C++ flags. LDFLAGS is set to -m64 -O/-O2/-O3. If for
462
some reason a 32-bit Solaris is used it is necessary to add the flag
463
--32 to the script invocation. Due to bugs in compiling with -O3 on
464
Solaris only -O2 is used by default, when --fast flag is used -O3 will
467
Sets -m64 (default) or -m32 (if specifically set) in LDFLAGS and
417
470
Solaris/Sparc/Forte
418
471
-------------------
420
Sets ASFLAGS=LDFLAGS=xarch=v9, so that we compile Sparc v9 binaries
421
C flags = -Xa -strconst -xc99=none
472
Uses cc as CC and CC as CXX
473
Note that SunStudio uses different binaries for C and C++ compilers.
475
Set -m64 (default) or -m32 (if specifically set) in ASFLAGS,
476
LDFLAGS and C/C++ flags.
478
Sets ASFLAGS=LDFLAGS=compiler flags=xarch=sparc, so that we compile
479
Sparc v9 binaries, also -mt is set in all those since we're always
480
building a multithreaded program.
482
C flags = -xstrconst This flag is set only on SPARC
422
483
C++ flags = -noex
423
C/C++ flags = -mt -D_FORTEC -xarch=v9
425
For non-debug builds, the following flags are also used:
485
Set the following C/C++ flags:
488
-nofstore This flag is set only on x86
495
-features=no%except This flag is set only on x86
497
When compiling with fast we set (-ipo only used if we have
498
set --with-link-time-optimizer):
499
C/C++ flags: -xtarget=native -xunroll=3 -xipo
502
When not compiling with fast we always set -xtarget=generic
504
When compiling with fast on SPARC we also set:
505
C/C++ flags: -xbinopt=prepare
506
LDFLAGS: -xbinopt=prepare
508
When compiling with fast on x86 we also set:
509
C/C++ flags: -xregs=frameptr
510
When not compiling with fast we set on x86
511
C/C++ flags: -xregs=no%frameptr
514
ASFLAGS = LDFLAGS = C/C++ flags = -xarch=sparc
516
The optimisation level is
518
-xO2 Production build on SPARC
519
-xO3 Production build on x86
520
-xO4 Fast builds on SPARC/x86
431
C/C++ flags include -fno-common -arch i386.
524
C/C++ flags include -fno-common -arch i386.
525
When 64-bits builds then i386 is replaced by x86_64.
433
Non-debug versions also add -Os -felide-constructors, where "-Os"
434
means the build is space-optimised as long as the space optimisations
435
do not negatively affect performance. Debug versions use -O.
527
Non-debug versions also add -Os -felide-constructors, where "-Os"
528
means the build is space-optimised as long as the space optimisations
529
do not negatively affect performance. Debug versions use -O.
531
Mac OS X builds will always be 32-bit by default, when --64 is added
532
the build will be 64 bit instead. Thus the flag --m64 is added only
533
when specifically given as an option.
1061
1194
set_base_engines()
1063
engine_configs="$engine_configs --with-archive-storage-engine"
1196
engine_configs="--with-archive-storage-engine"
1064
1197
engine_configs="$engine_configs --with-blackhole-storage-engine"
1065
engine_configs="$engine_configs --with-example-storage-engine"
1198
engine_configs="$engine_configs --without-example-storage-engine"
1066
1199
engine_configs="$engine_configs --with-federated-storage-engine"
1067
1200
engine_configs="$engine_configs --with-partition"
1201
base_configs="$base_configs $engine_configs"
1206
base_configs="$base_configs --with-innodb"
1211
base_configs="$base_configs --with-ndbcluster"
1212
base_configs="$base_configs --without-ndb-debug"
1070
1215
set_pro_package()
1072
base_configs="$base_configs $engine_configs"
1073
base_configs="$base_configs --with-innodb"
1074
base_configs="$base_configs --with-comment=\"MySQL Pro $version_text built from source\""
1217
if test "x$without_comment" != "xyes" ; then
1218
base_configs="$base_configs --with-comment=\"MySQL Enterprise Pro $version_text built from source\""
1075
1220
if test "x$with_debug_flag" = "xyes" ; then
1076
1221
base_configs="$base_configs --with-server-suffix=\"-debug\""
1080
1225
set_cge_extended_package()
1082
if test "x$gpl" = "xno" ; then
1083
echo "Cannot build Extended Carrier Grade Edition as Commercial version"
1227
if test "x$without_comment" != "xyes" ; then
1228
base_configs="$base_configs --with-comment=\"MySQL Cluster Carrier Grade Extended Edition $version_text built from source\""
1085
base_configs="$base_configs --with-ndbcluster"
1086
base_configs="$base_configs --without-ndb-debug"
1087
base_configs="$base_configs $engine_configs"
1088
base_configs="$base_configs --with-innodb"
1089
base_configs="$base_configs --with-comment=\"MySQL Cluster Carrier Grade Extended Edition $version_text built from source\""
1090
1230
if test "x$with_debug_flag" = "xyes" ; then
1091
1231
base_configs="$base_configs --with-server-suffix=\"-cge-extended-debug\""
1093
base_configs="$base_configs --with-server-suffix=\"-cge-extended"\"
1233
base_configs="$base_configs --with-server-suffix=\"-cge-extended\""
1097
1237
set_cge_package()
1099
base_configs="$base_configs --with-ndbcluster"
1100
base_configs="$base_configs --without-ndb-debug"
1101
base_configs="$base_configs $engine_configs"
1102
base_configs="$base_configs --with-comment=\"MySQL Cluster Carrier Grade Edition $version_text built from source\""
1239
if test "x$without_comment" != "xyes" ; then
1240
base_configs="$base_configs --with-comment=\"MySQL Cluster Carrier Grade Edition $version_text built from source\""
1103
1242
if test "x$with_debug_flag" = "xyes" ; then
1104
1243
base_configs="$base_configs --with-server-suffix=\"-cge-debug\""
1106
base_configs="$base_configs --with-server-suffix=\"-cge"\"
1245
base_configs="$base_configs --with-server-suffix=\"-cge\""
1110
1249
set_classic_package()
1112
base_configs="$base_configs --with-comment=\"MySQL Classic $version_text built from source\""
1251
if test "x$without_comment" != "xyes" ; then
1252
base_configs="$base_configs --with-comment=\"MySQL Classic $version_text built from source\""
1113
1254
if test "x$with_debug_flag" = "xyes" ; then
1114
1255
base_configs="$base_configs --with-server-suffix=\"-debug\""
1257
base_configs="$base_configs --without-example-storage-engine"
1285
set_cc_and_cxx_for_gcc()
1287
if test "x$CC" = "x" ; then
1288
CC="gcc -static-libgcc -fno-exceptions"
1290
if test "x$CXX" = "x" ; then
1291
CXX="gcc -static-libgcc -fno-exceptions"
1295
set_cc_and_cxx_for_icc()
1297
if test "x$CC" = "x" ; then
1298
CC="icc -static-intel -static-libgcc"
1300
if test "x$CXX" = "x" ; then
1301
CXX="icpc -static-intel -static-libgcc"
1305
set_cc_and_cxx_for_forte()
1307
if test "x$CC" = "x" ; then
1310
if test "x$CXX" = "x" ; then
1144
1316
# If we discover a Core 2 Duo architecture and we have enabled the fast
1145
1317
# flag, we enable a compile especially optimised for Core 2 Duo. This
1169
1341
base_configs="$base_configs --enable-assembler"
1342
if test "x$fast_flag" != "xno" ; then
1343
compiler_flags="$compiler_flags -O3"
1345
compiler_flags="$compiler_flags -O0"
1347
set_cc_and_cxx_for_gcc
1352
echo "Checking for 32/64-bits compilation"
1353
echo "int main() { return 0; }" > temp_test.c
1354
if test "x$m64" = "xyes" ; then
1355
cmd="$CC $compile_flags -m64 temp_test.c"
1356
if ! $cmd 2>1 ; then
1358
echo "Changing to 32-bits since 64-bits didn't work"
1360
echo "Will use 64-bits"
1363
cmd="$CC $compile_flags -m32 temp_test.c"
1364
if ! $cmd 2>1 ; then
1366
echo "Changing to 64-bits since 32-bits didn't work"
1368
echo "Will use 32-bits"
1379
# check if compiler is gcc and dump its version
1380
cc_verno=`$cc -dumpversion 2>/dev/null`
1381
if test "x$?" = "x0" ; then
1382
set -- `echo $cc_verno | tr '.' ' '`
1387
gcc_version=`expr $cc_major '*' 100 '+' $cc_minor`
1392
# Link Time Optimizer in GCC (LTO) uses a parameter -flto
1393
# which was added to GCC 4.5, if --with-link-time-optimizer
1394
# is set then use this feature
1396
check_for_link_time_optimizer()
1399
if test "$gcc_version" -ge 405 && \
1400
test "x$with_link_time_optimizer" = "xyes" ; then
1401
compiler_flags="$compiler_flags -flto"
1402
LDFLAGS="$LDFLAGS -flto"
1175
1406
# Linux Section
1179
1410
if test "x$cpu_base_type" != "xx86" && \
1180
1411
test "x$cpu_base_type" != "xitanium" ; then
1181
usage "Only x86 and Itanium CPUs supported for 32-bit Linux"
1412
usage "Only x86 and Itanium CPUs supported for Linux"
1184
base_configs="$base_configs --with-fast-mutexes"
1415
if test "x$use_tcmalloc" = "xyes" ; then
1416
base_configs="$base_configs --with-mysqld-libs=-ltcmalloc_minimal"
1185
1418
if test "x$cpu_base_type" = "xx86" ; then
1186
1419
base_configs="$base_configs --enable-assembler"
1188
1421
if test "x$compiler" = "xgcc" ; then
1422
set_cc_and_cxx_for_gcc
1423
if test "x$fast_flag" != "xno" ; then
1424
if test "x$fast_flag" = "xyes" ; then
1425
compiler_flags="$compiler_flags -O3"
1426
check_for_link_time_optimizer
1428
compiler_flags="$compiler_flags -O2"
1431
compiler_flags="$compiler_flags -O0"
1191
1434
if test "x$m64" = "xyes" ; then
1192
1435
compiler_flags="$compiler_flags -m64"
1437
compiler_flags="$compiler_flags -m32"
1194
1439
# configure will set proper compiler flags for gcc on Linux
1195
1440
elif test "x$compiler" = "xicc" ; then
1196
1441
compiler_flags="$compiler_flags -mp -restrict"
1197
CC="icc -static-intel"
1198
CXX="icpc -static-intel"
1442
set_cc_and_cxx_for_icc
1199
1443
if test "x$cpu_base_type" = "xitanium" ; then
1200
1444
compiler_flags="$compiler_flags -no-ftz"
1202
1446
if test "x$fast_flag" != "xno" ; then
1203
1447
compiler_flags="$compiler_flags -O3 -unroll2 -ip"
1204
if test "x$fast_flag" = "xyes" ; then
1448
if test "x$fast_flag" = "xyes" && \
1449
test "x$with_link_time_optimizer" = "xyes" ; then
1205
1450
compiler_flags="$compiler_flags -ipo"
1451
LDFLAGS="$LDFLAGS -ipo"
1217
1463
set_solaris_configs()
1219
base_configs="$base_configs --with-mysqld-libs=-lmtmalloc"
1465
# Use mtmalloc as malloc, see Tim Cook blog
1466
# For information on optimal compiler settings, see article at
1467
# http://developers.sun.com/solaris/articles/mysql_perf_tune.html
1468
# by Luojia Chen at Sun.
1469
base_configs="$base_configs --with-named-curses=-lcurses"
1220
1470
case "`uname -a`" in
1475
base_configs="$base_configs --with-mysqld-libs=-lmtmalloc"
1224
die "Only versions 10 and 11 supported for Solaris"
1478
usage "Only versions 8,9, 10 and 11 supported for Solaris"
1226
1481
if test "x$cpu_base_type" != "xx86" && \
1227
1482
test "x$cpu_base_type" != "xsparc" ; then
1228
1483
usage "Only x86 and Sparc CPUs supported for Solaris"
1486
if test "x$compiler" != "xgcc" && \
1487
test "x$compiler" != "xforte" ; then
1488
usage "Only gcc and Forte compilers supported for Solaris"
1491
if test "x$m64" = "xyes" ; then
1492
compiler_flags="$compiler_flags -m64"
1494
ASFLAGS="$ASFLAGS -m64"
1496
compiler_flags="$compiler_flags -m32"
1498
ASFLAGS="$ASFLAGS -m32"
1231
1500
if test "x$compiler" = "xgcc" ; then
1501
set_cc_and_cxx_for_gcc
1234
1502
if test "x$cpu_base_type" != "xx86" ; then
1235
usage "Only gcc supported for Solaris 10/11 on SPARC"
1237
compiler_flags="$compiler_flags -m64 -DMY_ATOMIC_MODE_RWLOCKS"
1238
LDFLAGS="-m64 -static-libgcc"
1239
if test "x$fast_flag" != "xno" ; then
1240
LDFLAGS="$LDFLAGS -O2"
1241
compiler_flags="$compiler_flags -O2"
1243
LDFLAGS="$LDFLAGS -O"
1244
compiler_flags="$compiler_flags -O"
1246
elif test "x$compiler" = "xforte" ; then
1503
usage "gcc currently not supported for Solaris on SPARC"
1506
if test "x$fast_flag" = "xyes" ; then
1507
LDFLAGS="$LDFLAGS -O3"
1508
compiler_flags="$compiler_flags -O3"
1509
check_for_link_time_optimizer
1511
if test "x$fast_flag" = "xgeneric" ; then
1512
LDFLAGS="$LDFLAGS -O2"
1513
compiler_flags="$compiler_flags -O2"
1515
LDFLAGS="$LDFLAGS -O0"
1516
compiler_flags="$compiler_flags -O0"
1520
#Using Forte compiler (SunStudio)
1521
set_cc_and_cxx_for_forte
1522
compiler_flags="$compiler_flags -mt"
1523
LDFLAGS="$LDFLAGS -mt"
1524
compiler_flags="$compiler_flags -fsimple=1"
1525
compiler_flags="$compiler_flags -ftrap=%none"
1526
compiler_flags="$compiler_flags -xbuiltin=%all"
1527
compiler_flags="$compiler_flags -xlibmil"
1528
compiler_flags="$compiler_flags -xlibmopt"
1529
if test "x$fast_flag" = "xyes" ; then
1530
compiler_flags="$compiler_flags -xtarget=native"
1531
compiler_flags="$compiler_flags -xunroll=3"
1532
if test "x$with_link_time_optimizer" = "xyes" ; then
1533
compiler_flags="$compiler_flags -xipo"
1534
LDFLAGS="$LDFLAGS -xipo"
1537
compiler_flags="$compiler_flags -xtarget=generic"
1247
1539
if test "x$cpu_base_type" = "xx86" ; then
1248
usage "Only gcc supported for Solaris/x86"
1250
if test "x$cpu_base_type" != "xsparc" ; then
1251
usage "Forte compiler supported for Solaris 9/SPARC only"
1257
base_cflags="$base_cflags -Xa -xstrconst -xc99=none"
1258
base_cxxflags="$base_cxxflags -noex"
1259
compiler_flags="$compiler_flags -mt -D_FORTEC -xarch=v9"
1260
if test "x$fast_flag" != "xno" ; then
1261
compiler_flags="$compiler_flags -xO3"
1264
usage "Only gcc and Forte compilers supported for Solaris"
1540
compiler_flags="$compiler_flags -nofstore"
1541
base_cxx_flags="$base_cxx_flags -features=no%except"
1542
if test "x$fast_flag" = "xyes" ; then
1543
compiler_flags="$compiler_flags -xregs=frameptr"
1544
compiler_flags="$compiler_flags -xO4"
1546
compiler_flags="$compiler_flags -xregs=no%frameptr"
1547
if test "x$fast_flag" = "xgeneric" ; then
1548
compiler_flags="$compiler_flags -xO2"
1550
compiler_flags="$compiler_flags -xO0"
1554
#Using SPARC cpu with SunStudio (Forte) compiler
1555
ASFLAGS="$ASFLAGS -xarch=sparc"
1556
LDFLAGS="$LDFLAGS -xarch=sparc"
1557
base_cxxflags="$base_cxxflags -noex"
1558
base_cflags="$base_cflags -xstrconst"
1559
compiler_flags="$compiler_flags -xarch=sparc"
1560
if test "x$fast_flag" = "xyes" ; then
1561
compiler_flags="$compiler_flags -xbinopt=prepare"
1562
LDFLAGS="$LDFLAGS -xbinopt=prepare"
1563
compiler_flags="$compiler_flags -xO4"
1564
elif test "x$fast_flag" = "xgeneric" ; then
1565
compiler_flags="$compiler_flags -xO3"
1567
compiler_flags="$compiler_flags -xO0"
1282
1583
# Optimize for space as long as it doesn't affect performance, use some
1283
1584
# optimisations also when not in fast mode.
1586
base_cxxflags="$base_cxxflags -felide-constructors"
1587
compiler_flags="$compiler_flags -fno-common"
1588
if test "x$m64" = "xyes" ; then
1589
compiler_flags="$compiler_flags -m64"
1590
compiler_flags="$compiler_flags -arch x86_64"
1592
compiler_flags="$compiler_flags -m32"
1593
compiler_flags="$compiler_flags -arch i386"
1285
1595
if test "x$fast_flag" != "xno" ; then
1286
1596
compiler_flags="$compiler_flags -Os"
1287
base_cxxflags="$base_cxxflags -felide-constructors"
1289
compiler_flags="$compiler_flags -O"
1598
compiler_flags="$compiler_flags -O0"
1600
set_cc_and_cxx_for_gcc
added
removed
BUILD/build_mccge.sh
