Index: head/Mk/bsd.gcc.mk
===================================================================
--- head/Mk/bsd.gcc.mk	(revision 488672)
+++ head/Mk/bsd.gcc.mk	(revision 488673)
@@ -1,210 +1,217 @@
 #-*- 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+ which requests at least GCC version X.
 # 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=	7+			# port requires GCC 7 or later.
 #   USE_GCC=	5			# port requires GCC 5.
 #
 # If you are wondering what your port exactly does, use "make test-gcc"
 # to see some debugging.
 #
 # $FreeBSD$
 
 GCC_Include_MAINTAINER=		gerald@FreeBSD.org
 
 # All GCC versions supported by the ports framework.  Keep them in
 # ascending order and in sync with the table below. 
 # When adding a version, please keep the comment in
 # Mk/bsd.default-versions.mk in sync.
 GCCVERSIONS=	040200 040800 040900 050000 060000 070000 080000
 
 # The first field is the OSVERSION in which it disappeared from the base.
 # The second field is the version as USE_GCC would use.
 GCCVERSION_040200=	9999999 4.2
 GCCVERSION_040800=	      0 4.8
 GCCVERSION_040900=	      0 4.9
 GCCVERSION_050000=	      0 5
 GCCVERSION_060000=	      0 6
 GCCVERSION_070000=	      0 7
 GCCVERSION_080000=	      0 8
 
 # 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}_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}_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}_R} || !exists(/usr/bin/gcc)
 V:=			${_GCCVERSION_${v}_V:S/.//}
 _GCC_PORT_DEPENDS:=	gcc${V}
 _GCC_PORT:=		gcc${V}
 CC:=			gcc${V}
 CXX:=			g++${V}
 CPP:=			cpp${V}
 _GCC_RUNTIME:=		${LOCALBASE}/lib/gcc${V}
+.   if ${PORTNAME} == gcc
+# We don't want the rpath stuff while building GCC itself
+# so we do not set the FLAGS as done in the else part.
+# When building a GCC, we want the target libraries to be used and not the
+# host GCC libraries.
+.   else
 CFLAGS+=		-Wl,-rpath=${_GCC_RUNTIME}
 CXXFLAGS+=		-Wl,-rpath=${_GCC_RUNTIME}
 LDFLAGS+=		-Wl,-rpath=${_GCC_RUNTIME} -L${_GCC_RUNTIME}
+.   endif
 .  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
 
 # Now filter unsupported flags for CC and CXX.
 CFLAGS:=		${CFLAGS:N-mretpoline}
 CXXFLAGS:=		${CXXFLAGS:N-mretpoline}
 
 .if defined(_GCC_PORT_DEPENDS)
 BUILD_DEPENDS+=	${_GCC_PORT_DEPENDS}:lang/${_GCC_PORT}
 RUN_DEPENDS+=	${_GCC_PORT_DEPENDS}: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 up to ${_GCCVERSION_${v}_R}"
 #	@echo ${v} - ${_GCC_FOUND${v}} - up to ${_GCCVERSION_${v}_R} - ${_GCCVERSION_${v}_V}
 .endfor
 	@echo Using GCC version ${_USE_GCC}
 .endif
 	@echo CC=${CC} - CXX=${CXX} - CPP=${CPP}
 	@echo CFLAGS=\"${CFLAGS}\"
 	@echo CXXFLAGS=\"${CXXFLAGS}\"
 	@echo LDFLAGS=\"${LDFLAGS}\"
 	@echo "BUILD_DEPENDS=${BUILD_DEPENDS}"
 	@echo "RUN_DEPENDS=${RUN_DEPENDS}"
 .endif
Index: head/lang/gcc7/Makefile
===================================================================
--- head/lang/gcc7/Makefile	(revision 488672)
+++ head/lang/gcc7/Makefile	(revision 488673)
@@ -1,148 +1,155 @@
 # Created by: Gerald Pfeifer <gerald@FreeBSD.org>
 # $FreeBSD$
 
 PORTNAME=	gcc
 PORTVERSION=	7.4.0
 PORTREVISION=	1
 CATEGORIES=	lang
 MASTER_SITES=	GCC
 PKGNAMESUFFIX=	${SUFFIX}
 
 MAINTAINER=	gerald@FreeBSD.org
 COMMENT=	GNU Compiler Collection 7
 
 LICENSE=	GPLv3 GPLv3RLE
 LICENSE_COMB=	multi
 
 ONLY_FOR_ARCHS=	aarch64 amd64 arm armv6 armv7 i386 powerpc powerpc64 powerpcspe sparc64
 
 LIB_DEPENDS=	libgmp.so:math/gmp \
 		libmpfr.so:math/mpfr \
 		libmpc.so:math/mpc
 BUILD_DEPENDS+=	${LOCALBASE}/bin/as:devel/binutils
 RUN_DEPENDS+=	${LOCALBASE}/bin/as:devel/binutils
 .if defined(MAINTAINER_MODE)
 BUILD_DEPENDS+=	runtest:misc/dejagnu
 .endif
 
 USES=		compiler cpe gmake iconv libtool makeinfo perl5 tar:xz
 USE_BINUTILS=	yes
 USE_PERL5=	build
 
 CONFLICTS=	gcc7-devel-7.*
 
 CPE_VENDOR=	gnu
 
 GCC_VERSION=	${PORTVERSION}
 SUFFIX=		${PORTVERSION:C/([0-9]+).*/\1/}
 SSP_UNSAFE=	yes
 CFLAGS:=	${CFLAGS:N-mretpoline}
 CXXFLAGS:=	${CXXFLAGS:N-mretpoline}
 
 OPTIONS_DEFINE=		BOOTSTRAP GRAPHITE
 OPTIONS_DEFAULT=	BOOTSTRAP
 BOOTSTRAP_DESC=		Build using a full bootstrap
 GRAPHITE_DESC=		Support for Graphite loop optimizations
 
 .if exists(/usr/lib32/libc.so)
 OPTIONS_DEFINE_powerpc64+=	MULTILIB
 OPTIONS_DEFAULT_powerpc64+=	MULTILIB
 MULTILIB_DESC=		Build support for 32-bit and 64-bit targets
 MULTILIB_CONFIGURE_ENABLE=	multilib
 .else
 CONFIGURE_ARGS+=	--disable-multilib
 .endif
 
 .include <bsd.port.pre.mk>
 
 .if ${ARCH} == amd64
 CONFIGURE_TARGET=	x86_64-portbld-${OPSYS:tl}${OSREL}
 
 .elif ${ARCH} == powerpc64
 CONFIGURE_ENV+=	UNAME_m="powerpc64"
 USE_GCC=	5	# This port requires at least GCC 4.9, and we need
 			# to ensure not to cause a dependency on itself (so
 			# USE_GCC=yes or USE_GCC=X+ are not an option).
 
 .elif ${ARCH} == powerpcspe
 CONFIGURE_ARGS+=	--with-cpu=8540 --enable-e500_double --without-fp
 .endif
 
 LANGUAGES:=	c,c++,objc,fortran
 TARGLIB=	${PREFIX}/lib/gcc${SUFFIX}
+TARGLIB32=	${PREFIX}/lib32	# The version information is added later
 LIBEXEC=	${PREFIX}/libexec/gcc${SUFFIX}
 GNU_CONFIGURE=	yes
 CONFIGURE_OUTSOURCE=	yes
 .if empty(PORT_OPTIONS:MBOOTSTRAP)
 CONFIGURE_ARGS+=--disable-bootstrap
 .else
 CONFIGURE_ARGS+=--with-build-config=bootstrap-debug
 ALL_TARGET=	bootstrap-lean
 .endif
 INSTALL_TARGET=	install-strip
 .if ${UID} != 0
 BINMODE=	755
 .endif
 CONFIGURE_ARGS+=--disable-nls \
 		--enable-gnu-indirect-function \
 		--libdir=${TARGLIB} \
 		--libexecdir=${LIBEXEC} \
 		--program-suffix=${SUFFIX} \
 		--with-as=${LOCALBASE}/bin/as \
 		--with-gmp=${LOCALBASE} \
 		--with-gxx-include-dir=${TARGLIB}/include/c++/ \
 		--with-ld=${LOCALBASE}/bin/ld \
 		${ICONV_CONFIGURE_ARG} \
 		--with-pkgversion="FreeBSD Ports Collection" \
 		--with-system-zlib
 MAKE_ARGS+=	MAKEINFOFLAGS="--no-split"
 USE_LDCONFIG=	${TARGLIB}
 PLIST_SUB+=	GCC_VERSION=${GCC_VERSION} \
 		GNU_HOST=${CONFIGURE_TARGET} \
 		SUFFIX=${SUFFIX}
 INFO=		gcc${SUFFIX}/cpp \
 		gcc${SUFFIX}/cppinternals \
 		gcc${SUFFIX}/gcc \
 		gcc${SUFFIX}/gccinstall \
 		gcc${SUFFIX}/gccint \
 		gcc${SUFFIX}/gfortran \
 		gcc${SUFFIX}/libgomp
 # Release tarballs (as opposed to snapshots) always carry this.
 INFO+=		gcc${SUFFIX}/libquadmath \
 		gcc${SUFFIX}/libitm
 SUB_FILES=	pkg-message
 SUB_LIST+=	TARGLIB=${TARGLIB}
 
 .if ${PORT_OPTIONS:MGRAPHITE}
 LIB_DEPENDS+=	libisl.so:devel/isl
 CONFIGURE_ARGS+=--with-isl=${LOCALBASE}
 .endif
 
 CONFIGURE_ARGS+=--enable-languages=${LANGUAGES}
 
 pre-everything::
 	@${ECHO_MSG} "Making GCC ${PORTVERSION} for ${CONFIGURE_TARGET} [${LANGUAGES}]"
 
 pre-configure:
 	cd ${WRKSRC} ; contrib/gcc_update --touch
 	@${RM} ${WRKSRC}/gcc/*/*.info*
 
 .if defined(MAINTAINER_MODE)
 full-regression-test: build
 	cd ${TEST_WRKSRC}; ${MAKE_CMD} -sk check \
 	; ${WRKSRC}/contrib/test_summary
 .endif
 
 post-stage:
 	${RM} ${STAGEDIR}${PREFIX}/man/man7/*
 	${RM} -r ${STAGEDIR}${TARGLIB}/gcc/*/${GCC_VERSION}/include-fixed/
 	# Add target libraries and include files to packaging list.
 	${RM} ${WRKDIR}/PLIST.lib
-.for d in ${TARGLIB:S/^${PREFIX}\///} ${LIBEXEC:S/^${PREFIX}\///}
+
+.if ${ARCH} == powerpc64 && ${PORT_OPTIONS:MMULTILIB}
+	${MKDIR} ${STAGEDIR}${TARGLIB32}/gcc${SUFFIX}
+	${MV} ${STAGEDIR}${PREFIX}/lib/lib32/* ${STAGEDIR}${TARGLIB32}/gcc${SUFFIX}
+.endif
+
+.for d in ${TARGLIB:S/^${PREFIX}\///} ${TARGLIB32:S/^${PREFIX}\///} ${LIBEXEC:S/^${PREFIX}\///}
 	cd ${STAGEDIR}${PREFIX} ; if [ -d $d ]; then \
 	    ${FIND} $d -type f -o -type l >>${WRKDIR}/PLIST.lib ;\
 	fi
 .endfor
 	cd ${WRKDIR} ; ${SED} -i -e "/PLIST.lib/ r PLIST.lib" ${TMPPLIST}
 
 .include <bsd.port.post.mk>