Fast release builds

Dramatically improve the link time in release mode.  Today's MC Hammer Xcode
Voodoo lesson: don't use the slow dsymutil utility; instead, make a "fake"
.dSYM that contains the original unstripped Mach-O file.

Committed: http://src.chromium.org/viewvc/chrome?view=rev&revision=5042

[Mark Mentovai, 2008-11-06 22:38:54]

The added files are the interesting ones.  The project file changes are just to
add script phases to all of our executable targets, the script phases are all
the same and just call strip_from_xcode.

[Amanda Walker, 2008-11-07 02:17:30]

LGTM.  Might not hurt to have someone with python readability take a quick look
at the python scripts.

[Mark Mentovai, 2008-11-07 14:41:48]

Steven, can you take a look at build/mac/strip_save_dsym from a Pythonic
perspective?  Thanks.

[sgk, 2008-11-07 17:57:38]

http://codereview.chromium.org/9659/diff/236/36
File build/mac/strip_save_dsym (right):

http://codereview.chromium.org/9659/diff/236/36#newcode1
Line 1: #!/usr/bin/python
I favor:

#!/usr/bin/env python

To accomodate systems that don't have it installed in /usr/bin/python.  Possibly
moot if this is really a Mac specific script and i'ts okay to count on its
installation in /usr/bin.

http://codereview.chromium.org/9659/diff/236/36#newcode46
Line 46: file_cmd = subprocess.Popen(["/usr/bin/file", "-b", "--", macho],
Good use of "--" here.

I did find an external Python module that can determine file types (using the
libmagic) without invoking an external /usr/bin/file command:

http://pypi.python.org/pypi/python-magic/0.1

If performance is really important here, we could look at incorporating that
into the build, but it would obviously be a little more involved.

http://codereview.chromium.org/9659/diff/236/36#newcode52
Line 52: type_match = re.compile("^Mach-O executable (.*)$").match(type_line)
re.match("^Mach-O executable (.*)$", type_line)

For one-off uses, you don't need to call re.compile() explicitly, just use the
module function.  re.compile() preprocesses the pattern for faster re-use on
multiple searches.

If macho_archs() will be called repeatedly and performance is a concern, compile
the expression as a global and then re-use it

type_match_re = re.compile("^Mach-O executable (.*)$")
def macho_archs(macho):
  type_match = type_match_re.match(type_line)

(Also, .match() implicitly anchors the pattern at beginning of line, so the
initial "^" is unnecessary but doesn't hurt anything.  Personally, I'd leave it
in because I like the explicitness.)

http://codereview.chromium.org/9659/diff/236/36#newcode57
Line 57: type_match = re.compile(
Ditto here for re.compile().

http://codereview.chromium.org/9659/diff/236/36#newcode63
Line 63: arch_match = re.compile(
Ditto here for re.compile() (and for uses below, I won't add a comment for each
separately).

http://codereview.chromium.org/9659/diff/236/36#newcode100
Line 100: break
The "while True" loop idiom here is backwards compatible to old Python versions,
but provided you're only going to be using this with Python 2.3 or later (which
should be the case for our builds), you should just be able to do:

    for otool_line in cmd.stdout:

That should use an iterator to fetch lines from the file object.  (There might
be gotchas trying to use it with a file object returned by subprocess; if it
doesn't seem to work in this case, let me know.)

http://codereview.chromium.org/9659/diff/236/36#newcode262
Line 262: shutil.rmtree(dsym)
Clean up like this is traditionally done in a finally: block so that the cleanup
can occur (avoiding leakage) even if some intervening code throws an exception:

  try:
    # Assume tree removal unless we succeed.
    remove_tree = True
    ...
    strip_cmd = subprocess.Popen(strip_cmdline)
    if strip_cmd.wait() == 0:
      remove_tree = False
  finally:
    if remove_tree:
      shutil.rmtree(dsym)

Or something like that, anyway--obviously

[sgk, 2008-11-07 22:23:46]

lgtm