#

# CDDL HEADER START

#

# The contents of this file are subject to the terms of the

# Common Development and Distribution License (the "License").

# You may not use this file except in compliance with the License.

#

# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

# or http://www.opensolaris.org/os/licensing.

# See the License for the specific language governing permissions

# and limitations under the License.

#

# When distributing Covered Code, include this CDDL HEADER in each

# file and include the License file at usr/src/OPENSOLARIS.LICENSE.

# If applicable, add the following below this CDDL HEADER, with the

# fields enclosed by brackets "[]" replaced with your own identifying

# information: Portions Copyright [yyyy] [name of copyright owner]

#

# CDDL HEADER END

#

#

# Copyright (c) 2014, 2016, Oracle and/or its affiliates. All rights reserved.

#

BUILD_BITS= 64

COMPILER= gcc

# The golang build process just doesn't work with Parfait.

export PARFAIT_BUILD=no

include ../../make-rules/shared-macros.mk

PATCH_EACH_ARCHIVE= 1

COMPONENT_NAME=		golang

COMPONENT_MAJOR_VERSION=	$(shell echo $(COMPONENT_VERSION) | $(GSED) -e 's/\([0-9]\+\.[0-9]\+\).*/\1/')

COMPONENT_PROJECT_URL=	https://golang.org/

COMPONENT_ARCHIVE=	go$(COMPONENT_VERSION).src.tar.gz

COMPONENT_ARCHIVE_URL=	https://storage.googleapis.com/golang/$(COMPONENT_ARCHIVE)

COMPONENT_ARCHIVE_HASH=	 \

COMPONENT_PROJECT_URL=	https://golang.org

# Go has a number of supplementary tools and packages that are located in

# separate archives or source repositories. Because Go currently forces a

# recompile of all packages whenever the compiler changes, building and

# delivering them within the same build component build process is the best

# option for now.

# Supplementary packages; these are delivered as source only for now as the

# paths to the compiled packages are written directly into the binaries and

# there's no way (currently) to fix that during the build process.

SUPP_PACKAGES=		crypto image lint net sys text tools tour

define supp-rules

COMPONENT_NAME_$(1)=		$(1)

COMPONENT_VERSION_$(1)=		$(COMPONENT_VERSION)

COMPONENT_LABEL_$(1)=

COMPONENT_IMPORT_SRC_$(1)=	golang.org/x

GIT_REPO_$(1)=			https://github.com/golang/$(1).git

TPNO_$(1)=			$(TPNO)

endef

$(foreach suffix, $(SUPP_PACKAGES), $(eval $(call supp-rules,$(suffix))))

# Desired "revision" of Go's "community" libraries; these are arbitrary

# revisions chosen from the last commit to the respective repository at the

# same time that this component was updated as there is no formal release

# process for these packages.  Whenever Go is updated, these should be as well.

# Resulting hash of related git commit once archived.

# Go package imports for lint are found in github directory.

COMPONENT_IMPORT_SRC_lint=	github.com/golang

# Go's "not well-formed" elf objects confuse elfsign, which then causes

# problems for RE.  For now, we workaround this by adding the

# 'com.oracle.elfsign=false' tag to every elf object.

NO_ELFSIGN_MOG=		$(BUILD_DIR)/no-elfsign.mog

PUBLISH_STAMP= $(NO_ELFSIGN_MOG) $(BUILD_DIR)/.published-$(MACH)

# Bake in where Go package will be installed.

GOROOT_FINAL=		/usr/lib/golang/$(COMPONENT_MAJOR_VERSION)

# Enable easier stack unwinding for debugging.

GOEXPERIMENT=		framepointer

COMPONENT_BUILD_ENV +=	GOROOT_FINAL="$(GOROOT_FINAL)"

COMPONENT_BUILD_ENV +=	GOEXPERIMENT="$(GOEXPERIMENT)"

COMPONENT_BUILD_ENV +=	\

# Install root for supplementary packages.

SUPP_ROOT=$(PROTOUSRLIBDIR)/gocode/$(COMPONENT_MAJOR_VERSION)

# For convenience during installation of supplementary packages.

COMPONENT_INSTALL_ENV += PATH="$(PROTO_DIR)$(GOROOT_FINAL)/bin:$(PATH)"

COMPONENT_INSTALL_ENV += GOROOT="$(PROTO_DIR)$(GOROOT_FINAL)"

