1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
|
#-*- tab-width: 4; -*-
# ex:ts=4
#
# bsd.gcc.mk - Support for smarter USE_GCC usage.
#
# Created by: Edwin Groothuis <edwin@freebsd.org>
#
# To request the use of a current version of GCC, specify USE_GCC=yes in
# your port/system configuration. This is the preferred use of USE_GCC.
# It uses the canonical version of GCC defined in bsd.default-versions.mk.
#
# USE_GCC=any is similar, except that it also accepts the old GCC 4.2-
# based system compiler in older versions of FreeBSD.
#
# If your port needs a specific (minimum) version of GCC, you can easily
# specify that with a USE_GCC= statement. Unless absolutely necessary
# do so by specifying USE_GCC=X.Y+ which requests at least GCC version
# X.Y. To request a specific version omit the trailing + sign.
#
# Examples:
# USE_GCC= yes # port requires a current version of GCC
# # as defined in bsd.default-versions.mk.
# USE_GCC= any # port requires GCC 4.2 or later.
# USE_GCC= 4.8+ # port requires GCC 4.8 or later.
# USE_GCC= 4.8 # port requires GCC 4.8.
#
# If you are wondering what your port exactly does, use "make test-gcc"
# to see some debugging.
#
# $FreeBSD$
GCC_Include_MAINTAINER= gerald@FreeBSD.org
.include "${PORTSDIR}/Mk/bsd.default-versions.mk"
# All GCC versions supported by the ports framework. Keep them in
# ascending order and in sync with the table below.
GCCVERSIONS= 040200 040600 040700 040800 040900
# The first field if the OSVERSION in which it appeared in the base.
# The second field is the OSVERSION in which it disappeared from the base.
# The third field is the version as USE_GCC would use.
GCCVERSION_040200= 700042 9999999 4.2
GCCVERSION_040600= 0 0 4.6
GCCVERSION_040700= 0 0 4.7
GCCVERSION_040800= 0 0 4.8
GCCVERSION_040900= 0 0 4.9
GCC_DEFAULT_V= ${GCC_DEFAULT:S/.//}
# No configurable parts below this. ####################################
#
.if defined(USE_GCC) && ${USE_GCC} == yes
USE_GCC= ${GCC_DEFAULT}+
.endif
# Extract the fields from GCCVERSION_...
.for v in ${GCCVERSIONS}
. for j in ${GCCVERSION_${v}}
. if !defined(_GCCVERSION_${v}_L)
_GCCVERSION_${v}_L= ${j}
. elif !defined(_GCCVERSION_${v}_R)
_GCCVERSION_${v}_R= ${j}
. elif !defined(_GCCVERSION_${v}_V)
_GCCVERSION_${v}_V= ${j}
. endif
. endfor
.endfor
.if defined(USE_GCC) && !defined(FORCE_BASE_CC_FOR_TESTING)
. if ${USE_GCC} == any
# Enable the clang-is-cc workaround. Default to the last GCC imported
# into base.
_USE_GCC:= 4.2
_GCC_ORLATER:= true
. else # ${USE_GCC} == any
# See if we can use a later version or exclusively the one specified.
_USE_GCC:= ${USE_GCC:S/+//}
.if ${USE_GCC} != ${_USE_GCC}
_GCC_ORLATER:= true
.endif
. endif # ${USE_GCC} == any
# Initialize _GCC_FOUND${v}. In parallel, check if USE_GCC points to a
# valid version to begin with.
.for v in ${GCCVERSIONS}
. if exists(${LOCALBASE}/bin/gcc${_GCCVERSION_${v}_V:S/.//})
_GCC_FOUND${v}= port
. elif ${OSVERSION} >= ${_GCCVERSION_${v}_L} && ${OSVERSION} < ${_GCCVERSION_${v}_R}
. if exists(/usr/bin/gcc)
_GCC_FOUND${v}= base
. endif
. endif
. if ${_USE_GCC}==${_GCCVERSION_${v}_V}
_GCCVERSION_OKAY= true
. endif
.endfor
.if !defined(_GCCVERSION_OKAY)
IGNORE= Unknown version of GCC specified (USE_GCC=${USE_GCC})
.endif
# If the GCC package defined in USE_GCC does not exist, but a later
# version is allowed (for example 4.7+), see if there is a later.
# First check if the base installed version is good enough, otherwise
# get the first available version.
#
.if defined(_GCC_ORLATER)
. for v in ${GCCVERSIONS}
. if ${_USE_GCC} == ${_GCCVERSION_${v}_V}
_GCC_MIN1:= true
. endif
. if defined(_GCC_MIN1) && defined(_GCC_FOUND${v}) && ${_GCC_FOUND${v}}=="base" && !defined(_GCC_FOUND)
_GCC_FOUND:= ${_GCCVERSION_${v}_V}
. endif
. endfor
. for v in ${GCCVERSIONS}
. if ${_USE_GCC} == ${_GCCVERSION_${v}_V}
_GCC_MIN2:= true
. endif
. if defined(_GCC_MIN2) && defined(_GCC_FOUND${v}) && !defined(_GCC_FOUND)
_GCC_FOUND:= ${_GCCVERSION_${v}_V}
. endif
. endfor
. if defined(_GCC_FOUND)
_USE_GCC:= ${_GCC_FOUND}
. elif ${_USE_GCC} < ${GCC_DEFAULT}
_USE_GCC:= ${GCC_DEFAULT}
. endif
.endif # defined(_GCC_ORLATER)
.endif # defined(USE_GCC)
.if defined(_USE_GCC)
# A concrete version has been selected. Determine if the installed OS
# features this version in the base, and if not then set proper ports
# dependencies, CC, CXX, CPP, and flags.
.for v in ${GCCVERSIONS}
. if ${_USE_GCC} == ${_GCCVERSION_${v}_V}
. if ${OSVERSION} < ${_GCCVERSION_${v}_L} || ${OSVERSION} > ${_GCCVERSION_${v}_R} || !exists(/usr/bin/gcc)
V:= ${_GCCVERSION_${v}_V:S/.//}
_GCC_PORT_DEPENDS:= gcc${V}
. if ${_USE_GCC} == ${GCC_DEFAULT}
_GCC_PORT:= gcc
. else
_GCC_PORT:= gcc${V}
. endif
CC:= gcc${V}
CXX:= g++${V}
CPP:= cpp${V}
_GCC_RUNTIME:= ${LOCALBASE}/lib/gcc${V}
CFLAGS+= -Wl,-rpath=${_GCC_RUNTIME}
CXXFLAGS+= -Wl,-rpath=${_GCC_RUNTIME}
LDFLAGS+= -Wl,-rpath=${_GCC_RUNTIME} -L${_GCC_RUNTIME}
. else # Use GCC in base.
CC:= gcc
CXX:= g++
. if exists(/usr/bin/gcpp)
CPP:= gcpp
. else
CPP:= cpp
. endif
. endif # Use GCC in base.
. endif # ${_USE_GCC} == ${_GCCVERSION_${v}_V}
.endfor
.undef V
.if defined(_GCC_PORT_DEPENDS)
BUILD_DEPENDS+= ${_GCC_PORT_DEPENDS}:${PORTSDIR}/lang/${_GCC_PORT}
RUN_DEPENDS+= ${_GCC_PORT_DEPENDS}:${PORTSDIR}/lang/${_GCC_PORT}
# Later GCC ports already depend on binutils; make sure whatever we
# build leverages this as well.
USE_BINUTILS= yes
.endif
.endif # defined(_USE_GCC) && !defined(FORCE_BASE_CC_FOR_TESTING)
test-gcc:
@echo USE_GCC=${USE_GCC}
.if defined(IGNORE)
@echo "IGNORE: ${IGNORE}"
.else
.if defined(USE_GCC)
.if defined(_GCC_ORLATER)
@echo Port can use later versions.
.else
@echo Port cannot use later versions.
.endif
.for v in ${GCCVERSIONS}
@echo -n "GCC version: ${_GCCVERSION_${v}_V} "
.if defined(_GCC_FOUND${v})
@echo -n "(${_GCC_FOUND${v}}) "
.endif
@echo "- OSVERSION from ${_GCCVERSION_${v}_L} to ${_GCCVERSION_${v}_R}"
# @echo ${v} - ${_GCC_FOUND${v}} - ${_GCCVERSION_${v}_L} to ${_GCCVERSION_${v}_R} - ${_GCCVERSION_${v}_V}
.endfor
@echo Using GCC version ${_USE_GCC}
.endif
@echo CC=${CC} - CXX=${CXX} - CPP=${CPP} - CFLAGS=\"${CFLAGS}\"
@echo LDFLAGS=\"${LDFLAGS}\"
@echo "BUILD_DEPENDS=${BUILD_DEPENDS}"
@echo "RUN_DEPENDS=${RUN_DEPENDS}"
.endif
|
