[libcxx] Support generating linker script for static library

[phosek]

Summary

When supported, we also generate linker script for static library,
renaming it to libc++static.a. The linker scripts also includes any
additional dependencies that the static library has.

[ldionne]

libcxx/lib/CMakeLists.txt

381

There's something I don't understand here. You seem to be calling the script as <script> output input (in that order) here, but the script seems to take input output based on the argparse stuff below. If "${CMAKE_STATIC_LIBRARY_PREFIX}c++static${CMAKE_STATIC_LIBRARY_SUFFIX}" is the input file, where is it created?

385

Why call it libc++static.a instead of libc++.a?

388

Is that true on all platforms? On what platforms is this linker script expected to work?

libcxx/utils/gen_link_script.py

11

Can you confirm that there are no functional changes beyond adding support for a custom output file in this script? This is only a refactoring (thanks!), or did I miss something?

25

I think a word is missing somewhere because this help seems unclear to me.

29

List of libraries? Just any libraries?

[phosek]

libcxx/lib/CMakeLists.txt

385

We rename libc++.a to libc++static.a and then create linker script called libc++.a in its place that contains INPUT(libc++static.a ...). Like I said in my email, I'm not a big fan of that name so I welcome other suggestions.

ChromeOS toolchain already does this in their toolchain build and they use the name libc++_static.a (I dropped _ because we already have libc++fs.a and libc++experimental.a), libstdc++ uses the same approach and they use the name libstdc++_nonshared.a.

[phosek]

libcxx/utils/gen_link_script.py

11

The original script did not support creating a linker script for static library, so there's a functional change, but I also refactored the code a bit to make it (subjectively) simpler. I'd be fine doing the refactoring as a separate change if you prefer?

[ldionne]

libcxx/utils/gen_link_script.py

11

No, I'm fine with the refactoring + the functional change, I was just trying to spot what the functional change was. I'm sorry, but I still don't see what prevented the previous script from handling static archives. Can you please point it out?

22–42

Please add general description of what the script does, like there used to be.

27

Please consider making these named parameters instead of positional parameters. That would have answered some of my questions before I had to ask them.

[phosek]

libcxx/lib/CMakeLists.txt

381

input is TARGET_SONAME_FILE:cxx_shared which would be libc++.so.1, output is TARGET_LINKER_FILE:cxx_shared which would be libc++.so. With these arguments gen_link_script.py generates libc++.so linker script that has libc++.so.1 as input, which matches the current behavior.

libcxx/utils/gen_link_script.py

11

Previous version assumes that the input file (libc++) is a symlink which would be the case for libc++.so which a symlink to libc++.so.1. The script replace that symlink with a linker script that includes the library that the symlink was originally pointing to.

However, this doesn't work for static library which is a plain file libc++.a. The new version now handles input files that are not symlinks and it also allows renaming the input to output (the --rename option), so libc++.a would be first renamed to libc++static.a and generated linker script would include it as input.

Does this make sense?

27

I find it little awkward to use optional arguments as required arguments but I can do that if you prefer?

[ldionne]

libcxx/lib/CMakeLists.txt

388

I liked c++static more than c++nonshared, personally.

libcxx/utils/gen_link_script.py

11

Ok, thanks for explaining.

27

You can have required named arguments: parser.add_argument('--foo', required=True). https://docs.python.org/2.7/library/argparse.html#required

[phosek]

libcxx/utils/gen_link_script.py

27

I know, I was just pointing out that I find it a little awkward to use "optional" arguments as required arguments which is what "positional" is typically used for, but that's just my personal preference. I'm fine changing that if you prefer.

[ldionne]

Ship it, with named parameters. Don't wait over the holidays.

libcxx/utils/gen_link_script.py

27

I don't understand why you say they're optional arguments.. To me, they are "named" arguments. Optional is when required=False, mandatory is when required=True. But regardless, I do think that using named arguments will be much better because of the self documentation -- I don't want to have to read this script to figure out what the command in the CMake is doing.

[ldionne]

@phosek do you still want to do this?

libcxx/cmake/Modules/HandleLibcxxFlags.cmake

foreach(lib ${ARGN})
     list(APPEND LIBCXX_INTERFACE_LIBRARIES ${lib})
   endforeach()
 endmacro()
 
 # Turn a comma separated CMake list into a space separated string.
 macro(split_list listname)
   string(REPLACE ";" " " ${listname} "${${listname}}")
 endmacro()
