diff --git a/tools/bugpoint/BugDriver.cpp b/tools/bugpoint/BugDriver.cpp
index 7a3339c..cf7b183 100644
--- a/tools/bugpoint/BugDriver.cpp
+++ b/tools/bugpoint/BugDriver.cpp
@@ -66,12 +66,12 @@
   return Result;
 }
 
-BugDriver::BugDriver(const char *toolname, bool find_bugs,
+BugDriver::BugDriver(const char *toolname, bool as_child, bool find_bugs,
                      unsigned timeout, unsigned memlimit, bool use_valgrind,
                      LLVMContext& ctxt)
   : Context(ctxt), ToolName(toolname), ReferenceOutputFile(OutputFile),
     Program(0), Interpreter(0), SafeInterpreter(0), gcc(0),
-    run_find_bugs(find_bugs), Timeout(timeout), 
+    run_as_child(as_child), run_find_bugs(find_bugs), Timeout(timeout), 
     MemoryLimit(memlimit), UseValgrind(use_valgrind) {}
 
 BugDriver::~BugDriver() {
@@ -119,13 +119,15 @@
   Program = ParseInputFile(Filenames[0], Context);
   if (Program == 0) return true;
     
-  outs() << "Read input file      : '" << Filenames[0] << "'\n";
+  if (!run_as_child)
+    outs() << "Read input file      : '" << Filenames[0] << "'\n";
 
   for (unsigned i = 1, e = Filenames.size(); i != e; ++i) {
     std::auto_ptr<Module> M(ParseInputFile(Filenames[i], Context));
     if (M.get() == 0) return true;
 
-    outs() << "Linking in input file: '" << Filenames[i] << "'\n";
+    if (!run_as_child)
+      outs() << "Linking in input file: '" << Filenames[i] << "'\n";
     std::string ErrorMessage;
     if (Linker::LinkModules(Program, M.get(), &ErrorMessage)) {
       errs() << ToolName << ": error linking in '" << Filenames[i] << "': "
@@ -134,7 +136,8 @@
     }
   }
 
-  outs() << "*** All input ok\n";
+  if (!run_as_child)
+    outs() << "*** All input ok\n";
 
   // All input files read successfully!
   return false;
@@ -146,6 +149,14 @@
 /// variables are set up from command line arguments.
 ///
 bool BugDriver::run(std::string &ErrMsg) {
+  // The first thing to do is determine if we're running as a child. If we are,
+  // then what to do is very narrow. This form of invocation is only called
+  // from the runPasses method to actually run those passes in a child process.
+  if (run_as_child) {
+    // Execute the passes
+    return runPassesAsChild(PassesToRun);
+  }
+  
   if (run_find_bugs) {
     // Rearrange the passes and apply them to the program. Repeat this process
     // until the user kills the program or we find a bug.
diff --git a/tools/bugpoint/BugDriver.h b/tools/bugpoint/BugDriver.h
index 6312ffa..fb5ae29 100644
--- a/tools/bugpoint/BugDriver.h
+++ b/tools/bugpoint/BugDriver.h
@@ -51,6 +51,7 @@
   AbstractInterpreter *Interpreter;   // How to run the program
   AbstractInterpreter *SafeInterpreter;  // To generate reference output, etc.
   GCC *gcc;
+  bool run_as_child;
   bool run_find_bugs;
   unsigned Timeout;
   unsigned MemoryLimit;
@@ -61,7 +62,7 @@
   friend class ReduceMisCodegenFunctions;
 
 public:
-  BugDriver(const char *toolname, bool find_bugs,
+  BugDriver(const char *toolname, bool as_child, bool find_bugs,
             unsigned timeout, unsigned memlimit, bool use_valgrind,
             LLVMContext& ctxt);
   ~BugDriver();
@@ -289,6 +290,9 @@
     return runPasses(M, PassesToRun, Filename, DeleteOutput);
   }
 
+  /// runAsChild - The actual "runPasses" guts that runs in a child process.
+  int runPassesAsChild(const std::vector<const PassInfo*> &PassesToRun);
+
   /// initializeExecutionEnvironment - This method is used to set up the
   /// environment for executing LLVM programs.
   ///
diff --git a/tools/bugpoint/OptimizerDriver.cpp b/tools/bugpoint/OptimizerDriver.cpp
index d83f7f3..a6b90dc 100644
--- a/tools/bugpoint/OptimizerDriver.cpp
+++ b/tools/bugpoint/OptimizerDriver.cpp
@@ -27,7 +27,6 @@
 #include "llvm/Target/TargetData.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/CommandLine.h"
-#include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/System/Path.h"
 #include "llvm/System/Program.h"
@@ -86,6 +85,37 @@
   outs() << getPassesString(PassesToRun) << "\n";
 }
 
+int BugDriver::runPassesAsChild(const std::vector<const PassInfo*> &Passes) {
+  std::string ErrInfo;
+  raw_fd_ostream OutFile(ChildOutput.c_str(), ErrInfo,
+                         raw_fd_ostream::F_Binary);
+  if (!ErrInfo.empty()) {
+    errs() << "Error opening bitcode file: " << ChildOutput << "\n";
+    return 1;
+  }
+
+  PassManager PM;
+  // Make sure that the appropriate target data is always used...
+  PM.add(new TargetData(Program));
+
+  for (unsigned i = 0, e = Passes.size(); i != e; ++i) {
+    if (Passes[i]->getNormalCtor())
+      PM.add(Passes[i]->getNormalCtor()());
+    else
+      errs() << "Cannot create pass yet: " << Passes[i]->getPassName() << "\n";
+  }
+  // Check that the module is well formed on completion of optimization
+  PM.add(createVerifierPass());
+
+  // Write bitcode out to disk as the last step...
+  PM.add(createBitcodeWriterPass(OutFile));
+
+  // Run all queued passes.
+  PM.run(*Program);
+
+  return 0;
+}
+
 cl::opt<bool> SilencePasses("silence-passes", cl::desc("Suppress output of running passes (both stdout and stderr)"));
 
 /// runPasses - Run the specified passes on Program, outputting a bitcode file
@@ -134,25 +164,17 @@
 
   // setup the child process' arguments
   SmallVector<const char*, 8> Args;
-  std::string Opt;
-  llvm::StringRef TN(ToolName);
-  if (TN.find('/') == llvm::StringRef::npos) {
-    Opt = ToolName;
-  } else {
-    std::pair<llvm::StringRef, llvm::StringRef> P = TN.rsplit('/');
-    Opt = P.first.str() + "/" + "opt";
-  }
-
-  sys::Path tool = sys::Program::FindProgramByName(Opt);
+  sys::Path tool = sys::Program::FindProgramByName(ToolName);
   if (UseValgrind) {
     Args.push_back("valgrind");
     Args.push_back("--error-exitcode=1");
     Args.push_back("-q");
     Args.push_back(tool.c_str());
   } else
-    Args.push_back(Opt.c_str());
+    Args.push_back(ToolName);
 
-  Args.push_back("-o");
+  Args.push_back("-as-child");
+  Args.push_back("-child-output");
   Args.push_back(OutputFilename.c_str());
   std::vector<std::string> pass_args;
   for (unsigned i = 0, e = PluginLoader::getNumPlugins(); i != e; ++i) {
@@ -170,12 +192,6 @@
     Args.push_back(*ExtraArgs);
   Args.push_back(0);
 
-  DEBUG(errs() << "\nAbout to run:\t";
-        for (unsigned i = 0, e = Args.size()-1; i != e; ++i)
-          errs() << " " << Args[i];
-        errs() << "\n";
-        );
-
   sys::Path prog;
   if (UseValgrind)
     prog = sys::Program::FindProgramByName("valgrind");
diff --git a/tools/bugpoint/bugpoint.cpp b/tools/bugpoint/bugpoint.cpp
index 41156f9..ba5234b 100644
--- a/tools/bugpoint/bugpoint.cpp
+++ b/tools/bugpoint/bugpoint.cpp
@@ -29,6 +29,13 @@
 #include "llvm/LinkAllVMCore.h"
 using namespace llvm;
 
+// AsChild - Specifies that this invocation of bugpoint is being generated
+// from a parent process. It is not intended to be used by users so the 
+// option is hidden.
+static cl::opt<bool> 
+AsChild("as-child", cl::desc("Run bugpoint as child process"), 
+        cl::ReallyHidden);
+          
 static cl::opt<bool> 
 FindBugs("find-bugs", cl::desc("Run many different optimization sequences "
                                "on program to find bugs"), cl::init(false));
@@ -116,7 +123,7 @@
       MemoryLimit = 100;
   }
 
-  BugDriver D(argv[0], FindBugs, TimeoutValue, MemoryLimit,
+  BugDriver D(argv[0], AsChild, FindBugs, TimeoutValue, MemoryLimit,
               UseValgrind, Context);
   if (D.addSources(InputFilenames)) return 1;