blob: 26e32b6bebb5d936271eaf5aba796c2d25452bc3 [file] [log] [blame]
# Building libgo is time-consuming. Allow developers to stub it out
# via cmake flag if desired.
if(DISABLE_LIBGO_BUILD)
return()
endif()
message(STATUS "starting libgo configuration.")
include(GoVars)
include(AutoGenGo)
include(ConfigSetup)
include(GenDeps)
include(GoPackage)
include(StructConfigUtils)
include(LibbacktraceUtils)
include(LibffiUtils)
# Root of libgo sources.
set(libgo_srcroot "${GOLLVM_SOURCE_DIR}/gofrontend/libgo")
# Directory from which we're going to pull libgo Go source code.
set(libgo_gosrcroot "${libgo_srcroot}/go")
# Directory from which we're going to pull libgo C source code.
set(libgo_csrcroot "${libgo_srcroot}")
# Directory from which we're going to pull libgo helper scripts (ex: match.sh)
set(libgo_scriptroot ${libgo_srcroot})
# Libbacktrace source code.
set(libbacktrace_srcroot "${CMAKE_CURRENT_SOURCE_DIR}/libbacktrace")
# Libffi source code.
set(libffi_srcroot "${CMAKE_CURRENT_SOURCE_DIR}/libffi")
# Binary root (top level of libgo build).
set(libgo_binroot "${CMAKE_CURRENT_BINARY_DIR}")
#........................................................................
#
# Call a helper to set up libbacktrace. This also creates the libbacktrace
# targets (libbacktrace_nonpiclib, libbacktrace_piclib).
setup_libbacktrace()
# Call a helper to set up libffi. This also creates the libffi
# targets (libffi_nonpiclib, libffi_piclib).
setup_libffi(${libffi_srcroot})
# Base set of defines for building C code
set(basedefines "-D_GNU_SOURCE" "-D_LARGEFILE_SOURCE" "-D_FILE_OFFSET_BITS=64")
# Set up various config.h files. Copy the LLVM-generated config.h and
# related files (the libgo config.h will include the llvm config.h).
file(MAKE_DIRECTORY "${libgo_binroot}/llvm/Config")
set(llvmconfigdir "${LLVM_BINARY_DIR}/include/llvm/Config")
file(COPY "${llvmconfigdir}/config.h" DESTINATION "llvm/Config")
file(COPY "${llvmconfigdir}/llvm-config.h" DESTINATION "llvm/Config")
# Generate config.h, included by various C files in libgo/go/runtime
# and also used to emit gen-sysinfo.go.
file(MAKE_DIRECTORY "${libgo_binroot}/runtime")
set(runtimeconfigdoth ${libgo_binroot}/runtime/config.h)
configure_file(
${CMAKE_CURRENT_SOURCE_DIR}/config.h.cmake
${runtimeconfigdoth})
# Subdirectory for godumpspec tool.
add_subdirectory(godumpspec)
#......................................................................
# Driver for compiling *.go files.
get_target_property(driverdir llvm-goc RUNTIME_OUTPUT_DIRECTORY)
set(gollvm_driver "${driverdir}/llvm-goc")
set(gocompiler ${gollvm_driver})
# Pick up any extra Go compiler flags specified via
# "cmake -DGOLLVM_EXTRA_GOCFLAGS=..."
set(tmp_libgo_extra_gocflags ${GOLLVM_EXTRA_GOCFLAGS})
if(GOLLVM_EXTRA_GOCFLAGS)
string(REPLACE " " ";" libgo_extra_gocflags ${tmp_libgo_extra_gocflags})
endif()
if(NOT GOLLVM_USE_SPLIT_STACK)
list(APPEND libgo_extra_gocflags "-fno-split-stack")
endif()
# Read in list of all libgo packages
file(STRINGS "${libgo_srcroot}/libgo-packages.txt" libpackages)
file(STRINGS "${libgo_srcroot}/gotool-packages.txt" toolpackages)
list(APPEND allpackages ${libpackages})
list(APPEND allpackages ${toolpackages})
# Script used to collect the Go source files that make up a package.
set(matchdotsh "${libgo_scriptroot}/match.sh")
# Set <pkg>_matchargs for packages that need additional match.sh args.
set(runtime_matchargs "--tag=libffi")
# Certain packages need extra Go source files. The convention here is
# that <pkg>_extra_go_files holds the additional sources for <pkg>.
set(runtime_extra_go_files "runtime_linknames.go" "runtime_sysinfo.go" "sigtab.go")
set(cmd_internal_objabi_extra_go_files "objabi.go")
set(internal_goroot_extra_go_files "zstdpkglist.go")
set(internal_cpu_extra_go_files "cpugen.go")
set(golang_org_x_sys_cpu_extra_go_files "gcpugen.go")
set(cmd_go_internal_cfg_extra_go_files "zdefaultcc.go")
set(runtime_internal_sys_extra_go_files "version.go")
set(go_types_extra_go_files "gccgosizes.go")
set(syscall_extra_go_files "libcalls.go" "sysinfo.go" "syscall_arch.go" "syscall_linknames.go")
set(os_extra_go_files "os_linknames.go")
set(os_user_extra_go_files "os_user_linknames.go")
if(${goos} STREQUAL "linux")
list(APPEND syscall_extra_go_files "epoll.go")
endif()
# Collect the source files in each package, write to temp file.
foreach( pack ${allpackages})
# The package directory should exist-- issue an error if it does not.
if(NOT EXISTS ${libgo_gosrcroot}/${pack})
message(SEND_ERROR "Package directory ${pack} does not exist.")
else()
string(REPLACE "/" "_" ptarget2 "${pack}")
string(REPLACE "." "_" ptarget "${ptarget2}")
set(packfilestmp "${libgo_binroot}/${ptarget}.gofiles")
# Package-specific match args
set(margs "${${ptarget}_matchargs}")
# Invoke match.sh to collect Go files of interest for this
# package, via shell script.
execute_process(COMMAND "${shell}" "${matchdotsh}" ${margs}
"--goarch=${goarch}" "--goos=${goos}"
"--srcdir=${libgo_gosrcroot}/${pack}"
OUTPUT_VARIABLE packfiles)
string(STRIP ${packfiles} packfiles)
# Incorporate any extra source files. These generated files are
# expected to appear in the root of the bin dir.
set(extrasrcs "${${ptarget}_extra_go_files}")
foreach( esrc ${extrasrcs})
string(STRIP ${esrc} esrcf)
string(APPEND packfiles " ${libgo_binroot}/${esrcf}")
endforeach()
file(WRITE ${packfilestmp} "${packfiles}\n")
endif()
endforeach()
#........................................................................
# This macro determines the final set of Go source files and Go compiler
# flags for a given package. Outputs are returned in the following
# variables:
#
# basepacksrcs Base Go source files (no autogenfiles)
# packsrcs All Go source files (including autogenfiles)
# packopts GOCFLAGS to use when building package
#
macro(collect_package_inputs pack)
set(basepacksrcs)
set(packsrcs)
set(packopts)
string(REPLACE "/" "_" ptarget2 "${pack}")
string(REPLACE "." "_" ptarget "${ptarget2}")
set(packfilestmp "${libgo_binroot}/${ptarget}.gofiles")
file(STRINGS ${packfilestmp} matchoutput)
separate_arguments(matchoutput)
# Canonicalize paths. Not strictly needed, but makes output nicer.
foreach( packsrc ${matchoutput})
string(STRIP ${packsrc} spack)
get_filename_component(canonsrc "${spack}" REALPATH)
list(APPEND packsrcs "${canonsrc}")
get_filename_component(canondir "${canonsrc}" DIRECTORY)
if(NOT ${canondir} STREQUAL ${libgo_binroot})
list(APPEND basepacksrcs "${canonsrc}")
endif()
endforeach()
# Collect any package-specific Go command line flags
set(packopts "${${ptarget}_gocflags}")
endmacro()
#........................................................................
# Certain packages need special compiler options. The convention here
# <pkg>_gocflags holds the command line options needed for <pkg>.
# FIXME: when 386 comes on line, use correct 386-specific options here.
set(math_gocflags "-ffp-contract=off" "-fno-math-errno" "-fno-trapping-math")
set(math_check_gocflags "-ffp-contract=off" "-fno-math-errno" "-fno-trapping-math")
set(runtime_gocflags "-fgo-c-header=runtime.inc.raw" "-fgo-compiling-runtime")
set(runtime_check_gocflags "-fgo-compiling-runtime")
set(runtime_internal_atomic_gocflags "-fgo-compiling-runtime")
set(runtime_internal_atomic_check_gocflags "-fgo-compiling-runtime")
set(runtime_internal_sys_gocflags "-fgo-compiling-runtime")
set(runtime_internal_sys_check_gocflags "-fgo-compiling-runtime")
set(runtime_pprof_check_gocflags "-fno-inline" "-static-libgo")
#........................................................................
# Rules for version.go
set(versiondotgo "${libgo_binroot}/version.go")
set(versiontmp "${libgo_binroot}/version.go.tmp")
mkversion(${goos} ${goarch} ${versiontmp} ${libgo_binroot}
${libgo_gosrcroot} ${libgo_scriptroot})
copy_if_different(${versiontmp} ${versiondotgo})
# Rules for gccgosizes.go
set(gccgosizesdotgo "${libgo_binroot}/gccgosizes.go")
set(gccgosizestmp "${libgo_binroot}/gccgosizes.go.tmp")
mkgccgosizes(${goarch} ${gccgosizestmp} ${libgo_scriptroot})
copy_if_different(${gccgosizestmp} ${gccgosizesdotgo})
# Rules for objabi.go
set(objabidotgo "${libgo_binroot}/objabi.go")
set(objabitmp "${libgo_binroot}/objabi.go.tmp")
mkobjabi(${objabitmp} ${libgo_binroot} ${libgo_gosrcroot})
copy_if_different(${objabitmp} ${objabidotgo})
# Rules for zstdpkglist.go
set(zstdpkglistdotgo "${libgo_binroot}/zstdpkglist.go")
set(zstdpkglisttmp "${libgo_binroot}/zstdpkglist.go.tmp")
mkzstdpkglist("goroot" ${zstdpkglisttmp} "${libpackages}")
copy_if_different(${zstdpkglisttmp} ${zstdpkglistdotgo})
# Rules for zdefaultcc.go
set(zdefaultccdotgo "${libgo_binroot}/zdefaultcc.go")
set(zdefaultcctmp "${libgo_binroot}/zdefaultcc.go.tmp")
mkzdefaultcc("cfg" ${zdefaultcctmp}
${CMAKE_C_COMPILER} ${CMAKE_CXX_COMPILER} EXPORT)
copy_if_different(${zdefaultcctmp} ${zdefaultccdotgo})
# Rules for gen-sysinfo.go
set(gensysinfodotgo "${libgo_binroot}/gen-sysinfo.go")
set(gensysinfotmp "${libgo_binroot}/gen-sysinfo.go.tmp")
set(gensysinfomacrotmp "${libgo_binroot}/sysinfo.macros.txt")
set(gensysinfoobject "${libgo_binroot}/sysinfo.o")
get_target_property(godumpspecdir llvm-godumpspec RUNTIME_OUTPUT_DIRECTORY)
set(godumpspecexec "${godumpspecdir}/llvm-godumpspec")
set(sysinfoc "${libgo_srcroot}/sysinfo.c")
set(sysinfoflags ${basedefines})
list(APPEND sysinfoflags "-I${libgo_binroot}" "-I${libgo_binroot}/runtime")
mkgensysinfo(${gensysinfotmp} ${gensysinfodotgo}
${gensysinfomacrotmp} ${gensysinfoobject} ${godumpspecexec} ${sysinfoc}
CFLAGS ${sysinfoflags}
DEPS llvm-godumpspec ${runtimeconfigdoth})
# Command to create runtime_sysinfo.go, via shell script.
set(mkrsysinfosh "${libgo_scriptroot}/mkrsysinfo.sh")
set(rsysinfodotgo "${libgo_binroot}/runtime_sysinfo.go")
generate_go_from_script(${rsysinfodotgo} ${mkrsysinfosh}
${goos} ${goarch} ${libgo_binroot}
DEP ${gensysinfodotgo})
# Command to create sigtab.go, via shell script
set(sigtabdotgo "${libgo_binroot}/sigtab.go")
set(mksigtabsh "${libgo_scriptroot}/mksigtab.sh")
generate_go_from_script(${sigtabdotgo} ${mksigtabsh}
${goos} ${goarch} ${libgo_binroot}
CAPTURE DEP ${gensysinfodotgo})
# Generation of libcalls.go
set(libcallsdotgo "${libgo_binroot}/libcalls.go")
set(libcallstmp "${libgo_binroot}/tmp-libcalls.go")
set(awkfile "${libgo_gosrcroot}/syscall/mksyscall.awk")
set(mklibcallssh "${CMAKE_CURRENT_SOURCE_DIR}/mklibcalls.sh")
collect_package_inputs("syscall")
set(syscallgofiles "${libgo_binroot}/syscall.basefiles")
string(REPLACE ";" " " basepacksrcs "${basepacksrcs}")
file(WRITE "${syscallgofiles}" "${basepacksrcs}\n")
generate_go_from_script(${libcallsdotgo} ${mklibcallssh} ${goos} ${goarch}
${libgo_binroot} DEP ${awkfile} ${syscallgofiles}
SCRIPTARGS ${awk} ${awkfile} ${syscallgofiles}
${libcallstmp})
# Generated file errno.i
set(errnoi "${libgo_binroot}/errno.i")
set(errnoitmp "${libgo_binroot}/tmp-errno.i")
set(mkerrnoish "${CMAKE_CURRENT_SOURCE_DIR}/mkerrnoi.sh")
set(cflags ${CMAKE_C_FLAGS})
if(NOT "${CMAKE_SYSROOT}" STREQUAL "")
set(cflags "--sysroot=${CMAKE_SYSROOT}")
endif()
generate_go_from_script(${errnoi} ${mkerrnoish} ${goos} ${goarch}
${libgo_binroot} SCRIPTARGS "${CMAKE_C_COMPILER}"
${errnoitmp} ${cflags})
# Generated file sysinfo.go
set(sysinfodotgo "${libgo_binroot}/sysinfo.go")
set(mksysinfosh "${libgo_scriptroot}/mksysinfo.sh")
generate_go_from_script(${sysinfodotgo} ${mksysinfosh} ${goos} ${goarch}
${libgo_binroot} DEP ${gensysinfodotgo} ${errnoi})
# Generated file syscall_arch.go
set(syscallarchdotgo "${libgo_binroot}/syscall_arch.go")
set(syscallarchtmp "${libgo_binroot}/syscall_arch.go.tmp")
mksyscallarch(${syscallarchtmp} ${goos} ${goarch})
copy_if_different(${syscallarchtmp} ${syscallarchdotgo})
# Compute epoll size/offset info
compute_struct_size_at_compile_time(SIZEOF_STRUCT_EPOLL_EVENT
"struct epoll_event"
"sys/epoll.h"
"cmake-epoll-tmpfile.cpp")
compute_field_offset_at_compile_time(STRUCT_EPOLL_EVENT_FD_OFFSET
"struct epoll_event"
"data.fd"
"stddef.h;sys/epoll.h"
"cmake-epoll-tmpfile.cpp")
# Generated file epoll.go
set(epolldotgo "${libgo_binroot}/epoll.go")
set(epolltmp "${libgo_binroot}/epoll.go.tmp")
mkepoll(${epolltmp})
copy_if_different(${epolltmp} ${epolldotgo})
# Generated file cpugen.go
set(cpugendotgo "${libgo_binroot}/cpugen.go")
set(cpugentmp "${libgo_binroot}/cpugen.go.tmp")
mkcpugen(${goarch} ${cpugentmp} ${libgo_scriptroot})
copy_if_different(${cpugentmp} ${cpugendotgo})
# Generated file gcpugen.go
set(gcpugendotgo "${libgo_binroot}/gcpugen.go")
set(gcpugentmp "${libgo_binroot}/gcpugen.go.tmp")
mkgcpugen(${goarch} ${gcpugentmp} ${libgo_scriptroot})
copy_if_different(${gcpugentmp} ${gcpugendotgo})
# Generate *_linknames.go files for various packages. For the syscall
# package, generate syscall_linknames.go by examining libcalls.go; for
# { runtime, os, os/user } packages, examine the package source files.
set(lnpkgs "runtime" "os" "os/user" "syscall")
set(lnawkfile "${libgo_scriptroot}/mklinknames.awk")
set(mklinknamessh "${CMAKE_CURRENT_SOURCE_DIR}/mklinknames.sh")
foreach( pack ${lnpkgs})
string(REPLACE "/" "_" ptarget2 "${pack}")
string(REPLACE "." "_" ptarget "${ptarget2}")
set(pkgofiles "${libgo_binroot}/${ptarget}.lnbasefiles")
set(deps "")
if(${pack} STREQUAL "syscall")
set(deps "${libcallsdotgo}")
else()
collect_package_inputs(${pack})
string(REPLACE ";" " " deps "${basepacksrcs}")
endif()
file(WRITE "${pkgofiles}" "${deps}\n")
set(pklinknamestmp "${libgo_binroot}/tmp-${ptarget}_linknames.go")
set(pklinknamesdotgo "${libgo_binroot}/${ptarget}_linknames.go")
get_filename_component(pkbase "${pack}" NAME)
generate_go_from_script(${pklinknamesdotgo} ${mklinknamessh} ${goos} ${goarch}
${libgo_binroot} DEP ${awkfile} ${pkgofiles} ${gensysinfodotgo}
${libcallsdotgo} SCRIPTARGS ${awk} ${lnawkfile}
${pkgofiles} ${pklinknamestmp} ${pkbase})
endforeach()
#........................................................................
message(STATUS "Libgo: creating stdlib package targets")
set(libgo_go_picobjects)
set(libgo_go_nonpicobjects)
set(libgo_goxfiles)
set(libgotool_nonpicobjects)
# Process each package
foreach( pack ${allpackages})
string(REPLACE "/" "_" ptarget2 "${pack}")
string(REPLACE "." "_" ptarget "${ptarget2}")
collect_package_inputs(${pack})
# Generate dependencies.
set(packdeps)
godeps(${pack} ${libgo_scriptroot} SOURCES ${basepacksrcs})
# If this is a gotool package, we don't need a pic version
set(nopic)
list(FIND toolpackages ${pack} found)
if(NOT ${found} EQUAL -1)
set(nopic "NOPIC")
endif()
# Call into helper to create rules for package.
add_go_package("${pack}" "${libgo_binroot}" GOSRC ${packsrcs} GODEP ${packdeps} GOCFLAGS ${packopts} ${libgo_extra_gocflags} ${nopic})
# Accumulate libgo objects.
if(${found} EQUAL -1)
list(APPEND libgo_go_picobjects ${package_picofile})
list(APPEND libgo_go_nonpicobjects ${package_ofile})
list(APPEND libgo_goxfiles ${package_goxfile})
else()
list(APPEND libgotool_nonpicobjects ${package_ofile})
endif()
endforeach()
# Create object library for libgotool
add_library(libgotool STATIC EXCLUDE_FROM_ALL ${libgotool_nonpicobjects})
set_target_properties(libgotool PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${libgo_binroot})
set_target_properties(libgotool PROPERTIES OUTPUT_NAME "gotool")
set_target_properties(libgotool PROPERTIES LINKER_LANGUAGE C)
# This file contains the list of packages for which we want to run tests.
file(STRINGS "${libgo_srcroot}/check-packages.txt" checkpackages)
#......................................................................
#
# C portion of libgo
# Generate new runtime.inc from runtime.inc.raw if anything has changed.
set(runtimeinc "${libgo_binroot}/runtime.inc")
set(runtimeincraw "${libgo_binroot}/runtime.inc.raw")
set(runtimeinctmp "${libgo_binroot}/runtime.inc.tmp")
set(runtimeincgen "${libgo_binroot}/tmp-runtime.inc")
set(mkruntimeincsh "${libgo_srcroot}/mkruntimeinc.sh")
generate_go_from_script(${runtimeinc} ${mkruntimeincsh} "" "" ${libgo_binroot} SCRIPTARGS ${runtimeincraw} ${runtimeinctmp} ${runtimeincgen} DEP "libgo_runtime")
# Create a target for runtime.inc so that things can depend on it
add_custom_target(runtimeinctarg DEPENDS ${runtimeinc})
# Base C files from the runtime dir.
set(runtimecfiles
"runtime/aeshash.c"
"runtime/go-assert.c"
"runtime/go-caller.c"
"runtime/go-callers.c"
"runtime/go-cgo.c"
"runtime/go-construct-map.c"
"runtime/go-ffi.c"
"runtime/go-fieldtrack.c"
"runtime/go-matherr.c"
"runtime/go-memclr.c"
"runtime/go-memequal.c"
"runtime/go-memmove.c"
"runtime/go-nanotime.c"
"runtime/go-now.c"
"runtime/go-nosys.c"
"runtime/go-reflect-call.c"
"runtime/go-setenv.c"
"runtime/go-signal.c"
"runtime/go-unsafe-pointer.c"
"runtime/go-unsetenv.c"
"runtime/go-unwind.c"
"runtime/go-varargs.c"
"runtime/env_posix.c"
"runtime/panic.c"
"runtime/print.c"
"runtime/proc.c"
"runtime/runtime_c.c"
"runtime/stack.c"
"runtime/yield.c"
"runtime/go-context.S")
# C files that happen to be living in other packages.
list(APPEND runtimecfiles
"go/internal/bytealg/bytealg.c"
"go/log/syslog/syslog_c.c"
"go/os/dir_gccgo_c.c"
"go/reflect/makefunc_ffi_c.c"
"go/runtime/internal/atomic/atomic.c"
"go/internal/cpu/cpu_gccgo.c"
"go/sync/atomic/atomic.c"
"go/syscall/errno.c"
"go/syscall/signame.c"
"go/syscall/wait.c")
if (NOT ${goarch} STREQUAL "arm64")
list(APPEND runtimecfiles
"go/golang.org/x/sys/cpu/cpu_gccgo_x86.c")
endif()
# Linux-specific C files.
if(${goos} STREQUAL "linux")
list(APPEND runtimecfiles
"go/syscall/clone_linux.c")
endif()
# Form full paths.
set(runtimecpaths)
foreach(cfile ${runtimecfiles})
list(APPEND runtimecpaths "${libgo_csrcroot}/${cfile}")
endforeach()
# go-wrapper.c is not in gofrontend/libgo
list(APPEND runtimecpaths "${GOLLVM_SOURCE_DIR}/libgo/runtime/go-wrappers.c")
# Compiler flags for C files in the runtime.
set(baseopts "-g -Wno-zero-length-array ")
if(GOLLVM_USE_SPLIT_STACK)
string(APPEND baseopts "-fsplit-stack ")
endif()
foreach(def ${basedefines})
string(APPEND baseopts "${def} ")
endforeach()
string(APPEND baseopts "${GOLLVM_EXTRA_CFLAGS} ")
# Special flags required for aeshash.c (functions in this file are called
# only when running on the proper architecture, so it is safe to ask for
# specific architectural features).
if (${goarch} STREQUAL "arm64")
set_source_files_properties(${libgo_csrcroot}/runtime/aeshash.c PROPERTIES COMPILE_FLAGS "-march=armv8-a+crypto")
else()
set_source_files_properties(${libgo_csrcroot}/runtime/aeshash.c PROPERTIES COMPILE_FLAGS "-maes -mssse3")
endif()
# Object library based on libgo C code, PIC-compiled
add_library(libgo_c_piclib OBJECT EXCLUDE_FROM_ALL ${runtimecpaths})
set_target_properties(libgo_c_piclib PROPERTIES COMPILE_FLAGS "-fPIC ${baseopts}")
target_include_directories(libgo_c_piclib PUBLIC
"${libgo_csrcroot}/runtime"
"${libgo_binroot}/runtime"
${libbacktrace_srcroot})
add_dependencies(libgo_c_piclib runtimeinctarg)
# Library with non-PIC-compiled objects from libgo C code
add_library(libgo_c_nonpiclib OBJECT EXCLUDE_FROM_ALL ${runtimecpaths})
set_target_properties(libgo_c_nonpiclib PROPERTIES COMPILE_FLAGS "-fno-PIC ${baseopts}")
target_include_directories(libgo_c_nonpiclib PUBLIC
"${libgo_csrcroot}/runtime"
"${libgo_binroot}/runtime"
${libbacktrace_srcroot})
add_dependencies(libgo_c_nonpiclib runtimeinctarg)
# Static libgo -- combines non-pic C objects and non-pic Go objects
add_gollvm_library(libgo_static STATIC
$<TARGET_OBJECTS:libgo_c_nonpiclib>
${libgo_go_nonpicobjects}
$<TARGET_OBJECTS:libbacktrace_nonpiclib>
$<TARGET_OBJECTS:libffi_nonpiclib>)
set_target_properties(libgo_static PROPERTIES OUTPUT_NAME "go")
set_target_properties(libgo_static PROPERTIES
ARCHIVE_OUTPUT_DIRECTORY ${libgo_binroot})
# HACK: undo LLVM default here.
string(REPLACE "-Wl,-z,defs" "" CMAKE_SHARED_LINKER_FLAGS
"${CMAKE_SHARED_LINKER_FLAGS}")
# Shared libgo -- combines pic C objects and non-pic Go objects.
add_gollvm_library(libgo_shared SHARED
$<TARGET_OBJECTS:libgo_c_piclib>
${libgo_go_picobjects}
$<TARGET_OBJECTS:libbacktrace_piclib>
$<TARGET_OBJECTS:libffi_piclib>)
set_target_properties(libgo_shared PROPERTIES
LIBRARY_OUTPUT_DIRECTORY ${libgo_binroot})
set_target_properties(libgo_shared PROPERTIES OUTPUT_NAME "go")
set(linkopts "-lpthread;-lm")
if(GOLLVM_USE_SPLIT_STACK)
string(APPEND linkopts ";-fsplit-stack")
endif()
target_link_libraries(libgo_shared PUBLIC "${linkopts}")
# Sources for libgobegin.a
set(libgobegincfiles
"${libgo_csrcroot}/runtime/go-main.c")
# libgobegin.a (static library only)
add_gollvm_library(libgobegin STATIC
${libgobegincfiles})
add_dependencies(libgobegin runtimeinctarg)
target_include_directories(libgobegin PUBLIC
"${libgo_csrcroot}/runtime"
"${libgo_binroot}/runtime")
# Use -fPIC for libgobegin so that it can be put in a PIE.
set_target_properties(libgobegin PROPERTIES COMPILE_FLAGS "${baseopts} -fPIC")
set_target_properties(libgobegin PROPERTIES OUTPUT_NAME "gobegin")
set_target_properties(libgobegin PROPERTIES
ARCHIVE_OUTPUT_DIRECTORY ${libgo_binroot})
# Sources for libgolibbegin.a
set(libgolibbegincfiles
"${libgo_csrcroot}/runtime/go-libmain.c")
# libgolibbegin.a (static library only)
add_gollvm_library(libgolibbegin STATIC
${libgolibbegincfiles})
add_dependencies(libgolibbegin runtimeinctarg)
target_include_directories(libgolibbegin PUBLIC
"${libgo_csrcroot}/runtime"
"${libgo_binroot}/runtime")
# Use -fPIC for libgolibbegin so that it can be put in a PIE.
set_target_properties(libgolibbegin PROPERTIES
COMPILE_FLAGS "${baseopts} -fPIC")
set_target_properties(libgolibbegin PROPERTIES OUTPUT_NAME "golibbegin")
set_target_properties(libgolibbegin PROPERTIES
ARCHIVE_OUTPUT_DIRECTORY ${libgo_binroot})
# Pseudo-target for all libgo buildables.
add_custom_target(libgo_all DEPENDS
llvm-goc libgo_static libgo_shared libgobegin libgolibbegin)
add_dependencies(gollvm libgo_all)
# Create a target-specific symlink to the Go library dir. This is
# an interim solution; ideally we want to key off of CMAKE_INSTALL_PREFIX.
execute_process(COMMAND ${CMAKE_COMMAND}
-E make_directory "${LLVM_BINARY_DIR}/libgo")
execute_process(COMMAND ${CMAKE_COMMAND}
-E create_symlink "${libgo_binroot}"
"${LLVM_BINARY_DIR}/libgo/${LLVM_DEFAULT_TARGET_TRIPLE}")
#........................................................................
#
# Check target generation.
#
set(checktargets)
message(STATUS "Libgo: generating check targets")
foreach( pack ${checkpackages})
string(REPLACE "/" "_" ptarget2 "${pack}")
string(REPLACE "." "_" ptarget "${ptarget}")
set(runner "${CMAKE_CURRENT_SOURCE_DIR}/checkpackage.sh")
# This will set 'packsrcs' and 'packopts'
collect_package_inputs(${pack})
set(extralibs "")
string(FIND "${ptarget}" "cmd_" out)
if("${out}" EQUAL 0)
set(extralibs "${libgo_binroot}/libgotool.a")
endif()
# In some cases we want a different set of flags for the check
# target, notable the runtime package (where the main build uses
# -fgo-c-header=... but the check build does not).
set(checkgocflags "${${ptarget}_check_gocflags}")
if(NOT "${checkgocflags}" STREQUAL "")
set(packopts "${checkgocflags}")
endif()
# Test target for package x/y/z will be check_libgo_x_y_z
set(targetname "check_libgo_${ptarget}")
# Note: only a subset of package tests are dependent on libgotool.a,
# but for simplicity's sake we'll just make them all dependent on it.
add_custom_target(
${targetname}
COMMAND "${shell}" ${runner}
"PACKAGE" ${pack}
"FILES" ${packsrcs}
"GOOS" ${goos}
"GOARCH" ${goarch}
"GC" ${gocompiler} "-L" ${libgo_binroot} ${packopts} ${libgo_extra_gocflags}
"GOLIBS" ${packlibs} ${extralibs}
"BINDIR" "${libgo_binroot}"
"BASEDIR" "${libgo_srcroot}"
DEPENDS ${libgo_goxfiles} libgotool libgo_shared libgo_static libgobegin
COMMENT "Checking Go package ${pack}"
VERBATIM)
list(APPEND checktargets ${targetname})
endforeach()
add_custom_target(check-libgo DEPENDS ${checktargets})
message(STATUS "libgo configuration complete.")