trouble building universal binary with autotools

Question

I have a project that I'm building on OS X using autotools. I'd like to build a universal binary, but putting multiple -arch options in OBJCFLAGS conflicts with gcc's -M (which automake uses for dependency tracking). I can see a couple workarounds, but none seems straightforward.

Is there a way to force preprocessing to be separate from compilation (so -M is given to CPP, while -arch is handed to OBJC)?

I can see that automake supports options for disabling dependency tracking, and enabling it when it can't be done as a side-effect. Is there a way to force the use of the older style of tracking even when the side-effect based tracking is available?

I don't have any experience with lipo. Is there a good way to tie it into the autotools work flow?

Answer 1

This Apple Technical Note looks promising, but it's something I haven't done. I would think you'd only need to do a universal build when preparing a release, so perhaps you can do without dependency tracking?

Answer 2

There's a few solutions here; and likely one that has evaded me.

1. The easiest and fastest is to add --disable-dependency-tracking to your run of ./configure.

   This will tell it not to generate dependencies at all. The dependency phase is what's killing you because the -M dependency options are being used during code generation; which can't be done if there are multiple architectures being targetted.

   So this is 'fine' if you are doing a clean build on someone else's package; or you don't mind doing a 'make clean' before each build. If you are hacking at the source, especially header files, this is no good as make probably won't know what to rebuild and will leave you with stale binaries.

2. Better, but more dangerous is to do something like:

   CC=clang CXX=clang++ ./configure

   This will make the compiler clang instead of gcc. You have clang if you have a recent Xcode. Configure will realize that clang meets the compilation requirements, but will also decide that it isn't safe for auto-dependency generation. Instead of disabling auto dependency gen, it will do old-style 2 pass generation.

   One caveat: This may or may not work as I described depending on how you set your architecture flags. If you have flags you want to pass to all compiler invocations (i.e.: -I for include paths), you should set CPPFLAGS. For code generation, set CFLAGS and CXXFLAGS for C and C++, (and I suppose COBJFLAGS for ObjC). Typically you would add $CPPFLAGS to those. I typically whip up a shell script something like:

   #!/bin/bash
   
   export CC=clang
   export CXX=clang
   
   export CPPFLAGS="-isysroot /Developer/SDKs/MacOSX10.5.sdk -mmacosx-version-min=10.5 -fvisibility=hidden"
   export CFLAGS="-arch i386 -arch x86_64 -O3 -fomit-frame-pointer -momit-leaf-frame-pointer -ffast-math $CPPFLAGS"
   export CXXFLAGS=$CFLAGS
   
   ./configure
   

   You probably don't want these exact flags, but it should get you the idea.

3. lipo. You've been down this road it sounds like. I've found the best way is as follows:

   a. Make top level directories like .X86_64 and .i386. Note the '.' in front. If you target a build into the source directories it usually needs to start with a dot to avoid screwing up 'make clean' later.

   b. Run ./configure with something like: --prefix=`pwd`/.i386` and however you set the architecture (in this case to i386).

   c. Do the make, and make install, and assuming it all went well make clean and make sure the stuff is still in .i386 Repeat for each architecture. The make clean at the end of each phase is pretty important as the reconfig may change what gets cleaned and you really want to make sure you don't pollute an architecture with old architecture files.

   d. Assuming you have all your builds the way you want, I usually make a shell script that looks and feels something like this to run at the end that will lipo things up for you.

   # move the working builds for posterity and debugging
   mv .i386 ./Build/i386
   mv .x86_64 ./Build/x86_64
   
   for path in ./Build/i386/lib/*
   do
       file=${path##*/}
       # only convert 'real' files                                                                                                   
       if [ -f "$file" -a ! -L "$file" ]; then
           partner="./Build/x86_64/Lib/$file"
           if [ -f $partner -a ! -L $partner ]; then
               target="./Build/Lib/$file"
               lipo -create "$file" "$partner" -output "$target" || { echo "Lipo failed to get phat"; exit 5; }
               echo Universal Binary Created: $target
           else
               echo Skipping: $file, no valid architecture pairing at: $partner
           fi
       else
           # this is a pretty common case, openssl creates symlinks                                                                  
           # echo Skipping: $file, NOT a regular file                                                                                
           true
       fi
   done
   

4. What I have NOT figured out is the magic that would let me use gcc, and old school 2-pass dep gen. Frankly I care less and less each day as I become more and more impressed with clang/llvm.

Good luck!