--- /dev/null
+/* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
+ *
+ * Copyright (c) 2006-2008 Apple Inc. All rights reserved.
+ *
+ * @APPLE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this
+ * file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_LICENSE_HEADER_END@
+ */
+
+#ifndef __LTO_READER_H__
+#define __LTO_READER_H__
+
+#include <stdlib.h>
+#include <mach-o/dyld.h>
+#include <vector>
+#include <ext/hash_set>
+#include <ext/hash_map>
+
+#include "MachOFileAbstraction.hpp"
+#include "Architectures.hpp"
+#include "ObjectFile.h"
+#include "Options.h"
+
+#include "llvm-c/lto.h"
+
+
+namespace lto {
+
+
+//
+// Reference handles Atom references. These references facilitate
+// symbol resolution.
+//
+
+class Reference : public ObjectFile::Reference
+{
+public:
+ Reference(const char* name) : fTargetName(name), fTargetAtom(NULL) { }
+ Reference(ObjectFile::Atom& atom) : fTargetName(NULL), fTargetAtom(&atom) { }
+
+ bool isTargetUnbound() const { return fTargetAtom == NULL; }
+ bool isFromTargetUnbound() const { return true; }
+ uint8_t getKind() const { return 0; }
+ uint64_t getFixUpOffset() const { return 0; }
+ const char * getTargetName() const { return fTargetName; }
+ ObjectFile::Atom& getTarget() const { return *fTargetAtom; }
+ uint64_t getTargetOffset() const { return 0; }
+ bool hasFromTarget() const { return false; }
+ ObjectFile::Atom& getFromTarget() const { return *((ObjectFile::Atom*)NULL); }
+ const char * getFromTargetName() const { return NULL; }
+ uint64_t getFromTargetOffset() const { return 0; }
+ TargetBinding getTargetBinding() const;
+ TargetBinding getFromTargetBinding() const { return kDontBind; }
+ void setTarget (ObjectFile::Atom& a, uint64_t offset)
+ { fTargetAtom = &a; }
+ void setFromTarget(ObjectFile::Atom &a) { }
+ const char * getDescription() const;
+
+private:
+ const char * fTargetName;
+ ObjectFile::Atom * fTargetAtom;
+};
+
+
+ObjectFile::Reference::TargetBinding Reference::getTargetBinding() const
+{
+ if ( fTargetAtom == NULL )
+ return kUnboundByName;
+ else if ( fTargetName == NULL )
+ return kBoundDirectly;
+ else
+ return kBoundByName;
+}
+
+const char* Reference::getDescription() const
+{
+ static char temp[256];
+ strcpy(temp, "reference to ");
+ if ( fTargetName != NULL )
+ strcat(temp, fTargetName);
+ else
+ strcat(temp, fTargetAtom->getDisplayName());
+ return temp;
+}
+
+
+class Segment : public ObjectFile::Segment
+{
+public:
+ Segment(const char* name, bool readable, bool writable, bool executable, bool fixedAddress)
+ : fName(name), fReadable(readable), fWritable(writable), fExecutable(executable), fFixedAddress(fixedAddress) {}
+ virtual const char* getName() const { return fName; }
+ virtual bool isContentReadable() const { return fReadable; }
+ virtual bool isContentWritable() const { return fWritable; }
+ virtual bool isContentExecutable() const { return fExecutable; }
+ virtual bool hasFixedAddress() const { return fFixedAddress; }
+
+ static Segment fgBootstrapSegment;
+
+private:
+ const char* fName;
+ const bool fReadable;
+ const bool fWritable;
+ const bool fExecutable;
+ const bool fFixedAddress;
+};
+
+Segment Segment:: fgBootstrapSegment("__TEMP", true, false, false, false);
+
+
+
+
+//
+// Atom acts as a proxy Atom for the symbols that are exported by LLVM bitcode file. Initially,
+// Reader creates Atoms to allow linker proceed with usual symbol resolution phase. After
+// optimization is performed, real Atoms are created for these symobls. However these real Atoms
+// are not inserted into global symbol table. Atom holds real Atom and forwards appropriate
+// methods to real atom.
+//
+class Atom : public ObjectFile::Atom
+{
+public:
+ Atom(class Reader& owner, const char* name, Scope, DefinitionKind, uint8_t alignment, ObjectFile::Atom& internalAtom);
+
+ ObjectFile::Reader* getFile() const { return (ObjectFile::Reader*)&fOwner; }
+ bool getTranslationUnitSource (const char **dir, const char **name) const
+ { return fRealAtom->getTranslationUnitSource(dir, name); }
+ const char * getName () const { return fName; }
+ const char * getDisplayName() const { return this->getName(); }
+ Scope getScope() const { return fScope; }
+ DefinitionKind getDefinitionKind() const { return (fRealAtom ? fRealAtom->getDefinitionKind() : fKind); }
+ SymbolTableInclusion getSymbolTableInclusion() const
+ { return fRealAtom->getSymbolTableInclusion(); }
+ bool dontDeadStrip() const { return false; }
+ bool isZeroFill() const { return (fRealAtom ? fRealAtom->isZeroFill() : false); }
+ bool isThumb() const { return false; }
+ uint64_t getSize() const { return (fRealAtom ? fRealAtom->getSize() : 0); }
+ std::vector<ObjectFile::Reference*>& getReferences() const
+ { return (fRealAtom ? fRealAtom->getReferences() : (std::vector<ObjectFile::Reference*>&)fReferences); }
+ bool mustRemainInSection() const { return fRealAtom->mustRemainInSection(); }
+ const char * getSectionName() const { return (fRealAtom ? fRealAtom->getSectionName() : NULL); }
+ // Linker::optimize() sets section for this atom, not fRealAtom. Use this Atom's fSection.
+ class ObjectFile::Section * getSection() const { return fSection; }
+ ObjectFile::Segment& getSegment() const { return (fRealAtom ? fRealAtom->getSegment() : Segment::fgBootstrapSegment); }
+ uint32_t getOrdinal() const { return (fRealAtom ? fRealAtom->getOrdinal() : 0); }
+ ObjectFile::Atom& getFollowOnAtom() const { return fRealAtom->getFollowOnAtom(); }
+ std::vector<ObjectFile::LineInfo>* getLineInfo() const { return (fRealAtom ? fRealAtom->getLineInfo() : NULL); }
+ ObjectFile::Alignment getAlignment() const { return (fRealAtom ? fRealAtom->getAlignment() : ObjectFile::Alignment(fAlignment)); }
+ void copyRawContent(uint8_t buffer[]) const
+ { if (fRealAtom) fRealAtom->copyRawContent(buffer); }
+ void setScope(Scope s) { if (fRealAtom) fRealAtom->setScope(s); else fScope = s; }
+
+ void setRealAtom (ObjectFile::Atom *atom)
+ { fRealAtom = atom; }
+ ObjectFile::Atom * getRealAtom() { return fRealAtom; }
+ void addReference(ObjectFile::Reference *ref)
+ { fReferences.push_back(ref); }
+
+ void setSectionOffset(uint64_t offset) { fSectionOffset = offset; if (fRealAtom) fRealAtom->setSectionOffset(offset); }
+ void setSection(class ObjectFile::Section* sect) { fSection = sect; if (fRealAtom) fRealAtom->setSection(sect); }
+
+private:
+ class Reader& fOwner;
+ const char* fName;
+ ObjectFile::Atom::Scope fScope;
+ ObjectFile::Atom::DefinitionKind fKind;
+ uint8_t fAlignment;
+ ObjectFile::Atom* fRealAtom;
+ std::vector<ObjectFile::Reference*> fReferences;
+};
+
+
+Atom::Atom(class Reader& owner, const char* name, Scope scope, DefinitionKind kind, uint8_t alignment, ObjectFile::Atom& internalAtom)
+: fOwner(owner), fName(name), fScope(scope), fKind(kind), fAlignment(alignment), fRealAtom(NULL)
+{
+ // every Atom references the InternalAtom for its reader
+ fReferences.push_back(new Reference(internalAtom));
+}
+
+
+//
+// ld64 only tracks non-internal symbols from an llvm bitcode file.
+// We model this by having an InternalAtom which represent all internal functions and data.
+// All non-interal symbols from a bitcode file are represented by a Atom
+// and each Atom has a reference to the InternalAtom. The InternalAtom
+// also has references to each symbol external to the bitcode file.
+//
+class InternalAtom : public ObjectFile::Atom
+{
+public:
+ InternalAtom(class Reader& owner) : fOwner(owner) {}
+
+ ObjectFile::Reader * getFile() const { return (ObjectFile::Reader*)&fOwner; }
+ bool getTranslationUnitSource (const char **dir, const char **name) const
+ { return false; }
+ const char * getName () const { return "__llvm-internal-atom"; }
+ const char * getDisplayName() const { return this->getName(); }
+ Scope getScope() const { return scopeTranslationUnit; }
+ DefinitionKind getDefinitionKind() const { return kRegularDefinition; }
+ SymbolTableInclusion getSymbolTableInclusion() const { return kSymbolTableNotIn; }
+ bool dontDeadStrip() const { return false; }
+ bool isZeroFill() const { return false; }
+ bool isThumb() const { return false; }
+ uint64_t getSize() const { return 0; }
+ std::vector<ObjectFile::Reference*>& getReferences() const { return (std::vector<ObjectFile::Reference*>&)fReferences; }
+ bool mustRemainInSection() const { return false; }
+ const char * getSectionName() const { return NULL; }
+ class ObjectFile::Section * getSection() const { return NULL; }
+ ObjectFile::Segment& getSegment() const { return Segment::fgBootstrapSegment; }
+ uint32_t getOrdinal() const { return 0; }
+ ObjectFile::Atom& getFollowOnAtom() const { return *((ObjectFile::Atom*)NULL); }
+ std::vector<ObjectFile::LineInfo>* getLineInfo() const { return NULL; }
+ ObjectFile::Alignment getAlignment() const { return ObjectFile::Alignment(0); }
+ void copyRawContent(uint8_t buffer[]) const { }
+ void setScope(Scope s) { }
+
+ void addReference(const char* targetName);
+
+private:
+ class Reader& fOwner;
+ std::vector<ObjectFile::Reference*> fReferences;
+};
+
+
+void InternalAtom::addReference(const char* name)
+{
+ fReferences.push_back(new Reference(name));
+}
+
+
+
+
+class RemovableAtoms
+{
+public:
+ RemovableAtoms(std::set<ObjectFile::Atom*>& iAtoms) : fAtoms(iAtoms) {}
+
+ bool operator()(ObjectFile::Atom*& atom) const {
+ return ( fAtoms.count(atom) != 0 );
+ }
+
+private:
+ std::set<ObjectFile::Atom*>& fAtoms;
+};
+
+
+
+//
+// LLVM bitcode file reader
+//
+class Reader : public ObjectFile::Reader
+{
+public:
+ static bool validFile(const uint8_t* fileContent, uint64_t fileLength, cpu_type_t architecture);
+ static bool loaded() { return (::lto_get_version() != NULL); }
+ Reader(const uint8_t* fileContent, uint64_t fileLength,
+ const char* path, time_t modTime,
+ const ObjectFile::ReaderOptions&, cpu_type_t arch);
+ virtual ~Reader();
+
+ virtual std::vector<class ObjectFile::Atom*>& getAtoms() { return (std::vector<class ObjectFile::Atom*>&)(fAtoms); }
+ virtual std::vector<class ObjectFile::Atom*>* getJustInTimeAtomsFor(const char* name) { return NULL; }
+ virtual const char* getPath() { return fPath; }
+ virtual time_t getModificationTime() { return fModTime; }
+ virtual ObjectFile::Reader::DebugInfoKind getDebugInfoKind() { return kDebugInfoNone; }
+ virtual std::vector<Stab>* getStabs() { return NULL; }
+ virtual void optimize(std::vector<ObjectFile::Atom*> &allAtoms, std::vector<ObjectFile::Atom*> &newAtoms,
+ std::vector<const char*> &additionalUndefines, uint32_t nextInputOrdinal,
+ ObjectFile::Reader* writer, bool allGlobalsAReDeadStripRoots,
+ int outputKind, bool verbose, bool saveTemps, const char* outputFilePath,
+ bool pie, bool allowTextRelocs);
+
+private:
+
+ class CStringEquals
+ {
+ public:
+ bool operator()(const char* left, const char* right) const { return (strcmp(left, right) == 0); }
+ };
+ typedef __gnu_cxx::hash_set<const char*, __gnu_cxx::hash<const char*>, CStringEquals> CStringSet;
+ typedef __gnu_cxx::hash_map<const char*, Atom*, __gnu_cxx::hash<const char*>, CStringEquals> CStringToAtom;
+
+ ObjectFile::Reader* makeMachOReader(const uint8_t* p, size_t len, uint32_t nextInputOrdinal);
+ static const char* tripletPrefixForArch(cpu_type_t);
+
+ cpu_type_t fArchitecture;
+ const char* fPath;
+ time_t fModTime;
+ lto_module_t fModule;
+ std::vector<ObjectFile::Atom*> fAtoms;
+ InternalAtom fInternalAtom;
+ const ObjectFile::ReaderOptions& fReaderOptions;
+ static std::set<Reader*> fgReaders;
+ static bool fgOptimized;
+};
+
+bool Reader::fgOptimized = false;
+std::set<Reader*> Reader::fgReaders;
+
+
+Reader::~Reader()
+{
+ if ( fModule != NULL )
+ ::lto_module_dispose(fModule);
+}
+
+Reader::Reader(const uint8_t* fileContent, uint64_t fileLength, const char* path, time_t modTime,
+ const ObjectFile::ReaderOptions& options, cpu_type_t arch)
+ : fArchitecture(arch), fPath(path), fModTime(modTime), fInternalAtom(*this), fReaderOptions(options)
+{
+ fgReaders.insert(this);
+
+ fModule = ::lto_module_create_from_memory(fileContent, fileLength);
+ if ( fModule == NULL )
+ throwf("could not parse object file %s: %s", path, lto_get_error_message());
+
+
+ uint32_t count = ::lto_module_get_num_symbols(fModule);
+ for (uint32_t i=0; i < count; ++i) {
+ const char* name = ::lto_module_get_symbol_name(fModule, i);
+ lto_symbol_attributes attr = lto_module_get_symbol_attribute(fModule, i);
+
+ ObjectFile::Atom::DefinitionKind kind;
+ switch ( attr & LTO_SYMBOL_DEFINITION_MASK ) {
+ case LTO_SYMBOL_DEFINITION_REGULAR:
+ kind = ObjectFile::Atom::kRegularDefinition;
+ break;
+ case LTO_SYMBOL_DEFINITION_TENTATIVE:
+ kind = ObjectFile::Atom::kTentativeDefinition;
+ break;
+ case LTO_SYMBOL_DEFINITION_WEAK:
+ kind = ObjectFile::Atom::kWeakDefinition;
+ break;
+ case LTO_SYMBOL_DEFINITION_UNDEFINED:
+ kind = ObjectFile::Atom::kExternalDefinition;
+ break;
+ default:
+ throwf("unknown definition kind for symbol %s in bitcode file %s", name, path);
+ }
+
+ // make LLVM atoms for definitions and a reference for undefines
+ if ( kind != ObjectFile::Atom::kExternalDefinition ) {
+ ObjectFile::Atom::Scope scope;
+ switch ( attr & LTO_SYMBOL_SCOPE_MASK) {
+ case LTO_SYMBOL_SCOPE_INTERNAL:
+ scope = ObjectFile::Atom::scopeTranslationUnit;
+ break;
+ case LTO_SYMBOL_SCOPE_HIDDEN:
+ scope = ObjectFile::Atom::scopeLinkageUnit;
+ break;
+ case LTO_SYMBOL_SCOPE_DEFAULT:
+ scope = ObjectFile::Atom::scopeGlobal;
+ break;
+ default:
+ throwf("unknown scope for symbol %s in bitcode file %s", name, path);
+ }
+ // only make atoms for non-internal symbols
+ if ( scope == ObjectFile::Atom::scopeTranslationUnit )
+ continue;
+ uint8_t alignment = (attr & LTO_SYMBOL_ALIGNMENT_MASK);
+ // make Atom
+ fAtoms.push_back(new Atom(*this, name, scope, kind, alignment, fInternalAtom));
+ }
+ else {
+ // add to list of external references
+ fInternalAtom.addReference(name);
+ }
+ }
+}
+
+const char* Reader::tripletPrefixForArch(cpu_type_t arch)
+{
+ switch (arch) {
+ case CPU_TYPE_POWERPC:
+ return "powerpc-";
+ case CPU_TYPE_POWERPC64:
+ return "powerpc64-";
+ case CPU_TYPE_I386:
+ return "i386-";
+ case CPU_TYPE_X86_64:
+ return "x86_64-";
+ case CPU_TYPE_ARM:
+ return "arm-";
+ }
+ return "";
+}
+
+bool Reader::validFile(const uint8_t* fileContent, uint64_t fileLength, cpu_type_t architecture)
+{
+ return ::lto_module_is_object_file_in_memory_for_target(fileContent, fileLength, tripletPrefixForArch(architecture));
+}
+
+void Reader::optimize(std::vector<ObjectFile::Atom *>& allAtoms, std::vector<ObjectFile::Atom*>& newAtoms,
+ std::vector<const char*>& additionalUndefines, uint32_t nextInputOrdinal,
+ ObjectFile::Reader* writer, bool allGlobalsAReDeadStripRoots,
+ int okind, bool verbose, bool saveTemps, const char* outputFilePath,
+ bool pie, bool allowTextRelocs)
+{
+ // this method is call on all Readers. We want the first call to trigger optimization
+ // across all Readers and the subsequent calls to do nothing.
+ if ( fgOptimized )
+ return;
+ fgOptimized = true;
+
+ Options::OutputKind outputKind = (Options::OutputKind)okind; // HACK to work around upward dependency
+
+ // print out LTO version string if -v was used
+ if ( verbose )
+ fprintf(stderr, "%s\n", lto_get_version());
+
+ // create optimizer and add each Reader
+ lto_code_gen_t generator = ::lto_codegen_create();
+ for (std::set<Reader*>::iterator it=fgReaders.begin(); it != fgReaders.end(); ++it) {
+ if ( ::lto_codegen_add_module(generator, (*it)->fModule) )
+ throwf("lto: could not merge in %s", (*it)->fPath);
+ }
+
+ // the linker must preserve all globals in dylibs and flat images
+ const bool globalsNeedPreserving = allGlobalsAReDeadStripRoots || fReaderOptions.fFlatNamespace;
+
+ // The atom graph uses directed edges (references). Collect all references where
+ // originating atom is not part of any LTO Reader. This allows optimizer to optimize an
+ // external (i.e. not originated from same .o file) reference if all originating atoms are also
+ // defined in llvm bitcode file.
+ CStringSet nonLLVMRefs;
+ CStringToAtom llvmAtoms;
+ bool hasNonllvmAtoms = false;
+ for (std::vector<ObjectFile::Atom*>::iterator it = allAtoms.begin(); it != allAtoms.end(); ++it) {
+ ObjectFile::Atom* atom = *it;
+ // only look at references come from an atom that is not an llvm atom
+ if ( fgReaders.count((Reader*)(atom->getFile())) == 0 ) {
+ // remember if we've seen an atoms not from an llvm reader and not from the writer
+ if ( atom->getFile() != writer )
+ hasNonllvmAtoms = true;
+ std::vector<ObjectFile::Reference*>& refs = atom->getReferences();
+ for (std::vector<ObjectFile::Reference*>::iterator ri=refs.begin(), re=refs.end(); ri != re; ++ri) {
+ ObjectFile::Reference* ref = *ri;
+ // add target name to set if target is an llvm atom
+ if ( (ref->getTargetName() != NULL) && (fgReaders.count((Reader*)(ref->getTarget().getFile())) != 0) ) {
+ nonLLVMRefs.insert(ref->getTargetName());
+ }
+ }
+ }
+ else {
+ const char* name = atom->getName();
+ if ( name != NULL )
+ llvmAtoms[name] = (Atom*)atom;
+ }
+ }
+ // tell code generator about symbols that must be preserved
+ for (CStringToAtom::iterator it = llvmAtoms.begin(); it != llvmAtoms.end(); ++it) {
+ const char* name = it->first;
+ Atom* atom = it->second;
+ // Include llvm Symbol in export list if it meets one of following two conditions
+ // 1 - globals need preserving and atom scope is global (and not linkage unit).
+ // 2 - included in nonLLVMRefs set.
+ // If a symbol is not listed in exportList then LTO is free to optimize it away.
+ if ( globalsNeedPreserving && (atom->getScope() == ObjectFile::Atom::scopeGlobal) )
+ ::lto_codegen_add_must_preserve_symbol(generator, name);
+ else if ( nonLLVMRefs.find(name) != nonLLVMRefs.end() )
+ ::lto_codegen_add_must_preserve_symbol(generator, name);
+ }
+
+ // special case running ld -r on all bitcode files to produce another bitcode file (instead of mach-o)
+ if ( (outputKind == Options::kObjectFile) && !hasNonllvmAtoms ) {
+ if ( ! ::lto_codegen_write_merged_modules(generator, outputFilePath) ) {
+ // HACK, no good way to tell linker we are all done, so just quit
+ exit(0);
+ }
+ warning("could not produce merged bitcode file");
+ }
+
+ // if requested, save off merged bitcode file
+ if ( saveTemps ) {
+ char tempBitcodePath[MAXPATHLEN];
+ strcpy(tempBitcodePath, outputFilePath);
+ strcat(tempBitcodePath, ".lto.bc");
+ ::lto_codegen_write_merged_modules(generator, tempBitcodePath);
+ }
+
+ // set code-gen model
+ lto_codegen_model model = LTO_CODEGEN_PIC_MODEL_DYNAMIC;
+ switch ( outputKind ) {
+ case Options::kDynamicExecutable:
+ if ( pie )
+ model = LTO_CODEGEN_PIC_MODEL_DYNAMIC;
+ else
+ model = LTO_CODEGEN_PIC_MODEL_DYNAMIC_NO_PIC;
+ break;
+ case Options::kDynamicLibrary:
+ case Options::kDynamicBundle:
+ case Options::kObjectFile: // ?? Is this appropriate ?
+ case Options::kDyld:
+ if ( allowTextRelocs )
+ model = LTO_CODEGEN_PIC_MODEL_DYNAMIC_NO_PIC;
+ else
+ model = LTO_CODEGEN_PIC_MODEL_DYNAMIC;
+ break;
+ case Options::kStaticExecutable:
+ model = LTO_CODEGEN_PIC_MODEL_STATIC;
+ break;
+ }
+ if ( ::lto_codegen_set_pic_model(generator, model) )
+ throwf("could not create set codegen model: %s", lto_get_error_message());
+
+ // run code generator
+ size_t machOFileLen;
+ const uint8_t* machOFile = (uint8_t*)::lto_codegen_compile(generator, &machOFileLen);
+ if ( machOFile == NULL )
+ throwf("could not do LTO codegen: %s", ::lto_get_error_message());
+
+ // if requested, save off temp mach-o file
+ if ( saveTemps ) {
+ char tempMachoPath[MAXPATHLEN];
+ strcpy(tempMachoPath, outputFilePath);
+ strcat(tempMachoPath, ".lto.o");
+ int fd = ::open(tempMachoPath, O_CREAT | O_WRONLY | O_TRUNC, 0666);
+ if ( fd != -1) {
+ ::write(fd, machOFile, machOFileLen);
+ ::close(fd);
+ }
+ }
+
+ // parse generated mach-o file into a MachOReader
+ ObjectFile::Reader* machoReader = this->makeMachOReader(machOFile, machOFileLen, nextInputOrdinal);
+
+ // sync generated mach-o atoms with existing atoms ld know about
+ std::vector<ObjectFile::Atom*> machoAtoms = machoReader->getAtoms();
+ for (std::vector<ObjectFile::Atom *>::iterator it = machoAtoms.begin(); it != machoAtoms.end(); ++it) {
+ ObjectFile::Atom* atom = *it;
+ const char* name = atom->getName();
+ if ( name != NULL ) {
+ CStringToAtom::iterator pos = llvmAtoms.find(name);
+ if ( pos != llvmAtoms.end() ) {
+ // turn Atom into a proxy for this mach-o atom
+ pos->second->setRealAtom(atom);
+ }
+ else {
+ // this atom is did not exist orginally, tell ld about it
+ newAtoms.push_back(atom);
+ }
+ }
+ else {
+ // ld only knew about named atoms, so this one must be new
+ newAtoms.push_back(atom);
+ }
+ std::vector<class ObjectFile::Reference*>& references = atom->getReferences();
+ for (std::vector<ObjectFile::Reference*>::iterator rit=references.begin(); rit != references.end(); ++rit) {
+ ObjectFile::Reference* ref = *rit;
+ const char* targetName = ref->getTargetName();
+ CStringToAtom::iterator pos;
+ if (targetName != NULL) {
+ switch ( ref->getTargetBinding() ) {
+ case ObjectFile::Reference::kUnboundByName:
+ // accumulate unbounded references so that ld can bound them.
+ additionalUndefines.push_back(targetName);
+ break;
+ case ObjectFile::Reference::kBoundDirectly:
+ case ObjectFile::Reference::kBoundByName:
+ // If mach-o atom is referencing another mach-o atom then
+ // reference is not going through Atom proxy. Fix it here to ensure that all
+ // llvm symbol references always go through Atom proxy.
+ pos = llvmAtoms.find(targetName);
+ if ( pos != llvmAtoms.end() )
+ ref->setTarget(*pos->second, ref->getTargetOffset());
+ break;
+ case ObjectFile::Reference::kDontBind:
+ break;
+ }
+ }
+ }
+ }
+
+ // Remove InternalAtoms from ld
+ std::set<class ObjectFile::Atom*> deletedAtoms;
+ for (std::set<Reader*>::iterator it=fgReaders.begin(); it != fgReaders.end(); ++it) {
+ deletedAtoms.insert(&((*it)->fInternalAtom));
+ }
+ // Remove Atoms from ld if code generator optimized them away
+ for (CStringToAtom::iterator li = llvmAtoms.begin(), le = llvmAtoms.end(); li != le; ++li) {
+ // check if setRealAtom() called on this Atom
+ if ( li->second->getRealAtom() == NULL )
+ deletedAtoms.insert(li->second);
+ }
+ allAtoms.erase(std::remove_if(allAtoms.begin(), allAtoms.end(), RemovableAtoms(deletedAtoms)), allAtoms.end());
+}
+
+
+ObjectFile::Reader* Reader::makeMachOReader(const uint8_t* p, size_t len, uint32_t nextInputOrdinal)
+{
+ switch ( fArchitecture ) {
+ case CPU_TYPE_POWERPC:
+ if ( mach_o::relocatable::Reader<ppc>::validFile(p) )
+ return new mach_o::relocatable::Reader<ppc>(p, "/tmp/lto.o", 0, fReaderOptions, nextInputOrdinal);
+ break;
+ case CPU_TYPE_POWERPC64:
+ if ( mach_o::relocatable::Reader<ppc64>::validFile(p) )
+ return new mach_o::relocatable::Reader<ppc64>(p, "/tmp/lto.o", 0, fReaderOptions, nextInputOrdinal);
+ break;
+ case CPU_TYPE_I386:
+ if ( mach_o::relocatable::Reader<x86>::validFile(p) )
+ return new mach_o::relocatable::Reader<x86>(p, "/tmp/lto.o", 0, fReaderOptions, nextInputOrdinal);
+ break;
+ case CPU_TYPE_X86_64:
+ if ( mach_o::relocatable::Reader<x86_64>::validFile(p) )
+ return new mach_o::relocatable::Reader<x86_64>(p, "/tmp/lto.o", 0, fReaderOptions, nextInputOrdinal);
+ break;
+ case CPU_TYPE_ARM:
+ if ( mach_o::relocatable::Reader<arm>::validFile(p) )
+ return new mach_o::relocatable::Reader<arm>(p, "/tmp/lto.o", 0, fReaderOptions, nextInputOrdinal);
+ break;
+ }
+ throw "LLVM LTO, file is not of required architecture";
+}
+
+}; // namespace lto
+
+
+void printLTOVersion(Options &opts) {
+ const char* vers = lto_get_version();
+ if ( vers != NULL )
+ fprintf(stderr, "%s\n", vers);
+}
+
+
+#endif
+
projects / apple / ld64.git / blobdiff