There is a problem with wanting to know a set of objects up front. Larger build systems tend to do a lot of subsystem discovery, and may be well into the build proper before discovery is completed.

And the problem with associating a link with an object file, is that a given object file may have multiple destinations.

Or, yes, a named pipe would work. My main concern with that approach is that it would require bigger changes to the build system.

Also, each of the plural link invocations has its own parameters, which I don’t think you want to smuggle to it via the GCC invocations.

So I’d give gold some sort of –daemon (OK, –concurrent) flag which makes it leave a named pipe that it then listens on. The build system could follow each GCC invocation with an echo to a pipe of the new object file’s name. This (or some similar scheme) allows multiple consumer invocations, all loosely coupled to the set of producers, without having to write new locking and buffering code.

How would the build system know that a link daemon was done? Via a ‘finish’ command?

I don’t know of anybody working on an ARM port yet.

astrange: ZeroLink is different from concurrent linking. ZeroLink postpones the linking until runtime. Concurrent linking does a more-or-less regular link, it just does it at the same time as the compilation.

GCC=gcc
RM=@rm -f
CP=@cp -p
CFLAGS=-O2 -g
LDFLAGS=-lc
CLEAR=@clear
EXT=.x86
RMEXT=*.x86

HAVE_GOLD := $(wildcard /usr/bin/gold)

ifeq ($(strip $(HAVE_GOLD)),)
# Do not create, change only access time (i.e. dummy command harmless)
PRELINK=@touch -c -a
LD=gcc
else
# Gold is present
PRELINK=gold –prelink $(LDFLAGS) -o
LD=gold –postlink
endif

all: a$(EXT) b$(EXT) d$(EXT)
@

clear:
$(CLEAR)

clean:
$(RM) a b d *.o a.out $(RMEXT)

a.o: a.h a.c
@echo “MUST add this line to prelink”
$(PRELINK) a$(EXT) a.o &
$(PRELINK) d$(EXT) d.o &
$(GCC) $(CFLAGS) -c a.c -o a.o

b.o: b.h b.c
@echo “MUST add this line to prelink”
$(PRELINK) b$(EXT) b.o &
$(PRELINK) d$(EXT) d.o &
$(GCC) $(CFLAGS) -c b.c -o b.o

d.o: d.h d.c
@echo “MUST add this line to prelink”
$(PRELINK) d$(EXT) d.o &
$(GCC) $(CFLAGS) -c b.c -o b.o

a$(EXT): a.o
@echo “Wrap up the linking process”
$(LD) $(LDFLAGS) -o a$(EXT) a.o

b$(EXT): b.o
@echo “Wrap up the linking process”
$(LD) $(LDFLAGS) -o b$(EXT) b.o

d$(EXT): a.o b.o d.o
@echo “Wrap up the linking process”
$(LD) $(LDFLAGS) -o d$(EXT) a.o b.o d.o

run: a$(EXT) b$(EXT) d$(EXT)
./a$(EXT)
./b$(EXT)
./d$(EXT)

# make clean clear all run

In this approach you have 3 instance of gold –prelink working on d.x86,
and one final instance doing the last operation,
so some locking/sharing/synchronization will have to be used somehow.
For instance gold –prelink processes could “talk” via a shared file:
d$(EXT).prebuild

Another approach is this:

GCC=gcc
RM=@rm -f
CP=@cp -p
CFLAGS=-O2 -g
LDFLAGS=-lc
CLEAR=@clear
EXT=.x86
RMEXT=*.x86

HAVE_GOLD := $(wildcard /usr/bin/gold)

ifeq ($(strip $(HAVE_GOLD)),)
# Do not create, change only access time (i.e. dummy command harmless)
PRELINK=@touch -c -a
LD=gcc
else
PRELINK=gold –prelink $(LDFLAGS) -o
LD=gold –postlink
endif

all: b$(EXT) d$(EXT)
@

clear:
$(CLEAR)

clean:
$(RM) a b d *.o a.out $(RMEXT)