+
+# Appends value to all lists in ARGN, if the condition is true.
+macro(append_list_if condition value)
+  if(${condition})
+    foreach(list ${ARGN})
+      list(APPEND ${list} ${value})
+    endforeach()
+  endif()
+endmacro()

libcxx/cmake/config-ix.cmake

if(WIN32 AND NOT MINGW)
   # use of pthread-win32 or similar libraries to emulate pthreads on Windows?
   set(LIBCXX_HAS_PTHREAD_LIB NO)
   set(LIBCXX_HAS_M_LIB NO)
   set(LIBCXX_HAS_RT_LIB NO)
 else()
   check_library_exists(pthread pthread_create "" LIBCXX_HAS_PTHREAD_LIB)
   check_library_exists(m ccos "" LIBCXX_HAS_M_LIB)
   check_library_exists(rt clock_gettime "" LIBCXX_HAS_RT_LIB)
+  check_library_exists(dl dlopen "" LIBCXX_HAS_DL_LIB)
 endif()

libcxx/lib/CMakeLists.txt

PROPERTIES
       LINK_FLAGS    "${LIBCXX_LINK_FLAGS}"
       COMPILE_FLAGS "${LIBCXX_COMPILE_FLAGS}"
       OUTPUT_NAME   "c++external_threads"
   )
 endif()
 
 # Generate a linker script inplace of a libc++.so symlink. Rerun this command
 # after cxx builds.
-if (LIBCXX_ENABLE_SHARED AND LIBCXX_ENABLE_ABI_LINKER_SCRIPT)
+if (LIBCXX_ENABLE_ABI_LINKER_SCRIPT)
   # Get the name of the ABI library and handle the case where CXXABI_LIBNAME
   # is a target name and not a library. Ex cxxabi_shared.
   set(LIBCXX_INTERFACE_LIBRARY_NAMES)
   foreach(lib ${LIBCXX_INTERFACE_LIBRARIES})
     # FIXME: Handle cxxabi_static and unwind_static.
     if (TARGET ${lib} OR
         (${lib} MATCHES "cxxabi(_static|_shared)?" AND HAVE_LIBCXXABI) OR
         (${lib} MATCHES "unwind(_static|_shared)?" AND HAVE_LIBUNWIND))
       list(APPEND LIBCXX_INTERFACE_LIBRARY_NAMES "$<TARGET_PROPERTY:${lib},OUTPUT_NAME>")
     else()
       list(APPEND LIBCXX_INTERFACE_LIBRARY_NAMES "${lib}")
     endif()
   endforeach()
   #split_list(LIBCXX_INTERFACE_LIBRARY_NAMES)
   # Generate a linker script inplace of a libc++.so symlink. Rerun this command
   # after cxx builds.
   add_custom_command(TARGET cxx_shared POST_BUILD
     COMMAND
       ${PYTHON_EXECUTABLE} ${LIBCXX_SOURCE_DIR}/utils/gen_link_script.py
     ARGS
+      "$<TARGET_SONAME_FILE:cxx_shared>"
       "$<TARGET_LINKER_FILE:cxx_shared>"
       ${LIBCXX_INTERFACE_LIBRARY_NAMES}
     WORKING_DIRECTORY ${LIBCXX_BUILD_DIR}
   )
+  append_list_if(LIBCXX_HAS_M_LIB m LIBCXX_STATIC_LIBRARY_LIBS)
+  append_list_if(LIBCXX_HAS_DL_LIB dl LIBCXX_STATIC_LIBRARY_LIBS)
+  append_list_if(LIBCXX_HAS_PTHREAD_LIB pthread LIBCXX_STATIC_LIBRARY_LIBS)
+  add_custom_command(TARGET cxx_static POST_BUILD
+    COMMAND
+      ${PYTHON_EXECUTABLE} ${LIBCXX_SOURCE_DIR}/utils/gen_link_script.py
+    ARGS
+      "${CMAKE_STATIC_LIBRARY_PREFIX}c++nonshared${CMAKE_STATIC_LIBRARY_SUFFIX}"
+      "$<TARGET_LINKER_FILE:cxx_static>"
+      ${LIBCXX_INTERFACE_LIBRARY_NAMES}
+      ${LIBCXX_STATIC_LIBRARY_LIBS}
+    BYPRODUCTS
+      ${LIBCXX_LIBRARY_DIR}/${CMAKE_STATIC_LIBRARY_PREFIX}c++static${CMAKE_STATIC_LIBRARY_SUFFIX}
+    WORKING_DIRECTORY ${LIBCXX_LIBRARY_DIR}
+  )
 endif()
 
 if (LIBCXX_INSTALL_LIBRARY)
   if (LIBCXX_INSTALL_FILESYSTEM_LIBRARY)
     set(filesystem_lib cxx_filesystem)
   endif()
   if (LIBCXX_INSTALL_EXPERIMENTAL_LIBRARY)
     set(experimental_lib cxx_experimental)