COMPONENT_INSTALL_ENV += GOPATH="$(SUPP_ROOT)"

BUILD_STYLE= justmake

BUILD_64 += $(BUILD_DIR)/man1/go.1

INSTALL_64 := build $(INSTALL_64)

include $(WS_MAKE_RULES)/common.mk

# Simplify source copying for install by eliding patch detritus.

GPATCH_BACKUP=

# Enable local transforms.

PKG_OPTIONS += -I $(COMPONENT_DIR)

# Avoid some of the default transforms:

# - facet.devel serves no useful purpose for a development package

# - facet.doc wrongly assumes all things in a doc directory are documentation;

#   in Go's case, some are binaries

#

# This requires completely redefining PUBLISH_TRANSFORMS for now.

PUBLISH_TRANSFORMS=	$(LICENSE_TRANSFORMS)

PUBLISH_TRANSFORMS +=	$(WS_TOP)/transforms/variant-cleanup

PUBLISH_TRANSFORMS +=	$(WS_TOP)/transforms/defaults

PUBLISH_TRANSFORMS +=	$(WS_TOP)/transforms/actuators

PUBLISH_TRANSFORMS +=	$(WS_TOP)/transforms/locale

PUBLISH_TRANSFORMS +=	$(PKGMOGRIFY_TRANSFORMS)

PUBLISH_TRANSFORMS +=	$(WS_TOP)/transforms/incorporate

PUBLISH_TRANSFORMS +=	$(WS_TOP)/transforms/publish-cleanup

ifeq ($(BUILD_TYPE),evaluation)

	PUBLISH_TRANSFORMS += $(WS_TOP)/transforms/evaluation

endif

$(NO_ELFSIGN_MOG): install

	cd $(PROTO_DIR); \

	find . -type f -exec elffile {} + | grep 'ELF [36]' | \

	    $(GSED) -e 's/^..\(.*\):.*$$/<transform file path=\1$$ -> \\\

	        default com.oracle.elfsign false>/' > $@

PUBLISH_TRANSFORMS +=	$(NO_ELFSIGN_MOG)

# Building go from the source repository version requires that we set an

# effective version and add some sort of unique identifier (in the case of

# pre-release versions), so we use 'devel' + archive hash + date similar to how

# We have to fiddle with the package archives to get them into the same source

# directory so that we can use the standard build targets.  We're effectively

# building multiple components using a single target.

COMPONENT_POST_UNPACK_ACTION= \

# Go doesn't have a standard Makefile-based build process, so override the

# default.

COMPONENT_BUILD_ACTION=	\

	cd $(@D)/src; $(ENV) $(COMPONENT_BUILD_ENV) ./make.bash

COMPONENT_TARGET_DIR= \

	$(PROTOUSRLIBDIR)/$(COMPONENT_NAME)/$(COMPONENT_MAJOR_VERSION)

# We can't do any ASLR'ing as the Go 6l linker has no understanding of the

# -z aslr=... option. So just override where needed in the .p5m files.

ASLR_MODE = $(ASLR_DISABLE)

# The timestamp is generated immediately once when the Makefile is evaluated to

# ensure every package gets the same one.

GOTS := $(shell date +"%Y%m%dT%H%M%SZ")

# Make sure the source code and object files have identical timestamps so

# the Go compiler doesn't try to rebuild them.

PKG_MACROS += TIMESTAMP=$(GOTS)

# Extra macros for packaging convenience.

PKG_MACROS += COMPONENT_MAJOR_VERSION=$(COMPONENT_MAJOR_VERSION)

# COMPONENT_MAJOR_VERSION suitable for use in regular expressions.

PKG_MACROS += COMPONENT_RE_MAJOR_VERSION=$(subst .,\\.,$(COMPONENT_MAJOR_VERSION))

COMPONENT_TEST_ENV +=	PATH="$(@D)/bin:$(PATH)"

COMPONENT_TEST_ENV +=	GOROOT="$(@D)"

COMPONENT_TEST_DIR=	$(@D)/src

COMPONENT_TEST_CMD=	./run.bash

COMPONENT_TEST_TARGETS=

# Go's test suite does not have deterministic output or order, and as such,

# success can only be determined by exit code, not by output comparison.

COMPONENT_TEST_CREATE_TRANSFORMS=

COMPONENT_TEST_PERFORM_TRANSFORM=

COMPONENT_TEST_COMPARE=