a.o: a.h a.c
$(GCC) $(CFLAGS) -DNOMAIN -c a.c -o a.o

b.o: b.h b.c
$(GCC) $(CFLAGS) -c b.c -o b.o

d.o: d.h d.c
$(GCC) $(CFLAGS) -c d.c -o d.o

# Add these rules
b$(EXT).prebuild:
@echo “prebuild b”
$(PRELINK) b$(EXT) a.o b.o

d$(EXT).prebuild:
@echo “prebuild d”
$(PRELINK) d$(EXT) a.o d.o

b$(EXT): b$(EXT).prebuild a.o b.o
@echo “Wrap up the linking process”
$(LD) $(LDFLAGS) -o b$(EXT) a.o b.o

d$(EXT): d$(EXT).prebuild a.o d.o
@echo “Wrap up the linking process”
$(LD) $(LDFLAGS) -o d$(EXT) a.o d.o

Now, you have only one gold –prelink that will exits once all files are linked
and dump the results in d$(EXT).prebuild
and gold –postlink finds the d$(EXT).prebuild file
and do the last bit of linking…

Another way even simpler is to have $(LD) do “nothing”,
similar to LD=@touch -c -a
and pass $(LDFLAGS) to $(PRELINK)
but that may be inconvenient,
if the executables do not have the same parameters…

So another way is this, which is easy to script out:

GCC=gcc
RM=@rm -f
CP=@cp -p
CFLAGS=-O2 -g
LDFLAGS=-lc
CLEAR=clear
EXT=.x86
RMEXT=*.x86

HAVE_GOLD := $(wildcard /usr/bin/gold)

# Check if HAVE_GOLD is not found and null
ifeq ($(strip $(HAVE_GOLD)),)
# Returns true and never execute the inner content
PRELINK=@true || (false && echo ”
PRELINKEND=”)
LD=gcc
LDEND=
else
PRELINK=gold –prelink
PRELINKOUT=
LD=@true || (false && echo ”
LDEND=”)
endif

all: b$(EXT) d$(EXT)
@

clear:
$(CLEAR)

clean:
$(RM) a b d *.o a.out $(RMEXT)

a.o: a.h a.c
$(GCC) $(CFLAGS) -DNOMAIN -c a.c -o a.o

b.o: b.h b.c
$(GCC) $(CFLAGS) -c b.c -o b.o

d.o: d.h d.c
$(GCC) $(CFLAGS) -c d.c -o d.o

b.prebuild:
@echo “prebuild b - Copy-paste from below with PRELINK..PRELINKEND prefix/suffix”
$(PRELINK) $(LDFLAGS) -o b$(EXT) a.o b.o $(PRELINKEND)

d.prebuild:
@echo “prebuild d - Copy-paste from below with PRELINK..PRELINKEND prefix/suffix”
$(PRELINK) $(LDFLAGS) -o d$(EXT) a.o d.o $(PRELINKEND)

b$(EXT): b.prebuild a.o b.o
@echo “no post processing”
$(LD) $(LDFLAGS) -o b$(EXT) a.o b.o $(LDEND)

d$(EXT): d.prebuild a.o d.o
@echo “no post processing”
$(LD) $(LDFLAGS) -o d$(EXT) a.o d.o $(LDEND)

It all depends on much work and how much life should be easy
for Makefile maintainers…

My 2 cents.

P.S.: Thanks for sharing gold with the community =)
Anything that can make compilation/linking time smaller
and our life simpler is always appreciated.
I saw MIPS, but is anyone working on having ARM support too?

I’ve actually spent a large chunk of the past week reading the ELF spec so I can improve the version of it I inherited when Fabrice Bellard lost interest in the project (he does QEMU these days). I’m turning it into a busybox-style swiss army knife executable that has various different “cc”, “ld”, “as”, “ar” etc. functions…

I’m also extending it until it can build an unmodified Linux kernel, but there’s rather a lot of work to do before then.