libcxx/utils/gen_link_script.py

 #!/usr/bin/env python
 #===----------------------------------------------------------------------===##
 #
 #                     The LLVM Compiler Infrastructure
 #
 # This file is dual licensed under the MIT and the University of Illinois Open
 # Source Licenses. See LICENSE.TXT for details.
 #
 #===----------------------------------------------------------------------===##
 
-import os
-import sys
-
-def print_and_exit(msg):
-    sys.stderr.write(msg + '\n')
-    sys.exit(1)
-
-def usage_and_exit():
-    print_and_exit("Usage: ./gen_link_script.py [--help] [--dryrun] <path/to/libcxx.so> <public_libs>...")
-
-def help_and_exit():
-    help_msg = \
-"""Usage
-
-  gen_link_script.py [--help] [--dryrun] <path/to/libcxx.so> <public_libs>...
-
-  Generate a linker script that links libc++ to the proper ABI library.
-  The script replaces the specified libc++ symlink.
-  An example script for c++abi would look like "INPUT(libc++.so.1 -lc++abi)".
-
-Arguments
-  <path/to/libcxx.so> - The top level symlink to the versioned libc++ shared
-                        library. This file is replaced with a linker script.
-  <public_libs>       - List of library names to include in linker script.
-
-Exit Status:
-  0 if OK,
-  1 if the action failed.
+"""
 """
-    print_and_exit(help_msg)
 
-def parse_args():
-    args = list(sys.argv)
-    del args[0]
-    if len(args) == 0:
-        usage_and_exit()
-    if args[0] == '--help':
-        help_and_exit()
-    dryrun = '--dryrun' == args[0]
-    if dryrun:
-        del args[0]
-    if len(args) < 2:
-        usage_and_exit()
-    symlink_file = args[0]
-    public_libs = args[1:]
-    return dryrun, symlink_file, public_libs
-
-def main():
-    dryrun, symlink_file, public_libs = parse_args()
+import argparse
+import os
+import sys
 
-    # Check that the given libc++.so file is a valid symlink.
-    if not os.path.islink(symlink_file):
-        print_and_exit("symlink file %s is not a symlink" % symlink_file)
 
-    # Read the symlink so we know what libc++ to link to in the linker script.
-    linked_libcxx = os.readlink(symlink_file)
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--dryrun", help="Don't write any output",
+                        action="store_true", default=False)
+    parser.add_argument("--rename", action="store_true", default=False,
+                        help="Rename the output as input so we can replace it")
+    parser.add_argument("input", help="Path to libc++ library")
+    parser.add_argument("output", help="Path to libc++ linker script")
+    parser.add_argument("libraries", nargs="+",
+                        help="List of libraries libc++ depends on")
+    args = parser.parse_args()
+
+    if os.path.islink(args.input):
+        # Read the symlink so we know what libc++ to link to.
+        libcxx = os.readlink(args.input)
+    elif not os.path.exists(args.input):
+        # Rename the output so we can replace it with the script.
+        libcxx = os.path.relpath(args.input)
+        if os.path.exists(args.output):
+            os.rename(args.output, libcxx)
+    else:
+        libcxx = args.input
 
     # Prepare the list of public libraries to link.
-    public_libs = ['-l%s' % l for l in public_libs]
+    public_libs = ['-l%s' % l for l in args.libraries]
 
     # Generate the linker script contents and print the script and destination
     # information.
-    contents = "INPUT(%s %s)" % (linked_libcxx, ' '.join(public_libs))
-    print("GENERATING SCRIPT: '%s' as file %s" % (contents, symlink_file))
+    contents = "INPUT(%s %s)" % (libcxx, ' '.join(public_libs))
+    print("GENERATING SCRIPT: '%s' as file %s" % (contents, args.output))
+
+    if args.dryrun:
+        return 0
 
     # Remove the existing libc++ symlink and replace it with the script.
-    if not dryrun:
-        os.unlink(symlink_file)
-        with open(symlink_file, 'w') as f:
-            f.write(contents + "\n")
+    with open(args.output, 'w') as f:
 
+    return 0
+
 
 if __name__ == '__main__':
-    main()
+    sys.exit(main())