[cmake/multilib] Teach llgo to respect the LLVM_LIBDIR_SUFFIX variable for multilib build and installs.

[chandlerc]

Summary

With this, I get the go subdirectory under the suffixed library which matches
the system's go subdirectory. However, when I run check-llgo everything fails
due to the linker being unable to find libgobegin-llgo or libgo-llgo. It
doesn't seem to be searching the lib64 directory where the libraries are.

Also, there are a *lot* of hard-coded 'lib' references in the gllgo code which
I feel are probably in need of multilib support as well.

So, sending this patch mostly as a starting point for folks to figure out how
to make llgo happy in a multilib world.

[chandlerc]

(added pcc as an explicit reviewer)

[pcc]

I think the right thing to do is to teach the getVariantDir function in gllgo.go to return an appropriate string (something like "../lib${LLVM_LIBDIR_SUFFIX}[/sanitizer]"). That string should eventually make its way to many of the appropriate places including the libgo build system. That and the initCompiler function looks like everything that needs to be taught about this.

Did you end up exposing LLVM_LIBDIR_SUFFIX somewhere like a #define in a header file? If so, we should be able to pick it up from Go (see e.g. bindings/go/llvm/version.go for an example of how to do that).

Let me know if you have any trouble making changes to the Go code and I'll see if I can take a look at it.

CMakeLists.txt

119

We shouldn't need this change after making my suggested changes.

[chandlerc]

Update to reflect a different direction for this suggested by Peter on IRC
where we use a CGO-accessed header file.

Still some debate as to what the right place to put this header file really
is...

[pcc]

LGTM

cmd/gllgo/gllgo.go

64

The formatting here looks inconsistent, did you run gofmt?

CMakeLists.txt

 include(ExternalProject)
 include(ProcessorCount)
 
