Attachment: Download

Issue Description:

I'm attempting to use some symbols from glibc that are normally hidden behind a _GNU_SOURCE macro definition. To do this, I've written a small SwiftPM module that provides a C header file that includes sys/socket.h after defining _GNU_SOURCE, to make the symbols available from that module to Swift.

Unfortunately, it seems like something in the Swift build toolchain, possibly the clang importer, is getting this wrong. To demonstrate the problem I've attached a small SwiftPM repro package that defines two modules: CMmesg, the C shim, and MMesg, a Swift module that attempts to use the symbols.

Example breakdown

For this example I'm using the mmsghdr structure defined in socket.h on Linux.

The project ultimately consists of three files. Firstly, a simple header file:

#ifndef C_MMESG_H
#define C_MMESG_H

#define _GNU_SOURCE
#include <sys/socket.h>

struct mmsghdr *allocateMMsg();
struct mmsghdr returnMMsg();

#endif

The main goal of this header file is to bring in the types from sys/socket.h, but we also forward-declare the two functions in the following C file. The C file exists to prove that, when compiling just the C code, SwiftPM correctly applies _GNU_SOURCE. It looks like this:

#include <c_mmesg.h>
#include <stdlib.h>

struct mmsghdr *allocateMMsg() {
    return malloc(sizeof(struct mmsghdr));
}


struct mmsghdr returnMMsg() {
    struct mmsghdr t = { 0 };
    return t;
}

This demonstrates that the C code is capable of seeing the structure definition for struct mmsghdr, as it uses it as a concrete type and knows its size.

Then we have a simple bit of Swift code:

import CMmesg

let x = mmsghdr()

print(x)

This code attempts to create a struct mmsghdr and print it.

Error

The compile fails with:

# swift run
Compile CMmesg empty.c
Compile Swift Module 'MMesg' (1 sources)
/code/Sources/MMesg/main.swift:3:9: error: use of unresolved identifier 'mmsghdr'
let x = mmsghdr()
        ^~~~~~~
SwiftGlibc.cmsghdr:1:15: note: did you mean 'cmsghdr'?
public struct cmsghdr {
              ^
SwiftGlibc.msghdr:1:15: note: did you mean 'msghdr'?
public struct msghdr {
              ^
error: terminated(1): /usr/bin/swift-build-tool -f /code/.build/debug.yaml mmesg.exe

Exploration

The initial problem is that the Swift compiler does not seem to see the structure definitions behind _GNU_SOURCE. You can play about with the Swift program to demonstrate this in a few ways. For example, if you change main.swift to instead call allocateMMsg, you'll find that this works, but Swift returns an OpaquePointer, indicating the compiler does not know the size of the type. If you try to call returnMMsg the Swift compiler will complain that it doesn't know what this function is, indicating that rather than barf on the use of the concrete type it's simply decided to elide the symbol definition altogether.

If you change from calling swift run to swift run -Xcc -D_GNU_SOURCE, the compile will start succeeding and it'll see the type. If you use swift run -Xswiftc -D_GNU_SOURCE the compile will not succeed.

Ramifications

In order to using anything from glibc that is hidden behind _GNU_SOURCE there are only two options. Either have all users pass -Xcc -D_GNU_SOURCE when building the tool, or use a C shim module that never exposes the missing types concretely, either by providing its own types or by forward-declaring them.

This can be done, but it's a substantial annoyance.

More generally, this shows a lack of sane handling of C header files. In this case the ramifications are minor, but with this code it's possible that a C module and its corresponding Swift module may end up disagreeing on the size or memory layout of structures, potentially violating the memory safety that Swift is supposed to provide.