XML2ROFF= $(USRSHAREDIR)/xml/xsolbook/python/xml2roff.py

$(BUILD_DIR)/man1/go.1:

	$(XML2ROFF) $(COMPONENT_DIR)/docs/go.1 -o $(BUILD_DIR)

define COMPONENT_INSTALL_ACTION=

	($(MKDIR) $(COMPONENT_TARGET_DIR)/src); \

	(cd $(SOURCE_DIR) && \

	$(GNUBIN)/find . -maxdepth 1 -print \

	  -exec $(GNUBIN)/cp -r \

	  --parents {} $(COMPONENT_TARGET_DIR) \;); \

	(cd $(BUILD_DIR_64) && \

	$(GNUBIN)/find src -type f \

		-exec $(GNUBIN)/cp --parents {} $(COMPONENT_TARGET_DIR) \;); \

	(cd $(BUILD_DIR_64) && $(CP) -r bin $(COMPONENT_TARGET_DIR)/); \

	(cd $(BUILD_DIR_64) && $(CP) -r pkg $(COMPONENT_TARGET_DIR)/); \

	($(RM) $(NO_ELFSIGN_MOG))

endef

# clear COMPONENT_POST_INSTALL_ACTION so we can append PERL_SCRIPTS_PROCESS

# at the end

COMPONENT_POST_INSTALL_ACTION =

#

# Magic to deliver supplemental package source into proto area.

#

define install-rules

BUILD_64 += $$(UNPACK_STAMP_$(1))

COMPONENT_POST_INSTALL_ACTION += \

	($(MKDIR) \

		$(SUPP_ROOT)/src/$$(COMPONENT_IMPORT_SRC_$(1))/$$(COMPONENT_NAME_$(1)); \

	$(CP) -r $$(COMPONENT_SRC_$(1))/* \

		$(SUPP_ROOT)/src/$$(COMPONENT_IMPORT_SRC_$(1))/$$(COMPONENT_NAME_$(1)));

endef

$(foreach suffix,$(SUPP_PACKAGES), $(eval $(call install-rules,$(suffix))))

# Install supplementary packages (this cannot be done one-by-one); install

# tools/go/types first to avoid quirk with trimpath and dependencies.  This is

# technically a build and install, but go's build command won't "install"

# results, it only verifies a target can be built and dumps it into a temporary

# directory.

#

# The -trimpath option used here ensures that the paths recorded in the

# pre-built packages do not contain the containing directory; the result is a

# path that Go will evaluate relative to $GOPATH and so will pass the "stale"

# object checks that Go performs at build time allowing reuse of the pre-built

# packages.

PROTO_ROOT= $(SUPP_ROOT)

COMPONENT_POST_INSTALL_ACTION += \

	($(ENV) $(COMPONENT_INSTALL_ENV) go install \

		-asmflags -trimpath=$(PROTO_ROOT) -gcflags -trimpath=$(PROTO_ROOT) \

		"golang.org/x/tools/go/types"; \

	$(ENV) $(COMPONENT_INSTALL_ENV) go install \

		-asmflags -trimpath=$(PROTO_ROOT) -gcflags -trimpath=$(PROTO_ROOT) \

		"golang.org/x/..."; \

	$(ENV) $(COMPONENT_INSTALL_ENV) go install \

		-asmflags -trimpath=$(PROTO_ROOT) -gcflags -trimpath=$(PROTO_ROOT) \

		"github.com/golang/...");

PERL_SCRIPTS= \

COMPONENT_POST_INSTALL_ACTION += $(PERL_SCRIPTS_PROCESS)

# Go's test suite is currently designed to be run from the build area.

# Used during the build.

REQUIRED_PACKAGES += developer/gcc

ifneq ($(MACH), sparc)

endif

# Used in this Makefile.

REQUIRED_PACKAGES += file/gnu-findutils

REQUIRED_PACKAGES += text/gnu-sed

# Required to build man pages.

REQUIRED_PACKAGES += developer/documentation-tool/xml2roff

# There's a single test script which requires perl.

REQUIRED_PACKAGES += $(PERL_PKG)

REQUIRED_PACKAGES += system/header

REQUIRED_PACKAGES += system/library

# Used for cgo support at runtime; we don't add a package dependency since cgo

# support is optional.

REQUIRED_PACKAGES += system/library/gcc/gcc-c-runtime

REQUIRED_PACKAGES += system/linker