Stripping Debug Symbols plugin

[dcdillon]

By adding the PKG_LIBS=-Wl,-S to my package, I tell the linker to strip the debug symbols when creating the .so file. This is necessary because I generate some truly unholy class and function names via templates (e.g. .so size goes from 13MB to 54KB with this flag added).

Would it be reasonable to add an // [[Rcpp::plugins(strip)]] that does this? I think it's probably useful.

[coatless]

To set some sort of build flags within the source has actually be brought up before: #266, #163, and #37.

I think perhaps a better way forward is to support a generalized version via:

// [[Rcpp::ldflags(-Wl,-S)]]

This is one of the features that I'd like to attack when I have a bit more time as I do not want to ruin the work of art that is the Rcpp Attributes system.

[thirdwing]

I think it should not be hard to add. However, it seems we need to think more about the design of attribute system.

Can you give some advice? @eddelbuettel

[kevinushey]

Well, the problem with using a plain old ldflags attribute is that it's not portable. I imagine @dcdillon wants a 'portable' solution, where 'portable' means 'works on Solaris'.

I would suggest that packages just do their own thing, e.g. you can always have in your DESCRIPTION file:

SystemRequirements: clang or gcc

and tell the CRAN maintainers that you're not interested in having your package distributed for Solaris machines.

[dcdillon]

Is there any way we can say PKG_LIBS=xxx unless Solaris?

[eddelbuettel]

@dcdillon Yes, (with a fair amount of work) using configure. That is exactly what configure is good at.

But I am with @kevinushey. Just alter SystemRequirements: to say, for example, "Windows or OS X or Linux". Maybe use a comma instead. I could swear that CRANberries showed me a new package once that had exactly that.

Now, of course, if you do we may mock you til the end of time for chickening out in front of Solaris.

In all seriousness though this is a tricky topic. Maybe not the time to rush this. I do like the discussion about the plugin of extra linker flags. That is good.

One loose idea: do what we did earlier for Rcpp and have R code return the proper string. Then we know at run-time that it is Slowlaris and we return an empty (and hence very, ahem, "portable") string, The others get your desired stripping behaviour.

[dcdillon]

Can you detect Solaris effectively within R? If so that's a nice and easy idea. And // [[Rcpp::plugins(strip)]] would definitely be a good thing...good for RcppArmadillo...good for BH, etc.

edit: Armadillo not Armadillon

[coatless]

@dcdillon Yes, you can reliably detect the different OSes.

https://github.com/coatless/balamuta/blob/282771477ecf21a99282e0da2bc053a7a97a1d4e/R/is_os.R#L16-L50

[dcdillon]

Well hell...let's do that. And condition a plugin (I vote for calling it strip) on that.

[eddelbuettel]

He scares R Core members. Earlier this afternoon: https://twitter.com/kwbroman/status/759837614262321152

[dcdillon]

If we can do something like https://github.com/dcdillon/RcppHoney/blob/feature/strip-libraries/R/onLoad.R, I will write it up. Any objections?

[dcdillon]

After much head scratching (and being put in my place by Oxford professors), I have something that should be on CRAN later today (we'll see if it passes, but I think we're in good shape now). It needs more linker support, but as a first pass it may be useful.

The return value of the following function is either "" or "-Wl,-S" and can be added to a plugin as the LIBS member of the list.

.getLibs <- function() {
    # These are the linker "wrappers" that we support.  This means
    # that we know how to ask the SHLIB_LD or SHLIB_CXXLD project
    linker_pattern <- "gcc|clang|g\\+\\+"

    # Call each linker wrapper that we know about with --version so we
    # can figure out whether we can support it for stripping or not.
    shlib_ld <- system(paste0(file.path(R.home("bin"), "R"),
        " CMD config SHLIB_LD"), intern=TRUE)
    shlib_cxxld <- system(paste0(file.path(R.home("bin"), "R"),
        " CMD config SHLIB_CXXLD"), intern=TRUE)

    shlib_ld_good <- FALSE
    shlib_cxxld_good <- FALSE

    # If SHLIB_LD has been defined, call it with --version and inspect
    # the output to determine if we know about it or not.  In the case
    # where --version is not supported, we should error here and assume
    # that we know nothing about the linker.
    if (shlib_ld != "") {
        shlib_ld_good <- tryCatch({
            shlib_ld_results <- system(paste0(shlib_ld, " --version"), intern=TRUE)

            # If the linker wrapper we got is something we know about,
            # ask it what linker it actually uses.
            if (any(grepl(linker_pattern, shlib_ld_results))) {
                shlib_ld_prog <- system(paste0(shlib_ld, " --print-prog-name=ld"), intern=TRUE)
                shlib_ld_results <- system(paste0(shlib_ld_prog, " --version"), intern=TRUE)

                # If the actual linker is GNU ld or GNU gold, then we
                # know how to tell it to strip.
                shlib_ld_good <- (grepl("^GNU (ld|gold)", shlib_ld_results[1]))
            } else {
                shlib_ld_good <- FALSE
            }

            shlib_ld_good
        }, warning = function(w) {
            return(FALSE)
        }, error = function(e) {
            return(FALSE)
        })
    } else {
        shlib_ld_good <- TRUE
    }

    # If SHLIB_CXXLD has been defined, call it with --version and
    # inspect the output to determine if we know about it or not.  In
    # the case where --version is not supported, we should error here
    # and assume that we know nothing about the linker
    if (shlib_cxxld != "") {
        shlib_cxxld_good <- tryCatch({
            shlib_cxxld_results <- system(paste0(shlib_cxxld, " --version"), intern=TRUE)

            # If the linker wrapper we got is something we know about,
            # ask it what linker it actually uses.
            if (any(grepl(linker_pattern, shlib_cxxld_results))) {
                shlib_cxxld_prog <- system(paste0(shlib_cxxld, " --print-prog-name=ld"), intern=TRUE)
                shlib_cxxld_results <- system(paste0(shlib_cxxld_prog, " --version"), intern=TRUE)

                # If the actual linker is GNU ld or GNU gold, then we
                # know how to tell it to strip
                shlib_cxxld_good <- (grepl("^GNU (ld|gold)", shlib_cxxld_results[1]))
            } else {
                shlib_cxxld_good <- FALSE
            }

            shlib_cxxld_good
        }, warning = function(w) {
            return(FALSE)
        }, error = function(e) {
            return(FALSE)
        })
    } else {
        shlib_cxxld_good <- TRUE
    }

    # If all the linkers we looked at use GNU compatible linkers, then
    # we can pass them -Wl,-S
    libs <- if (shlib_ld_good && shlib_cxxld_good) "-Wl,-S" else ""

    libs
}

[dcdillon]

Basically it says, "If we are using a GNU linker (ld or gold), then we can pass -Wl,-S to it and get the stripping we desire."

[github-actions]

This issue is stale (365 days without activity) and will be closed in 31 days unless new activity is seen. Please feel free to re-open it is still a concern, possibly with additional data.