+# Provide a config.h which exposes build system information.
+configure_file(
+  cmd/gllgo/config.h.cmake
+  ${CMAKE_CURRENT_BINARY_DIR}/cmd/gllgo/config.h)
+include_directories(${CMAKE_CURRENT_BINARY_DIR}/cmd/gllgo)
+
 llvm_add_go_executable(llgo llvm.org/llgo/cmd/gllgo ALL DEPENDS
   build/context.go
   cmd/gllgo/gllgo.go
   debug/debug.go
   irgen/annotations.go
   irgen/attribute.go
   irgen/builtins.go
   irgen/cabi.go
function(add_libgo_variant suffix cflags gocflags deps exclude_from_all)
 
   add_clobber_steps(libffi${suffix} clang ${deps})
 
   externalproject_add(libgo${suffix}
     DEPENDS clang llgo cc-wrapper libbacktrace${suffix} libffi${suffix} ${deps}
     SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo
     BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/${suffix}/libgo
     INSTALL_DIR ${CMAKE_BINARY_DIR}
     CONFIGURE_COMMAND <SOURCE_DIR>/configure --disable-multilib --without-libatomic --prefix=<INSTALL_DIR> "CC=env REAL_CC=${CMAKE_BINARY_DIR}/bin/clang@SPACE@${cflags} ${CMAKE_BINARY_DIR}/bin/cc-wrapper" "GOC=${CMAKE_BINARY_DIR}/bin/llgo -no-prefix -fcompilerrt-prefix=${CMAKE_BINARY_DIR} ${gocflags}"
     BUILD_COMMAND make -j${PROCESSOR_COUNT}
     LOG_CONFIGURE 1
     LOG_BUILD 1
     LOG_INSTALL 1
   )
   set_property(TARGET libgo${suffix}
                PROPERTY EXCLUDE_FROM_ALL ${exclude_from_all})
 

 if(TARGET msan)
   add_libgo_variant("_msan" "-fsanitize=memory" "-fsanitize=memory" msan TRUE)
 endif()
 
 if(TARGET dfsan)
   add_libgo_variant("_dfsan" "-fsanitize=dataflow" "-fsanitize=dataflow" dfsan TRUE)
 endif()
 
-install(FILES ${CMAKE_BINARY_DIR}/lib/libgo-llgo.a
-              ${CMAKE_BINARY_DIR}/lib/libgo-llgo.so
-              ${CMAKE_BINARY_DIR}/lib/libgo-llgo.so.6
-              ${CMAKE_BINARY_DIR}/lib/libgo-llgo.so.6.0.0
-              ${CMAKE_BINARY_DIR}/lib/libgobegin-llgo.a
-        DESTINATION lib)
+set(LLGO_LIBRARY_DIR ${CMAKE_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX})
+
+install(FILES ${LLGO_LIBRARY_DIR}/libgo-llgo.a
+              ${LLGO_LIBRARY_DIR}/libgo-llgo.so
+              ${LLGO_LIBRARY_DIR}/libgo-llgo.so.6
+              ${LLGO_LIBRARY_DIR}/libgo-llgo.so.6.0.0
+              ${LLGO_LIBRARY_DIR}/libgobegin-llgo.a
+        DESTINATION lib${LLVM_LIBDIR_SUFFIX})
 
-install(DIRECTORY ${CMAKE_BINARY_DIR}/lib/go
-        DESTINATION lib)
+install(DIRECTORY ${LLGO_LIBRARY_DIR}/go
+        DESTINATION lib${LLVM_LIBDIR_SUFFIX})
 
 add_custom_target(check-libgo
   COMMAND make -C ${CMAKE_CURRENT_BINARY_DIR}/libgo -j${PROCESSOR_COUNT} check
   DEPENDS libgo
   COMMENT "Running libgo tests")
 
 add_custom_target(check-llgo-bootstrap
   COMMAND strip -R .note.gnu.build-id -o ${CMAKE_CURRENT_BINARY_DIR}/llgo-stage2.stripped

cmd/gllgo/config.h.cmake

+/* This generated file is for internal use. Do not include it from headers. */
+
+#ifdef CONFIG_H
+#error config.h can only be included once
+#else
+#define CONFIG_H
+
+/* Multilib suffix for libdir. */
+#define LLVM_LIBDIR_SUFFIX "${LLVM_LIBDIR_SUFFIX}"
+
+#endif

cmd/gllgo/gllgo.go

 //===- gllgo.go - gccgo-like driver for llgo ------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This is llgo's driver. It has a gccgo-like interface in order to easily
 // interoperate with the "go" command and the libgo build system.
 //
 //===----------------------------------------------------------------------===//
 
 package main
 
+/*
+#include "config.h"
+*/
+import "C"
+
 import (
   "errors"
   "fmt"
   "go/scanner"
   "io/ioutil"
   "log"
   "os"
   "os/exec"
   "path/filepath"
   "strings"
 
   "llvm.org/llgo/debug"
   "llvm.org/llgo/irgen"
   "llvm.org/llvm/bindings/go/llvm"
 )
 
+const LibDirSuffix = C.LLVM_LIBDIR_SUFFIX
+
 func report(err error) {
   if list, ok := err.(scanner.ErrorList); ok {
     for _, e := range list {
       fmt.Fprintf(os.Stderr, "%s\n", e)
     }
   } else if err != nil {
     fmt.Fprintf(os.Stderr, "gllgo: error: %s\n", err)
   }
 }
 
 func llvmVersion() string {
   return strings.Replace(llvm.Version, "svn", "", 1)
 }
 
 func displayVersion() {
   fmt.Printf("llgo version %s (%s)\n\n", llvmVersion(), irgen.GoVersion())
   os.Exit(0)
 }
 
 func initCompiler(opts *driverOptions) (*irgen.Compiler, error) {
   importPaths := make([]string, len(opts.importPaths)+len(opts.libPaths))
   copy(importPaths, opts.importPaths)
   copy(importPaths[len(opts.importPaths):], opts.libPaths)
   if opts.prefix != "" {
-    importPaths = append(importPaths, filepath.Join(opts.prefix, "lib", "go", "llgo-"+llvmVersion()))
+    importPaths = append(importPaths, filepath.Join(opts.prefix, "lib" + LibDirSuffix, "go", "llgo-"+llvmVersion()))
   }
   copts := irgen.CompilerOptions{
     TargetTriple:       opts.triple,
     GenerateDebug:      opts.generateDebug,
     DebugPrefixMaps:    opts.debugPrefixMaps,
     DumpSSA:            opts.dumpSSA,
     GccgoPath:          opts.gccgoPath,
     ImportPaths:        importPaths,

 type sanitizerOptions struct {
   blacklist string
   crtPrefix string
 
   address, thread, memory, dataflow bool
 }
 
 func (san *sanitizerOptions) resourcePath() string {
-  return filepath.Join(san.crtPrefix, "lib", "clang", llvmVersion())
+  return filepath.Join(san.crtPrefix, "lib" + LibDirSuffix, "clang", llvmVersion())
 }
 
 func (san *sanitizerOptions) isPIEDefault() bool {
   return san.thread || san.memory || san.dataflow
 }
 
 func (san *sanitizerOptions) addPasses(mpm, fpm llvm.PassManager) {
   switch {
case '"', '\\':
       edata = append(edata, '\\')
     }
     edata = append(edata, data[i])
   }
   edata = append(edata, "\"\n"...)
   return string(edata)
 }
 
-// Get the lib-relative path to the standard libraries for the given driver
-// options. This is normally '.' but can vary for cross compilation, LTO,
-// sanitizers etc.
-func getVariantDir(opts *driverOptions) string {
+// Get the lib path to the standard libraries for the given driver options.
+// This is normally 'lib' but can vary for cross compilation, LTO, sanitizers
+// etc.
+func getLibDir(opts *driverOptions) string {
+  lib := "lib" + LibDirSuffix
   switch {
   case opts.lto:
-    return "llvm-lto.0"
+    return filepath.Join(lib, "llvm-lto.0")
   case opts.sanitizer.address:
-    return "llvm-asan.0"
+    return filepath.Join(lib, "llvm-asan.0")
   case opts.sanitizer.thread:
-    return "llvm-tsan.0"
+    return filepath.Join(lib, "llvm-tsan.0")
   case opts.sanitizer.memory:
-    return "llvm-msan.0"
+    return filepath.Join(lib, "llvm-msan.0")
   case opts.sanitizer.dataflow:
-    return "llvm-dfsan.0"
+    return filepath.Join(lib, "llvm-dfsan.0")
   default:
-    return "."
+    return lib
   }
 }
 
 func performAction(opts *driverOptions, kind actionKind, inputs []string, output string) error {
   switch kind {
   case actionPrint:
     switch opts.output {
     case "-dumpversion":
       fmt.Println("llgo-"+llvmVersion())
       return nil
     case "-print-libgcc-file-name":
       cmd := exec.Command(opts.bprefix+"gcc", "-print-libgcc-file-name")
       out, err := cmd.CombinedOutput()
       os.Stdout.Write(out)
       return err
     case "-print-multi-os-directory":
-      fmt.Println(getVariantDir(opts))
+      fmt.Println(filepath.Join("..", getLibDir(opts)))
       return nil
     case "--version":
       displayVersion()
       return nil
     default:
       panic("unexpected print command")
     }
 
case actionLink:
     var linkerPath string
     if opts.gccgoPath == "" {
       // TODO(pcc): See if we can avoid calling gcc here.
       // We currently rely on it to find crt*.o and compile
       // any C source files passed as arguments.
       linkerPath = opts.bprefix + "gcc"
 
       if opts.prefix != "" {
-        libdir := filepath.Join(opts.prefix, "lib", getVariantDir(opts))
+        libdir := filepath.Join(opts.prefix, getLibDir(opts))
         args = append(args, "-L", libdir)
         if !opts.staticLibgo {
           args = append(args, "-Wl,-rpath,"+libdir)
         }
       }
 
       args = append(args, "-lgobegin-llgo")
       if opts.staticLibgo {