7 files changed, 478 insertions, 428 deletions

diff --git a/contrib/llvm/tools/lto/LTOCodeGenerator.cpp b/contrib/llvm/tools/lto/LTOCodeGenerator.cpp
index 911fddf..671348c 100644
--- a/contrib/llvm/tools/lto/LTOCodeGenerator.cpp
+++ b/contrib/llvm/tools/lto/LTOCodeGenerator.cpp
@@ -119,6 +119,11 @@ bool LTOCodeGenerator::setCodePICModel(lto_codegen_model model,
     return true;
 }
 
+void LTOCodeGenerator::setCpu(const char* mCpu)
+{
+  _mCpu = mCpu;
+}
+
 void LTOCodeGenerator::setAssemblerPath(const char* path)
 {
     if ( _assemblerPath )
@@ -126,6 +131,14 @@ void LTOCodeGenerator::setAssemblerPath(const char* path)
     _assemblerPath = new sys::Path(path);
 }
 
+void LTOCodeGenerator::setAssemblerArgs(const char** args, int nargs)
+{
+  for (int i = 0; i < nargs; ++i) {
+    const char *arg = args[i];
+    _assemblerArgs.push_back(arg);
+  }
+}
+
 void LTOCodeGenerator::addMustPreserveSymbol(const char* sym)
 {
     _mustPreserveSymbols[sym] = 1;
@@ -142,8 +155,8 @@ bool LTOCodeGenerator::writeMergedModules(const char *path,
 
   // create output file
   std::string ErrInfo;
-  raw_fd_ostream Out(path, ErrInfo,
-                     raw_fd_ostream::F_Binary);
+  tool_output_file Out(path, ErrInfo,
+                       raw_fd_ostream::F_Binary);
   if (!ErrInfo.empty()) {
     errMsg = "could not open bitcode file for writing: ";
     errMsg += path;
@@ -151,16 +164,17 @@ bool LTOCodeGenerator::writeMergedModules(const char *path,
   }
     
   // write bitcode to it
-  WriteBitcodeToFile(_linker.getModule(), Out);
-  Out.close();
+  WriteBitcodeToFile(_linker.getModule(), Out.os());
+  Out.os().close();
 
-  if (Out.has_error()) {
+  if (Out.os().has_error()) {
     errMsg = "could not write bitcode file: ";
     errMsg += path;
-    Out.clear_error();
+    Out.os().clear_error();
     return true;
   }
   
+  Out.keep();
   return false;
 }
 
@@ -176,11 +190,16 @@ const void* LTOCodeGenerator::compile(size_t* length, std::string& errMsg)
     // generate assembly code
     bool genResult = false;
     {
-      raw_fd_ostream asmFD(uniqueAsmPath.c_str(), errMsg);
-      formatted_raw_ostream asmFile(asmFD);
+      tool_output_file asmFile(uniqueAsmPath.c_str(), errMsg);
       if (!errMsg.empty())
         return NULL;
-      genResult = this->generateAssemblyCode(asmFile, errMsg);
+      genResult = this->generateAssemblyCode(asmFile.os(), errMsg);
+      asmFile.os().close();
+      if (asmFile.os().has_error()) {
+        asmFile.os().clear_error();
+        return NULL;
+      }
+      asmFile.keep();
     }
     if ( genResult ) {
         uniqueAsmPath.eraseFromDisk();
@@ -257,6 +276,11 @@ bool LTOCodeGenerator::assemble(const std::string& asmPath,
         args.push_back("-c");
         args.push_back("-x");
         args.push_back("assembler");
+    } else {
+        for (std::vector<std::string>::iterator I = _assemblerArgs.begin(),
+               E = _assemblerArgs.end(); I != E; ++I) {
+            args.push_back(I->c_str());
+        }
     }
     args.push_back("-o");
     args.push_back(objPath.c_str());
@@ -301,7 +325,7 @@ bool LTOCodeGenerator::determineTarget(std::string& errMsg)
 
         // construct LTModule, hand over ownership of module and target
         SubtargetFeatures Features;
-        Features.getDefaultSubtargetFeatures("" /* cpu */, llvm::Triple(Triple));
+        Features.getDefaultSubtargetFeatures(_mCpu, llvm::Triple(Triple));
         std::string FeatureStr = Features.getString();
         _target = march->createTargetMachine(Triple, FeatureStr);
     }
@@ -343,7 +367,7 @@ void LTOCodeGenerator::applyScopeRestrictions() {
 }
 
 /// Optimize merged modules using various IPO passes
-bool LTOCodeGenerator::generateAssemblyCode(formatted_raw_ostream& out,
+bool LTOCodeGenerator::generateAssemblyCode(raw_ostream& out,
                                             std::string& errMsg)
 {
     if ( this->determineTarget(errMsg) ) 
@@ -378,7 +402,9 @@ bool LTOCodeGenerator::generateAssemblyCode(formatted_raw_ostream& out,
 
     codeGenPasses->add(new TargetData(*_target->getTargetData()));
 
-    if (_target->addPassesToEmitFile(*codeGenPasses, out,
+    formatted_raw_ostream Out(out);
+
+    if (_target->addPassesToEmitFile(*codeGenPasses, Out,
                                      TargetMachine::CGFT_AssemblyFile,
                                      CodeGenOpt::Aggressive)) {
       errMsg = "target file type not supported";
diff --git a/contrib/llvm/tools/lto/LTOCodeGenerator.h b/contrib/llvm/tools/lto/LTOCodeGenerator.h
index cac3b8c..f5b78a6 100644
--- a/contrib/llvm/tools/lto/LTOCodeGenerator.h
+++ b/contrib/llvm/tools/lto/LTOCodeGenerator.h
@@ -36,14 +36,16 @@ struct LTOCodeGenerator {
     bool                addModule(struct LTOModule*, std::string& errMsg);
     bool                setDebugInfo(lto_debug_model, std::string& errMsg);
     bool                setCodePICModel(lto_codegen_model, std::string& errMsg);
+    void                setCpu(const char *cpu);
     void                setAssemblerPath(const char* path);
+    void                setAssemblerArgs(const char** args, int nargs);
     void                addMustPreserveSymbol(const char* sym);
     bool                writeMergedModules(const char* path, 
                                                            std::string& errMsg);
     const void*         compile(size_t* length, std::string& errMsg);
     void                setCodeGenDebugOptions(const char *opts); 
 private:
-    bool                generateAssemblyCode(llvm::formatted_raw_ostream& out, 
+    bool                generateAssemblyCode(llvm::raw_ostream& out, 
                                              std::string& errMsg);
     bool                assemble(const std::string& asmPath, 
                             const std::string& objPath, std::string& errMsg);
@@ -62,6 +64,8 @@ private:
     llvm::MemoryBuffer*         _nativeObjectFile;
     std::vector<const char*>    _codegenOptions;
     llvm::sys::Path*            _assemblerPath;
+    std::string                 _mCpu;
+    std::vector<std::string>    _assemblerArgs;
 };
 
 #endif // LTO_CODE_GENERATOR_H
diff --git a/contrib/llvm/tools/lto/LTOModule.cpp b/contrib/llvm/tools/lto/LTOModule.cpp
index 0870205..c7cd585 100644
--- a/contrib/llvm/tools/lto/LTOModule.cpp
+++ b/contrib/llvm/tools/lto/LTOModule.cpp
@@ -4,10 +4,10 @@
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
-// 
+//
 //===----------------------------------------------------------------------===//
 //
-// This file implements the Link Time Optimization library. This library is 
+// This file implements the Link Time Optimization library. This library is
 // intended to be used by linker to optimize code at link time.
 //
 //===----------------------------------------------------------------------===//
@@ -36,490 +36,473 @@
 
 using namespace llvm;
 
-bool LTOModule::isBitcodeFile(const void* mem, size_t length)
-{
-    return llvm::sys::IdentifyFileType((char*)mem, length) 
-        == llvm::sys::Bitcode_FileType;
+bool LTOModule::isBitcodeFile(const void *mem, size_t length) {
+  return llvm::sys::IdentifyFileType((char*)mem, length)
+    == llvm::sys::Bitcode_FileType;
 }
 
-bool LTOModule::isBitcodeFile(const char* path)
-{
-    return llvm::sys::Path(path).isBitcodeFile();
+bool LTOModule::isBitcodeFile(const char *path) {
+  return llvm::sys::Path(path).isBitcodeFile();
 }
 
-bool LTOModule::isBitcodeFileForTarget(const void* mem, size_t length,
-                                       const char* triplePrefix) 
-{
-    MemoryBuffer* buffer = makeBuffer(mem, length);
-    if (!buffer)
-        return false;
-    return isTargetMatch(buffer, triplePrefix);
+bool LTOModule::isBitcodeFileForTarget(const void *mem, size_t length,
+                                       const char *triplePrefix) {
+  MemoryBuffer *buffer = makeBuffer(mem, length);
+  if (!buffer)
+    return false;
+  return isTargetMatch(buffer, triplePrefix);
 }
 
 
-bool LTOModule::isBitcodeFileForTarget(const char* path,
-                                       const char* triplePrefix) 
-{
-    MemoryBuffer *buffer = MemoryBuffer::getFile(path);
-    if (buffer == NULL)
-        return false;
-    return isTargetMatch(buffer, triplePrefix);
+bool LTOModule::isBitcodeFileForTarget(const char *path,
+                                       const char *triplePrefix) {
+  MemoryBuffer *buffer = MemoryBuffer::getFile(path);
+  if (buffer == NULL)
+    return false;
+  return isTargetMatch(buffer, triplePrefix);
 }
 
-// takes ownership of buffer
-bool LTOModule::isTargetMatch(MemoryBuffer* buffer, const char* triplePrefix)
-{
-    OwningPtr<Module> m(getLazyBitcodeModule(buffer, getGlobalContext()));
-    // on success, m owns buffer and both are deleted at end of this method
-    if (!m) {
-        delete buffer;
-        return false;
-    }
-    std::string actualTarget = m->getTargetTriple();
-    return (strncmp(actualTarget.c_str(), triplePrefix, 
-                    strlen(triplePrefix)) == 0);
+// Takes ownership of buffer.
+bool LTOModule::isTargetMatch(MemoryBuffer *buffer, const char *triplePrefix) {
+  OwningPtr<Module> m(getLazyBitcodeModule(buffer, getGlobalContext()));
+  // On success, m owns buffer and both are deleted at end of this method.
+  if (!m) {
+    delete buffer;
+    return false;
+  }
+  std::string actualTarget = m->getTargetTriple();
+  return (strncmp(actualTarget.c_str(), triplePrefix,
+                  strlen(triplePrefix)) == 0);
 }
 
 
-LTOModule::LTOModule(Module* m, TargetMachine* t) 
- : _module(m), _target(t), _symbolsParsed(false)
+LTOModule::LTOModule(Module *m, TargetMachine *t)
+  : _module(m), _target(t), _symbolsParsed(false)
 {
 }
 
-LTOModule* LTOModule::makeLTOModule(const char* path,
-                                    std::string& errMsg)
-{
-    OwningPtr<MemoryBuffer> buffer(MemoryBuffer::getFile(path, &errMsg));
-    if (!buffer)
-        return NULL;
-    return makeLTOModule(buffer.get(), errMsg);
+LTOModule *LTOModule::makeLTOModule(const char *path,
+                                    std::string &errMsg) {
+  OwningPtr<MemoryBuffer> buffer(MemoryBuffer::getFile(path, &errMsg));
+  if (!buffer)
+    return NULL;
+  return makeLTOModule(buffer.get(), errMsg);
 }
 
-/// makeBuffer - create a MemoryBuffer from a memory range.
-/// MemoryBuffer requires the byte past end of the buffer to be a zero.
-/// We might get lucky and already be that way, otherwise make a copy.
-/// Also if next byte is on a different page, don't assume it is readable.
-MemoryBuffer* LTOModule::makeBuffer(const void* mem, size_t length)
-{
-    const char *startPtr = (char*)mem;
-    const char *endPtr = startPtr+length;
-    if (((uintptr_t)endPtr & (sys::Process::GetPageSize()-1)) == 0 ||
-        *endPtr != 0) 
-        return MemoryBuffer::getMemBufferCopy(StringRef(startPtr, length));
-  
-    return MemoryBuffer::getMemBuffer(StringRef(startPtr, length));
+/// makeBuffer - Create a MemoryBuffer from a memory range.  MemoryBuffer
+/// requires the byte past end of the buffer to be a zero.  We might get lucky
+/// and already be that way, otherwise make a copy.  Also if next byte is on a
+/// different page, don't assume it is readable.
+MemoryBuffer *LTOModule::makeBuffer(const void *mem, size_t length) {
+  const char *startPtr = (char*)mem;
+  const char *endPtr = startPtr+length;
+  if (((uintptr_t)endPtr & (sys::Process::GetPageSize()-1)) == 0 ||
+      *endPtr != 0)
+    return MemoryBuffer::getMemBufferCopy(StringRef(startPtr, length));
+
+  return MemoryBuffer::getMemBuffer(StringRef(startPtr, length));
 }
 
 
-LTOModule* LTOModule::makeLTOModule(const void* mem, size_t length, 
-                                    std::string& errMsg)
-{
-    OwningPtr<MemoryBuffer> buffer(makeBuffer(mem, length));
-    if (!buffer)
-        return NULL;
-    return makeLTOModule(buffer.get(), errMsg);
+LTOModule *LTOModule::makeLTOModule(const void *mem, size_t length,
+                                    std::string &errMsg) {
+  OwningPtr<MemoryBuffer> buffer(makeBuffer(mem, length));
+  if (!buffer)
+    return NULL;
+  return makeLTOModule(buffer.get(), errMsg);
 }
 
-LTOModule* LTOModule::makeLTOModule(MemoryBuffer* buffer,
-                                    std::string& errMsg)
-{
-    InitializeAllTargets();
-
-    // parse bitcode buffer
-    OwningPtr<Module> m(ParseBitcodeFile(buffer, getGlobalContext(), &errMsg));
-    if (!m)
-        return NULL;
-
-    std::string Triple = m->getTargetTriple();
-    if (Triple.empty())
-      Triple = sys::getHostTriple();
-
-    // find machine architecture for this module
-    const Target* march = TargetRegistry::lookupTarget(Triple, errMsg);
-    if (!march) 
-        return NULL;
-
-    // construct LTModule, hand over ownership of module and target
-    SubtargetFeatures Features;
-    Features.getDefaultSubtargetFeatures("" /* cpu */, llvm::Triple(Triple));
-    std::string FeatureStr = Features.getString();
-    TargetMachine* target = march->createTargetMachine(Triple, FeatureStr);
-    return new LTOModule(m.take(), target);
+LTOModule *LTOModule::makeLTOModule(MemoryBuffer *buffer,
+                                    std::string &errMsg) {
+  InitializeAllTargets();
+
+  // parse bitcode buffer
+  OwningPtr<Module> m(ParseBitcodeFile(buffer, getGlobalContext(), &errMsg));
+  if (!m)
+    return NULL;
+
+  std::string Triple = m->getTargetTriple();
+  if (Triple.empty())
+    Triple = sys::getHostTriple();
+
+  // find machine architecture for this module
+  const Target *march = TargetRegistry::lookupTarget(Triple, errMsg);
+  if (!march)
+    return NULL;
+
+  // construct LTModule, hand over ownership of module and target
+  SubtargetFeatures Features;
+  Features.getDefaultSubtargetFeatures("" /* cpu */, llvm::Triple(Triple));
+  std::string FeatureStr = Features.getString();
+  TargetMachine *target = march->createTargetMachine(Triple, FeatureStr);
+  return new LTOModule(m.take(), target);
 }
 
 
-const char* LTOModule::getTargetTriple()
-{
-    return _module->getTargetTriple().c_str();
+const char *LTOModule::getTargetTriple() {
+  return _module->getTargetTriple().c_str();
 }
 
-void LTOModule::addDefinedFunctionSymbol(Function* f, Mangler &mangler)
-{
-    // add to list of defined symbols
-    addDefinedSymbol(f, mangler, true); 
-
-    // add external symbols referenced by this function.
-    for (Function::iterator b = f->begin(); b != f->end(); ++b) {
-        for (BasicBlock::iterator i = b->begin(); i != b->end(); ++i) {
-            for (unsigned count = 0, total = i->getNumOperands(); 
-                                        count != total; ++count) {
-                findExternalRefs(i->getOperand(count), mangler);
-            }
-        }
-    }
+void LTOModule::setTargetTriple(const char *triple) {
+  _module->setTargetTriple(triple);
 }
 
-// get string that data pointer points to 
-bool LTOModule::objcClassNameFromExpression(Constant* c, std::string& name)
-{
-    if (ConstantExpr* ce = dyn_cast<ConstantExpr>(c)) {
-        Constant* op = ce->getOperand(0);
-        if (GlobalVariable* gvn = dyn_cast<GlobalVariable>(op)) {
-            Constant* cn = gvn->getInitializer(); 
-            if (ConstantArray* ca = dyn_cast<ConstantArray>(cn)) {
-                if (ca->isCString()) {
-                    name = ".objc_class_name_" + ca->getAsString();
-                    return true;
-                }
-            }
-        }
+void LTOModule::addDefinedFunctionSymbol(Function *f, Mangler &mangler) {
+  // add to list of defined symbols
+  addDefinedSymbol(f, mangler, true);
+
+  // add external symbols referenced by this function.
+  for (Function::iterator b = f->begin(); b != f->end(); ++b) {
+    for (BasicBlock::iterator i = b->begin(); i != b->end(); ++i) {
+      for (unsigned count = 0, total = i->getNumOperands();
+           count != total; ++count) {
+        findExternalRefs(i->getOperand(count), mangler);
+      }
     }
-    return false;
+  }
 }
 
-// parse i386/ppc ObjC class data structure 
-void LTOModule::addObjCClass(GlobalVariable* clgv)
-{
-    if (ConstantStruct* c = dyn_cast<ConstantStruct>(clgv->getInitializer())) {
-        // second slot in __OBJC,__class is pointer to superclass name
-        std::string superclassName;
-        if (objcClassNameFromExpression(c->getOperand(1), superclassName)) {
-            NameAndAttributes info;
-            if (_undefines.find(superclassName.c_str()) == _undefines.end()) {
-                const char* symbolName = ::strdup(superclassName.c_str());
-                info.name = ::strdup(symbolName);
-                info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED;
-                // string is owned by _undefines
-                _undefines[info.name] = info;
-            }
+// Get string that data pointer points to.
+bool LTOModule::objcClassNameFromExpression(Constant *c, std::string &name) {
+  if (ConstantExpr *ce = dyn_cast<ConstantExpr>(c)) {
+    Constant *op = ce->getOperand(0);
+    if (GlobalVariable *gvn = dyn_cast<GlobalVariable>(op)) {
+      Constant *cn = gvn->getInitializer();
+      if (ConstantArray *ca = dyn_cast<ConstantArray>(cn)) {
+        if (ca->isCString()) {
+          name = ".objc_class_name_" + ca->getAsString();
+          return true;
         }
-        // third slot in __OBJC,__class is pointer to class name
-        std::string className;
-         if (objcClassNameFromExpression(c->getOperand(2), className)) {
-            const char* symbolName = ::strdup(className.c_str());
-            NameAndAttributes info;
-            info.name = symbolName;
-            info.attributes = (lto_symbol_attributes)
-                (LTO_SYMBOL_PERMISSIONS_DATA |
-                 LTO_SYMBOL_DEFINITION_REGULAR | 
-                 LTO_SYMBOL_SCOPE_DEFAULT);
-            _symbols.push_back(info);
-            _defines[info.name] = 1;
-         }
+      }
     }
+  }
+  return false;
 }
 
-
-// parse i386/ppc ObjC category data structure 
-void LTOModule::addObjCCategory(GlobalVariable* clgv)
-{
-    if (ConstantStruct* c = dyn_cast<ConstantStruct>(clgv->getInitializer())) {
-        // second slot in __OBJC,__category is pointer to target class name
-        std::string targetclassName;
-        if (objcClassNameFromExpression(c->getOperand(1), targetclassName)) {
-            NameAndAttributes info;
-            if (_undefines.find(targetclassName.c_str()) == _undefines.end()) {
-                const char* symbolName = ::strdup(targetclassName.c_str());
-                info.name = ::strdup(symbolName);
-                info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED;
-                // string is owned by _undefines
-               _undefines[info.name] = info;
-            }
-        }
+// Parse i386/ppc ObjC class data structure.
+void LTOModule::addObjCClass(GlobalVariable *clgv) {
+  if (ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer())) {
+    // second slot in __OBJC,__class is pointer to superclass name
+    std::string superclassName;
+    if (objcClassNameFromExpression(c->getOperand(1), superclassName)) {
+      NameAndAttributes info;
+      if (_undefines.find(superclassName.c_str()) == _undefines.end()) {
+        const char *symbolName = ::strdup(superclassName.c_str());
+        info.name = symbolName;
+        info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED;
+        // string is owned by _undefines
+        _undefines[info.name] = info;
+      }
+    }
+    // third slot in __OBJC,__class is pointer to class name
+    std::string className;
+    if (objcClassNameFromExpression(c->getOperand(2), className)) {
+      const char *symbolName = ::strdup(className.c_str());
+      NameAndAttributes info;
+      info.name = symbolName;
+      info.attributes = (lto_symbol_attributes)
+        (LTO_SYMBOL_PERMISSIONS_DATA |
+         LTO_SYMBOL_DEFINITION_REGULAR |
+         LTO_SYMBOL_SCOPE_DEFAULT);
+      _symbols.push_back(info);
+      _defines[info.name] = 1;
     }
+  }
 }
 
 
-// parse i386/ppc ObjC class list data structure 
-void LTOModule::addObjCClassRef(GlobalVariable* clgv)
-{
+// Parse i386/ppc ObjC category data structure.
+void LTOModule::addObjCCategory(GlobalVariable *clgv) {
+  if (ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer())) {
+    // second slot in __OBJC,__category is pointer to target class name
     std::string targetclassName;
-    if (objcClassNameFromExpression(clgv->getInitializer(), targetclassName)) {
-        NameAndAttributes info;
-        if (_undefines.find(targetclassName.c_str()) == _undefines.end()) {
-            const char* symbolName = ::strdup(targetclassName.c_str());
-            info.name = ::strdup(symbolName);
-            info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED;
-            // string is owned by _undefines
-            _undefines[info.name] = info;
-        }
+    if (objcClassNameFromExpression(c->getOperand(1), targetclassName)) {
+      NameAndAttributes info;
+      if (_undefines.find(targetclassName.c_str()) == _undefines.end()) {
+        const char *symbolName = ::strdup(targetclassName.c_str());
+        info.name = symbolName;
+        info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED;
+        // string is owned by _undefines
+        _undefines[info.name] = info;
+      }
     }
+  }
 }
 
 
-void LTOModule::addDefinedDataSymbol(GlobalValue* v, Mangler& mangler)
-{    
-    // add to list of defined symbols
-    addDefinedSymbol(v, mangler, false); 
-
-    // Special case i386/ppc ObjC data structures in magic sections:
-    // The issue is that the old ObjC object format did some strange 
-    // contortions to avoid real linker symbols.  For instance, the 
-    // ObjC class data structure is allocated statically in the executable 
-    // that defines that class.  That data structures contains a pointer to
-    // its superclass.  But instead of just initializing that part of the 
-    // struct to the address of its superclass, and letting the static and 
-    // dynamic linkers do the rest, the runtime works by having that field
-    // instead point to a C-string that is the name of the superclass. 
-    // At runtime the objc initialization updates that pointer and sets 
-    // it to point to the actual super class.  As far as the linker
-    // knows it is just a pointer to a string.  But then someone wanted the 
-    // linker to issue errors at build time if the superclass was not found.  
-    // So they figured out a way in mach-o object format to use an absolute 
-    // symbols (.objc_class_name_Foo = 0) and a floating reference 
-    // (.reference .objc_class_name_Bar) to cause the linker into erroring when
-    // a class was missing.   
-    // The following synthesizes the implicit .objc_* symbols for the linker
-    // from the ObjC data structures generated by the front end.
-    if (v->hasSection() /* && isTargetDarwin */) {
-        // special case if this data blob is an ObjC class definition
-        if (v->getSection().compare(0, 15, "__OBJC,__class,") == 0) {
-            if (GlobalVariable* gv = dyn_cast<GlobalVariable>(v)) {
-                addObjCClass(gv);
-            }
-        }                        
-    
-        // special case if this data blob is an ObjC category definition
-        else if (v->getSection().compare(0, 18, "__OBJC,__category,") == 0) {
-            if (GlobalVariable* gv = dyn_cast<GlobalVariable>(v)) {
-                addObjCCategory(gv);
-            }
-        }                        
-        
-        // special case if this data blob is the list of referenced classes
-        else if (v->getSection().compare(0, 18, "__OBJC,__cls_refs,") == 0) {
-            if (GlobalVariable* gv = dyn_cast<GlobalVariable>(v)) {
-                addObjCClassRef(gv);
-            }
-        }                        
-    }
-
-    // add external symbols referenced by this data.
-    for (unsigned count = 0, total = v->getNumOperands();
-                                                count != total; ++count) {
-        findExternalRefs(v->getOperand(count), mangler);
+// Parse i386/ppc ObjC class list data structure.
+void LTOModule::addObjCClassRef(GlobalVariable *clgv) {
+  std::string targetclassName;
+  if (objcClassNameFromExpression(clgv->getInitializer(), targetclassName)) {
+    NameAndAttributes info;
+    if (_undefines.find(targetclassName.c_str()) == _undefines.end()) {
+      const char *symbolName = ::strdup(targetclassName.c_str());
+      info.name = symbolName;
+      info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED;
+      // string is owned by _undefines
+      _undefines[info.name] = info;
     }
+  }
 }
 
 
-void LTOModule::addDefinedSymbol(GlobalValue* def, Mangler &mangler, 
-                                 bool isFunction)
-{    
-    // ignore all llvm.* symbols
-    if (def->getName().startswith("llvm."))
-        return;
-
-    // string is owned by _defines
-    const char* symbolName = ::strdup(mangler.getNameWithPrefix(def).c_str());
-
-    // set alignment part log2() can have rounding errors
-    uint32_t align = def->getAlignment();
-    uint32_t attr = align ? CountTrailingZeros_32(def->getAlignment()) : 0;
-    
-    // set permissions part
-    if (isFunction)
-        attr |= LTO_SYMBOL_PERMISSIONS_CODE;
-    else {
-        GlobalVariable* gv = dyn_cast<GlobalVariable>(def);
-        if (gv && gv->isConstant())
-            attr |= LTO_SYMBOL_PERMISSIONS_RODATA;
-        else
-            attr |= LTO_SYMBOL_PERMISSIONS_DATA;
-    }
-    
-    // set definition part 
-    if (def->hasWeakLinkage() || def->hasLinkOnceLinkage()) {
-        attr |= LTO_SYMBOL_DEFINITION_WEAK;
-    }
-    else if (def->hasCommonLinkage()) {
-        attr |= LTO_SYMBOL_DEFINITION_TENTATIVE;
+void LTOModule::addDefinedDataSymbol(GlobalValue *v, Mangler &mangler) {
+  // Add to list of defined symbols.
+  addDefinedSymbol(v, mangler, false);
+
+  // Special case i386/ppc ObjC data structures in magic sections:
+  // The issue is that the old ObjC object format did some strange
+  // contortions to avoid real linker symbols.  For instance, the
+  // ObjC class data structure is allocated statically in the executable
+  // that defines that class.  That data structures contains a pointer to
+  // its superclass.  But instead of just initializing that part of the
+  // struct to the address of its superclass, and letting the static and
+  // dynamic linkers do the rest, the runtime works by having that field
+  // instead point to a C-string that is the name of the superclass.
+  // At runtime the objc initialization updates that pointer and sets
+  // it to point to the actual super class.  As far as the linker
+  // knows it is just a pointer to a string.  But then someone wanted the
+  // linker to issue errors at build time if the superclass was not found.
+  // So they figured out a way in mach-o object format to use an absolute
+  // symbols (.objc_class_name_Foo = 0) and a floating reference
+  // (.reference .objc_class_name_Bar) to cause the linker into erroring when
+  // a class was missing.
+  // The following synthesizes the implicit .objc_* symbols for the linker
+  // from the ObjC data structures generated by the front end.
+  if (v->hasSection() /* && isTargetDarwin */) {
+    // special case if this data blob is an ObjC class definition
+    if (v->getSection().compare(0, 15, "__OBJC,__class,") == 0) {
+      if (GlobalVariable *gv = dyn_cast<GlobalVariable>(v)) {
+        addObjCClass(gv);
+      }
     }
-    else { 
-        attr |= LTO_SYMBOL_DEFINITION_REGULAR;
+
+    // special case if this data blob is an ObjC category definition
+    else if (v->getSection().compare(0, 18, "__OBJC,__category,") == 0) {
+      if (GlobalVariable *gv = dyn_cast<GlobalVariable>(v)) {
+        addObjCCategory(gv);
+      }
     }
-    
-    // set scope part
-    if (def->hasHiddenVisibility())
-        attr |= LTO_SYMBOL_SCOPE_HIDDEN;
-    else if (def->hasProtectedVisibility())
-        attr |= LTO_SYMBOL_SCOPE_PROTECTED;
-    else if (def->hasExternalLinkage() || def->hasWeakLinkage()
-             || def->hasLinkOnceLinkage() || def->hasCommonLinkage())
-        attr |= LTO_SYMBOL_SCOPE_DEFAULT;
-    else
-        attr |= LTO_SYMBOL_SCOPE_INTERNAL;
 
-    // add to table of symbols
-    NameAndAttributes info;
-    info.name = symbolName;
-    info.attributes = (lto_symbol_attributes)attr;
-    _symbols.push_back(info);
-    _defines[info.name] = 1;
-}
+    // special case if this data blob is the list of referenced classes
+    else if (v->getSection().compare(0, 18, "__OBJC,__cls_refs,") == 0) {
+      if (GlobalVariable *gv = dyn_cast<GlobalVariable>(v)) {
+        addObjCClassRef(gv);
+      }
+    }
+  }
 
-void LTOModule::addAsmGlobalSymbol(const char *name) {
-    // only add new define if not already defined
-    if (_defines.count(name) == 0) 
-        return;
-        
-    // string is owned by _defines
-    const char *symbolName = ::strdup(name);
-    uint32_t attr = LTO_SYMBOL_DEFINITION_REGULAR;
-    attr |= LTO_SYMBOL_SCOPE_DEFAULT;
-    NameAndAttributes info;
-    info.name = symbolName;
-    info.attributes = (lto_symbol_attributes)attr;
-    _symbols.push_back(info);
-    _defines[info.name] = 1;
+  // add external symbols referenced by this data.
+  for (unsigned count = 0, total = v->getNumOperands();
+       count != total; ++count) {
+    findExternalRefs(v->getOperand(count), mangler);
+  }
 }
 
-void LTOModule::addPotentialUndefinedSymbol(GlobalValue* decl, Mangler &mangler)
-{   
-    // ignore all llvm.* symbols
-    if (decl->getName().startswith("llvm."))
-        return;
 
-    // ignore all aliases
-    if (isa<GlobalAlias>(decl))
-        return;
+void LTOModule::addDefinedSymbol(GlobalValue *def, Mangler &mangler,
+                                 bool isFunction) {
+  // ignore all llvm.* symbols
+  if (def->getName().startswith("llvm."))
+    return;
 
-    std::string name = mangler.getNameWithPrefix(decl);
+  // string is owned by _defines
+  const char *symbolName = ::strdup(mangler.getNameWithPrefix(def).c_str());
 
-    // we already have the symbol
-    if (_undefines.find(name) != _undefines.end())
-      return;
+  // set alignment part log2() can have rounding errors
+  uint32_t align = def->getAlignment();
+  uint32_t attr = align ? CountTrailingZeros_32(def->getAlignment()) : 0;
 
-    NameAndAttributes info;
-    // string is owned by _undefines
-    info.name = ::strdup(name.c_str());
-    if (decl->hasExternalWeakLinkage())
-      info.attributes = LTO_SYMBOL_DEFINITION_WEAKUNDEF;
+  // set permissions part
+  if (isFunction)
+    attr |= LTO_SYMBOL_PERMISSIONS_CODE;
+  else {
+    GlobalVariable *gv = dyn_cast<GlobalVariable>(def);
+    if (gv && gv->isConstant())
+      attr |= LTO_SYMBOL_PERMISSIONS_RODATA;
     else
-      info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED;
-    _undefines[name] = info;
+      attr |= LTO_SYMBOL_PERMISSIONS_DATA;
+  }
+
+  // set definition part
+  if (def->hasWeakLinkage() || def->hasLinkOnceLinkage()) {
+    attr |= LTO_SYMBOL_DEFINITION_WEAK;
+  }
+  else if (def->hasCommonLinkage()) {
+    attr |= LTO_SYMBOL_DEFINITION_TENTATIVE;
+  }
+  else {
+    attr |= LTO_SYMBOL_DEFINITION_REGULAR;
+  }
+
+  // set scope part
+  if (def->hasHiddenVisibility())
+    attr |= LTO_SYMBOL_SCOPE_HIDDEN;
+  else if (def->hasProtectedVisibility())
+    attr |= LTO_SYMBOL_SCOPE_PROTECTED;
+  else if (def->hasExternalLinkage() || def->hasWeakLinkage()
+           || def->hasLinkOnceLinkage() || def->hasCommonLinkage())
+    attr |= LTO_SYMBOL_SCOPE_DEFAULT;
+  else
+    attr |= LTO_SYMBOL_SCOPE_INTERNAL;
+
+  // add to table of symbols
+  NameAndAttributes info;
+  info.name = symbolName;
+  info.attributes = (lto_symbol_attributes)attr;
+  _symbols.push_back(info);
+  _defines[info.name] = 1;
 }
 
+void LTOModule::addAsmGlobalSymbol(const char *name) {
+  // only add new define if not already defined
+  if (_defines.count(name))
+    return;
+
+  // string is owned by _defines
+  const char *symbolName = ::strdup(name);
+  uint32_t attr = LTO_SYMBOL_DEFINITION_REGULAR;
+  attr |= LTO_SYMBOL_SCOPE_DEFAULT;
+  NameAndAttributes info;
+  info.name = symbolName;
+  info.attributes = (lto_symbol_attributes)attr;
+  _symbols.push_back(info);
+  _defines[info.name] = 1;
+}
 
+void LTOModule::addPotentialUndefinedSymbol(GlobalValue *decl,
+                                            Mangler &mangler) {
+  // ignore all llvm.* symbols
+  if (decl->getName().startswith("llvm."))
+    return;
+
+  // ignore all aliases
+  if (isa<GlobalAlias>(decl))
+    return;
+
+  std::string name = mangler.getNameWithPrefix(decl);
+
+  // we already have the symbol
+  if (_undefines.find(name) != _undefines.end())
+    return;
+
+  NameAndAttributes info;
+  // string is owned by _undefines
+  info.name = ::strdup(name.c_str());
+  if (decl->hasExternalWeakLinkage())
+    info.attributes = LTO_SYMBOL_DEFINITION_WEAKUNDEF;
+  else
+    info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED;
+  _undefines[name] = info;
+}
 
-// Find external symbols referenced by VALUE. This is a recursive function.
-void LTOModule::findExternalRefs(Value* value, Mangler &mangler) {
-
-    if (GlobalValue* gv = dyn_cast<GlobalValue>(value)) {
-        if (!gv->hasExternalLinkage())
-            addPotentialUndefinedSymbol(gv, mangler);
-        // If this is a variable definition, do not recursively process
-        // initializer.  It might contain a reference to this variable
-        // and cause an infinite loop.  The initializer will be
-        // processed in addDefinedDataSymbol(). 
-        return;
-    }
 
-    // GlobalValue, even with InternalLinkage type, may have operands with 
-    // ExternalLinkage type. Do not ignore these operands.
-    if (Constant* c = dyn_cast<Constant>(value)) {
-        // Handle ConstantExpr, ConstantStruct, ConstantArry etc.
-        for (unsigned i = 0, e = c->getNumOperands(); i != e; ++i)
-            findExternalRefs(c->getOperand(i), mangler);
-    }
+
+// Find external symbols referenced by VALUE. This is a recursive function.
+void LTOModule::findExternalRefs(Value *value, Mangler &mangler) {
+  if (GlobalValue *gv = dyn_cast<GlobalValue>(value)) {
+    if (!gv->hasExternalLinkage())
+      addPotentialUndefinedSymbol(gv, mangler);
+    // If this is a variable definition, do not recursively process
+    // initializer.  It might contain a reference to this variable
+    // and cause an infinite loop.  The initializer will be
+    // processed in addDefinedDataSymbol().
+    return;
+  }
+
+  // GlobalValue, even with InternalLinkage type, may have operands with
+  // ExternalLinkage type. Do not ignore these operands.
+  if (Constant *c = dyn_cast<Constant>(value)) {
+    // Handle ConstantExpr, ConstantStruct, ConstantArry etc.
+    for (unsigned i = 0, e = c->getNumOperands(); i != e; ++i)
+      findExternalRefs(c->getOperand(i), mangler);
+  }
 }
 
-void LTOModule::lazyParseSymbols()
-{
-    if (!_symbolsParsed) {
-        _symbolsParsed = true;
-        
-        // Use mangler to add GlobalPrefix to names to match linker names.
-        MCContext Context(*_target->getMCAsmInfo());
-        Mangler mangler(Context, *_target->getTargetData());
-
-        // add functions
-        for (Module::iterator f = _module->begin(); f != _module->end(); ++f) {
-            if (f->isDeclaration())
-                addPotentialUndefinedSymbol(f, mangler);
-            else 
-                addDefinedFunctionSymbol(f, mangler);
-        }
-        
-        // add data 
-        for (Module::global_iterator v = _module->global_begin(), 
-                                    e = _module->global_end(); v !=  e; ++v) {
-            if (v->isDeclaration())
-                addPotentialUndefinedSymbol(v, mangler);
-            else 
-                addDefinedDataSymbol(v, mangler);
-        }
+void LTOModule::lazyParseSymbols() {
+  if (_symbolsParsed)
+    return;
 
-        // add asm globals
-        const std::string &inlineAsm = _module->getModuleInlineAsm();
-        const std::string glbl = ".globl";
-        std::string asmSymbolName;
-        std::string::size_type pos = inlineAsm.find(glbl, 0);
-        while (pos != std::string::npos) {
-          // eat .globl
-          pos = pos + 6;
-
-          // skip white space between .globl and symbol name
-          std::string::size_type pbegin = inlineAsm.find_first_not_of(' ', pos);
-          if (pbegin == std::string::npos)
-            break;
-
-          // find end-of-line
-          std::string::size_type pend = inlineAsm.find_first_of('\n', pbegin);
-          if (pend == std::string::npos)
-            break;
-
-          asmSymbolName.assign(inlineAsm, pbegin, pend - pbegin);
-          addAsmGlobalSymbol(asmSymbolName.c_str());
-
-          // search next .globl
-          pos = inlineAsm.find(glbl, pend);
-        }
+  _symbolsParsed = true;
 
-        // make symbols for all undefines
-        for (StringMap<NameAndAttributes>::iterator it=_undefines.begin(); 
-                                                it != _undefines.end(); ++it) {
-            // if this symbol also has a definition, then don't make an undefine
-            // because it is a tentative definition
-            if (_defines.count(it->getKey()) == 0) {
-              NameAndAttributes info = it->getValue();
-              _symbols.push_back(info);
-            }
-        }
-    }    
+  // Use mangler to add GlobalPrefix to names to match linker names.
+  MCContext Context(*_target->getMCAsmInfo());
+  Mangler mangler(Context, *_target->getTargetData());
+
+  // add functions
+  for (Module::iterator f = _module->begin(); f != _module->end(); ++f) {
+    if (f->isDeclaration())
+      addPotentialUndefinedSymbol(f, mangler);
+    else
+      addDefinedFunctionSymbol(f, mangler);
+  }
+
+  // add data
+  for (Module::global_iterator v = _module->global_begin(),
+         e = _module->global_end(); v !=  e; ++v) {
+    if (v->isDeclaration())
+      addPotentialUndefinedSymbol(v, mangler);
+    else
+      addDefinedDataSymbol(v, mangler);
+  }
+
+  // add asm globals
+  const std::string &inlineAsm = _module->getModuleInlineAsm();
+  const std::string glbl = ".globl";
+  std::string asmSymbolName;
+  std::string::size_type pos = inlineAsm.find(glbl, 0);
+  while (pos != std::string::npos) {
+    // eat .globl
+    pos = pos + 6;
+
+    // skip white space between .globl and symbol name
+    std::string::size_type pbegin = inlineAsm.find_first_not_of(' ', pos);
+    if (pbegin == std::string::npos)
+      break;
+
+    // find end-of-line
+    std::string::size_type pend = inlineAsm.find_first_of('\n', pbegin);
+    if (pend == std::string::npos)
+      break;
+
+    asmSymbolName.assign(inlineAsm, pbegin, pend - pbegin);
+    addAsmGlobalSymbol(asmSymbolName.c_str());
+
+    // search next .globl
+    pos = inlineAsm.find(glbl, pend);
+  }
+
+  // make symbols for all undefines
+  for (StringMap<NameAndAttributes>::iterator it=_undefines.begin();
+       it != _undefines.end(); ++it) {
+    // if this symbol also has a definition, then don't make an undefine
+    // because it is a tentative definition
+    if (_defines.count(it->getKey()) == 0) {
+      NameAndAttributes info = it->getValue();
+      _symbols.push_back(info);
+    }
+  }
 }
 
 
-uint32_t LTOModule::getSymbolCount()
-{
-    lazyParseSymbols();
-    return _symbols.size();
+uint32_t LTOModule::getSymbolCount() {
+  lazyParseSymbols();
+  return _symbols.size();
 }
 
 
-lto_symbol_attributes LTOModule::getSymbolAttributes(uint32_t index)
-{
-    lazyParseSymbols();
-    if (index < _symbols.size())
-        return _symbols[index].attributes;
-    else
-        return lto_symbol_attributes(0);
+lto_symbol_attributes LTOModule::getSymbolAttributes(uint32_t index) {
+  lazyParseSymbols();
+  if (index < _symbols.size())
+    return _symbols[index].attributes;
+  else
+    return lto_symbol_attributes(0);
 }
 
-const char* LTOModule::getSymbolName(uint32_t index)
-{
-    lazyParseSymbols();
-    if (index < _symbols.size())
-        return _symbols[index].name;
-    else
-        return NULL;
+const char *LTOModule::getSymbolName(uint32_t index) {
+  lazyParseSymbols();
+  if (index < _symbols.size())
+    return _symbols[index].name;
+  else
+    return NULL;
 }
diff --git a/contrib/llvm/tools/lto/LTOModule.h b/contrib/llvm/tools/lto/LTOModule.h
index 7f475d4..a19acc0 100644
--- a/contrib/llvm/tools/lto/LTOModule.h
+++ b/contrib/llvm/tools/lto/LTOModule.h
@@ -55,6 +55,7 @@ struct LTOModule {
                                            std::string& errMsg);
 
     const char*              getTargetTriple();
+    void                     setTargetTriple(const char*);
     uint32_t                 getSymbolCount();
     lto_symbol_attributes    getSymbolAttributes(uint32_t index);
     const char*              getSymbolName(uint32_t index);
diff --git a/contrib/llvm/tools/lto/Makefile b/contrib/llvm/tools/lto/Makefile
index 8d57333..e157a4c 100644
--- a/contrib/llvm/tools/lto/Makefile
+++ b/contrib/llvm/tools/lto/Makefile
@@ -25,15 +25,22 @@ LINK_COMPONENTS := $(TARGETS_TO_BUILD) ipo scalaropts linker bitreader bitwriter
 include $(LEVEL)/Makefile.common
 
 ifeq ($(HOST_OS),Darwin)
+    # Special hack to allow libLTO to have an offset version number.
+    ifdef LLVM_LTO_VERSION_OFFSET
+        LTO_LIBRARY_VERSION := $(shell expr $(LLVM_SUBMIT_VERSION) + \
+                                            $(LLVM_LTO_VERSION_OFFSET))
+    else
+        LTO_LIBRARY_VERSION := $(LLVM_SUBMIT_VERSION)
+    endif
+
     # set dylib internal version number to llvmCore submission number
     ifdef LLVM_SUBMIT_VERSION
         LLVMLibsOptions := $(LLVMLibsOptions) -Wl,-current_version \
-                        -Wl,$(LLVM_SUBMIT_VERSION).$(LLVM_SUBMIT_SUBVERSION) \
+                        -Wl,$(LTO_LIBRARY_VERSION).$(LLVM_SUBMIT_SUBVERSION) \
                         -Wl,-compatibility_version -Wl,1
     endif
     # extra options to override libtool defaults 
     LLVMLibsOptions    := $(LLVMLibsOptions)  \
-                         -avoid-version \
                          -Wl,-dead_strip \
                          -Wl,-seg1addr -Wl,0xE0000000 
 
@@ -41,7 +48,7 @@ ifeq ($(HOST_OS),Darwin)
     DARWIN_VERS := $(shell echo $(TARGET_TRIPLE) | sed 's/.*darwin\([0-9]*\).*/\1/')
     ifneq ($(DARWIN_VERS),8)
        LLVMLibsOptions    := $(LLVMLibsOptions)  \
-                            -no-undefined -Wl,-install_name \
+                            -Wl,-install_name \
                             -Wl,"@executable_path/../lib/lib$(LIBRARYNAME)$(SHLIBEXT)"
     endif
 endif
diff --git a/contrib/llvm/tools/lto/lto.cpp b/contrib/llvm/tools/lto/lto.cpp
index cc841bd..3d7ef0a 100644
--- a/contrib/llvm/tools/lto/lto.cpp
+++ b/contrib/llvm/tools/lto/lto.cpp
@@ -120,6 +120,14 @@ const char* lto_module_get_target_triple(lto_module_t mod)
     return mod->getTargetTriple();
 }
 
+//
+// sets triple string with which the object will be codegened.
+//
+void lto_module_set_target_triple(lto_module_t mod, const char *triple)
+{
+    return mod->setTargetTriple(triple);
+}
+
 
 //
 // returns the number of symbols in the object module
@@ -142,7 +150,7 @@ const char* lto_module_get_symbol_name(lto_module_t mod, uint32_t index)
 // returns the attributes of the ith symbol in the object module
 //
 lto_symbol_attributes lto_module_get_symbol_attribute(lto_module_t mod, 
-                                                            uint32_t index)
+                                                      uint32_t index)
 {
     return mod->getSymbolAttributes(index);
 }
@@ -203,6 +211,14 @@ bool lto_codegen_set_pic_model(lto_code_gen_t cg, lto_codegen_model model)
 }
 
 //
+// sets the cpu to generate code for
+//
+void lto_codegen_set_cpu(lto_code_gen_t cg, const char* cpu)
+{
+  return cg->setCpu(cpu);
+}
+
+//
 // sets the path to the assembler tool
 //
 void lto_codegen_set_assembler_path(lto_code_gen_t cg, const char* path)
@@ -210,6 +226,16 @@ void lto_codegen_set_assembler_path(lto_code_gen_t cg, const char* path)
     cg->setAssemblerPath(path);
 }
 
+
+//
+// sets extra arguments that libLTO should pass to the assembler
+//
+void lto_codegen_set_assembler_args(lto_code_gen_t cg, const char** args,
+                                    int nargs)
+{
+  cg->setAssemblerArgs(args, nargs);
+}
+
 //
 // adds to a list of all global symbols that must exist in the final
 // generated code.  If a function is not listed there, it might be
diff --git a/contrib/llvm/tools/lto/lto.exports b/contrib/llvm/tools/lto/lto.exports
index 9011cf6..4dbf760 100644
--- a/contrib/llvm/tools/lto/lto.exports
+++ b/contrib/llvm/tools/lto/lto.exports
@@ -6,6 +6,7 @@ lto_module_get_num_symbols
 lto_module_get_symbol_attribute
 lto_module_get_symbol_name
 lto_module_get_target_triple
+lto_module_set_target_triple
 lto_module_is_object_file
 lto_module_is_object_file_for_target
 lto_module_is_object_file_in_memory
@@ -20,4 +21,6 @@ lto_codegen_set_debug_model
 lto_codegen_set_pic_model
 lto_codegen_write_merged_modules
 lto_codegen_debug_options
+lto_codegen_set_assembler_args
 lto_codegen_set_assembler_path
+lto_codegen_set_cpu