--- /dev/null
+/* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
+ *
+ * Copyright (c) 2006-2009 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 "ld.hpp"
+
+#include "llvm-c/lto.h"
+
+
+namespace lto {
+
+
+//
+// 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 an 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 ld::Atom
+{
+public:
+ InternalAtom(class File& f);
+ // overrides of ld::Atom
+ virtual ld::File* file() const { return &_file; }
+ virtual bool translationUnitSource(const char** dir, const char** nm) const
+ { return false; }
+ virtual const char* name() const { return "import-atom"; }
+ virtual uint64_t size() const { return 0; }
+ virtual uint64_t objectAddress() const { return 0; }
+ virtual void copyRawContent(uint8_t buffer[]) const { }
+ virtual void setScope(Scope) { }
+ virtual ld::Fixup::iterator fixupsBegin() { return &_undefs[0]; }
+ virtual ld::Fixup::iterator fixupsEnd() { return &_undefs[_undefs.size()]; }
+
+ // for adding references to symbols outside bitcode file
+ void addReference(const char* name)
+ { _undefs.push_back(ld::Fixup(0, ld::Fixup::k1of1,
+ ld::Fixup::fixupNone, false, name)); }
+private:
+
+ ld::File& _file;
+ std::vector<ld::Fixup> _undefs;
+};
+
+
+//
+// LLVM bitcode file
+//
+class File : public ld::relocatable::File
+{
+public:
+ File(const char* path, time_t mTime, const uint8_t* content,
+ uint32_t contentLength, uint32_t ordinal, cpu_type_t arch);
+ virtual ~File();
+
+ // overrides of ld::File
+ virtual bool forEachAtom(ld::File::AtomHandler&);
+ virtual bool justInTimeforEachAtom(const char* name, ld::File::AtomHandler&)
+ { return false; }
+
+ // overrides of ld::relocatable::File
+ virtual bool objcReplacementClasses() { return false; }
+ virtual DebugInfoKind debugInfo() { return ld::relocatable::File::kDebugInfoNone; }
+ virtual std::vector<ld::relocatable::File::Stab>* stabs() { return NULL; }
+ virtual bool canScatterAtoms() { return true; }
+
+ lto_module_t module() { return _module; }
+ class InternalAtom& internalAtom() { return _internalAtom; }
+private:
+ friend class Atom;
+ friend class InternalAtom;
+
+ cpu_type_t _architecture;
+ class InternalAtom _internalAtom;
+ class Atom* _atomArray;
+ uint32_t _atomArrayCount;
+ lto_module_t _module;
+ ld::Section _section;
+};
+
+//
+// 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 ld::Atom
+{
+public:
+ Atom(File& f, const char* name, ld::Atom::Scope s,
+ ld::Atom::Definition d, ld::Atom::Alignment a);
+
+ // overrides of ld::Atom
+ virtual ld::File* file() const { return &_file; }
+ virtual bool translationUnitSource(const char** dir, const char** nm) const
+ { return (_compiledAtom ? _compiledAtom->translationUnitSource(dir, nm) : false); }
+ virtual const char* name() const { return _name; }
+ virtual uint64_t size() const { return (_compiledAtom ? _compiledAtom->size() : 0); }
+ virtual uint64_t objectAddress() const { return (_compiledAtom ? _compiledAtom->objectAddress() : 0); }
+ virtual void copyRawContent(uint8_t buffer[]) const
+ { if (_compiledAtom) _compiledAtom->copyRawContent(buffer); }
+
+ ld::Atom* compiledAtom() { return _compiledAtom; }
+ void setCompiledAtom(ld::Atom& atom)
+ { _compiledAtom = &atom; }
+private:
+
+ File& _file;
+ const char* _name;
+ ld::Atom* _compiledAtom;
+};
+
+
+
+
+
+
+
+class Parser
+{
+public:
+ static bool validFile(const uint8_t* fileContent, uint64_t fileLength, cpu_type_t architecture);
+ static const char* fileKind(const uint8_t* fileContent);
+ static File* parse(const uint8_t* fileContent, uint64_t fileLength, const char* path,
+ time_t modTime, uint32_t ordinal, cpu_type_t architecture);
+ static bool libLTOisLoaded() { return (::lto_get_version() != NULL); }
+ static bool optimize(const std::vector<ld::Atom*>& allAtoms, std::vector<ld::Atom*>& newAtoms,
+ std::vector<const char*>& additionalUndefines,
+ const std::set<ld::Atom*>&,
+ std::vector<ld::Atom*>& newDeadAtoms,
+ uint32_t nextInputOrdinal,
+ ld::OutFile* writer, ld::Atom* entryPointAtom,
+ const std::vector<const char*>& llvmOptions,
+ bool allGlobalsAReDeadStripRoots,
+ bool verbose, bool saveTemps,
+ const char* outputFilePath,
+ bool pie, bool mainExecutable, bool staticExecutable, bool relocatable,
+ bool allowTextRelocs, cpu_type_t arch);
+
+ static const char* ltoVersion() { return ::lto_get_version(); }
+
+private:
+ static const char* tripletPrefixForArch(cpu_type_t arch);
+ static ld::relocatable::File* parseMachOFile(const uint8_t* p, size_t len, uint32_t nextInputOrdinal, cpu_type_t arch);
+
+ 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;
+
+ class AtomSyncer : public ld::File::AtomHandler {
+ public:
+ AtomSyncer(std::vector<const char*>& a, std::vector<ld::Atom*>&na,
+ CStringToAtom la, CStringToAtom dla) :
+ additionalUndefines(a), newAtoms(na), llvmAtoms(la), deadllvmAtoms(dla) { }
+ virtual void doAtom(class ld::Atom&);
+
+ std::vector<const char*>& additionalUndefines;
+ std::vector<ld::Atom*>& newAtoms;
+ CStringToAtom llvmAtoms;
+ CStringToAtom deadllvmAtoms;
+ };
+
+ static std::vector<File*> _s_files;
+};
+
+std::vector<File*> Parser::_s_files;
+
+
+const char* Parser::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 Parser::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));
+}
+
+const char* Parser::fileKind(const uint8_t* p)
+{
+ if ( (p[0] == 0xDE) && (p[1] == 0xC0) && (p[2] == 0x17) && (p[3] == 0x0B) ) {
+ uint32_t arch = LittleEndian::get32(*((uint32_t*)(&p[16])));
+ switch (arch) {
+ case CPU_TYPE_POWERPC:
+ return "ppc";
+ case CPU_TYPE_I386:
+ return "i386";
+ case CPU_TYPE_X86_64:
+ return "x86_64";
+ case CPU_TYPE_ARM:
+ return "arm";
+ }
+ return "unknown bitcode architecture";
+ }
+ return NULL;
+}
+
+File* Parser::parse(const uint8_t* fileContent, uint64_t fileLength, const char* path, time_t modTime,
+ uint32_t ordinal, cpu_type_t architecture)
+{
+ File* f = new File(path, modTime, fileContent, fileLength, ordinal, architecture);
+ _s_files.push_back(f);
+ return f;
+}
+
+
+ld::relocatable::File* Parser::parseMachOFile(const uint8_t* p, size_t len, uint32_t nextInputOrdinal, cpu_type_t arch)
+{
+ switch ( arch ) {
+ case CPU_TYPE_POWERPC:
+ if ( mach_o::relocatable::Parser<ppc>::validFile(p) )
+ return mach_o::relocatable::Parser<ppc>::parse(p, len, "/tmp/lto.o", 0, nextInputOrdinal);
+ break;
+ case CPU_TYPE_POWERPC64:
+ if ( mach_o::relocatable::Parser<ppc64>::validFile(p) )
+ return mach_o::relocatable::Parser<ppc64>::parse(p, len, "/tmp/lto.o", 0, nextInputOrdinal);
+ break;
+ case CPU_TYPE_I386:
+ if ( mach_o::relocatable::Parser<x86>::validFile(p) )
+ return mach_o::relocatable::Parser<x86>::parse(p, len, "/tmp/lto.o", 0, nextInputOrdinal);
+ break;
+ case CPU_TYPE_X86_64:
+ if ( mach_o::relocatable::Parser<x86_64>::validFile(p) )
+ return mach_o::relocatable::Parser<x86_64>::parse(p, len, "/tmp/lto.o", 0, nextInputOrdinal);
+ break;
+ case CPU_TYPE_ARM:
+ if ( mach_o::relocatable::Parser<arm>::validFile(p) )
+ return mach_o::relocatable::Parser<arm>::parse(p, len, "/tmp/lto.o", 0, nextInputOrdinal);
+ break;
+ }
+ throw "LLVM LTO, file is not of required architecture";
+}
+
+
+
+File::File(const char* path, time_t mTime, const uint8_t* content, uint32_t contentLength, uint32_t ordinal, cpu_type_t arch)
+ : ld::relocatable::File(path,mTime,ordinal), _architecture(arch), _internalAtom(*this),
+ _atomArray(NULL), _atomArrayCount(0), _module(NULL),
+ _section("__TEXT_", "__tmp_lto", ld::Section::typeUnclassified)
+{
+ // create llvm module
+ _module = ::lto_module_create_from_memory(content, contentLength);
+ if ( _module == NULL )
+ throwf("could not parse object file %s: %s", path, lto_get_error_message());
+
+ // create atom for each global symbol in module
+ uint32_t count = ::lto_module_get_num_symbols(_module);
+ _atomArray = (Atom*)malloc(sizeof(Atom)*count);
+ for (uint32_t i=0; i < count; ++i) {
+ const char* name = ::lto_module_get_symbol_name(_module, i);
+ lto_symbol_attributes attr = lto_module_get_symbol_attribute(_module, i);
+
+ // <rdar://problem/6378110> LTO doesn't like dtrace symbols
+ // ignore dtrace static probes for now
+ // later when codegen is done and a mach-o file is produces the probes will be processed
+ if ( (strncmp(name, "___dtrace_probe$", 16) == 0) || (strncmp(name, "___dtrace_isenabled$", 20) == 0) )
+ continue;
+
+ ld::Atom::Definition def;
+ switch ( attr & LTO_SYMBOL_DEFINITION_MASK ) {
+ case LTO_SYMBOL_DEFINITION_REGULAR:
+ def = ld::Atom::definitionRegular;
+ break;
+ case LTO_SYMBOL_DEFINITION_TENTATIVE:
+ def = ld::Atom::definitionTentative;
+ break;
+ case LTO_SYMBOL_DEFINITION_WEAK:
+ def = ld::Atom::definitionRegular;
+ break;
+ case LTO_SYMBOL_DEFINITION_UNDEFINED:
+ case LTO_SYMBOL_DEFINITION_WEAKUNDEF:
+ def = ld::Atom::definitionProxy;
+ 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 ( def != ld::Atom::definitionProxy ) {
+ ld::Atom::Scope scope;
+ switch ( attr & LTO_SYMBOL_SCOPE_MASK) {
+ case LTO_SYMBOL_SCOPE_INTERNAL:
+ scope = ld::Atom::scopeTranslationUnit;
+ break;
+ case LTO_SYMBOL_SCOPE_HIDDEN:
+ scope = ld::Atom::scopeLinkageUnit;
+ break;
+ case LTO_SYMBOL_SCOPE_DEFAULT:
+ scope = ld::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 == ld::Atom::scopeTranslationUnit )
+ continue;
+ uint8_t alignment = (attr & LTO_SYMBOL_ALIGNMENT_MASK);
+ // make Atom using placement new operator
+ new (&_atomArray[_atomArrayCount++]) Atom(*this, name, scope, def, alignment);
+ }
+ else {
+ // add to list of external references
+ _internalAtom.addReference(name);
+ }
+ }
+}
+
+File::~File()
+{
+ if ( _module != NULL )
+ ::lto_module_dispose(_module);
+}
+
+bool File::forEachAtom(ld::File::AtomHandler& handler)
+{
+ handler.doAtom(_internalAtom);
+ for(uint32_t i=0; i < _atomArrayCount; ++i) {
+ handler.doAtom(_atomArray[i]);
+ }
+ return true;
+}
+
+InternalAtom::InternalAtom(File& f)
+ : ld::Atom(f._section, ld::Atom::definitionRegular, ld::Atom::combineNever, ld::Atom::scopeTranslationUnit,
+ ld::Atom::typeLTOtemporary, ld::Atom::symbolTableNotIn, false, false, ld::Atom::Alignment(0)),
+ _file(f)
+{
+}
+
+Atom::Atom(File& f, const char* name, ld::Atom::Scope s, ld::Atom::Definition d, ld::Atom::Alignment a)
+ : ld::Atom(f._section, d, ld::Atom::combineNever, s, ld::Atom::typeLTOtemporary, ld::Atom::symbolTableIn, false, false, a),
+ _file(f), _name(name), _compiledAtom(NULL)
+{
+}
+
+
+
+
+bool Parser::optimize(const std::vector<ld::Atom*>& allAtoms, std::vector<ld::Atom*>& newAtoms,
+ std::vector<const char*>& additionalUndefines,
+ const std::set<ld::Atom*>& deadAtoms,
+ std::vector<ld::Atom*>& newlyDeadAtoms,
+ uint32_t nextInputOrdinal,
+ ld::OutFile* writer, ld::Atom* entryPointAtom,
+ const std::vector<const char*>& llvmOptions,
+ bool allGlobalsAReDeadStripRoots,
+ bool verbose, bool saveTemps,
+ const char* outputFilePath,
+ bool pie, bool mainExecutable, bool staticExecutable, bool relocatable,
+ bool allowTextRelocs, cpu_type_t arch)
+{
+ // exit quickly if nothing to do
+ if ( _s_files.size() == 0 )
+ return false;
+
+ // 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::vector<File*>::iterator it=_s_files.begin(); it != _s_files.end(); ++it) {
+ if ( ::lto_codegen_add_module(generator, (*it)->module()) )
+ throwf("lto: could not merge in %s because %s", (*it)->path(), ::lto_get_error_message());
+ }
+
+ // add any -mllvm command line options
+ for (std::vector<const char*>::const_iterator it=llvmOptions.begin(); it != llvmOptions.end(); ++it) {
+ ::lto_codegen_debug_options(generator, *it);
+ }
+
+ // 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<ld::Atom*>::const_iterator it = allAtoms.begin(); it != allAtoms.end(); ++it) {
+ ld::Atom* atom = *it;
+ // only look at references that come from an atom that is not an llvm atom
+ if ( atom->contentType() != ld::Atom::typeLTOtemporary ) {
+ // remember if we've seen any atoms not from an llvm reader and not from the writer
+// if ( atom->getFile() != writer )
+// hasNonllvmAtoms = true;
+ for (ld::Fixup::iterator fit=atom->fixupsBegin(); fit != atom->fixupsEnd(); ++fit) {
+ if ( fit->binding != ld::Fixup::bindingByNameBound )
+ continue;
+ // and reference an llvm atom
+ if ( fit->u.target->contentType() == ld::Atom::typeLTOtemporary )
+ nonLLVMRefs.insert(fit->u.target->name());
+ }
+ }
+ else {
+ llvmAtoms[atom->name()] = (Atom*)atom;
+ }
+ }
+ // if entry point is in a llvm bitcode file, it must be preserved by LTO
+ if ( entryPointAtom != NULL ) {
+ if ( entryPointAtom->contentType() == ld::Atom::typeLTOtemporary )
+ nonLLVMRefs.insert(entryPointAtom->name());
+ }
+
+ // deadAtoms are the atoms that the linker coalesced. For instance weak or tentative definitions
+ // overriden by another atom. If any of these deadAtoms are llvm atoms and they were replaced
+ // with a mach-o atom, we need to tell the lto engine to preserve (not optimize away) its dead
+ // atom so that the linker can replace it with the mach-o one later.
+ CStringToAtom deadllvmAtoms;
+ for (std::set<ld::Atom*>::iterator it = deadAtoms.begin(); it != deadAtoms.end(); ++it) {
+ ld::Atom* atom = *it;
+ if ( atom->contentType() == ld::Atom::typeLTOtemporary ) {
+ const char* name = atom->name();
+ ::lto_codegen_add_must_preserve_symbol(generator, name);
+ deadllvmAtoms[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 - 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 ( (atom->scope() == ld::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 ( relocatable && !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");
+ }
+
+ // set code-gen model
+ lto_codegen_model model = LTO_CODEGEN_PIC_MODEL_DYNAMIC;
+ if ( mainExecutable ) {
+ if ( staticExecutable ) {
+ // darwin x86_64 "static" code model is really dynamic code model
+ if ( arch == CPU_TYPE_X86_64 )
+ model = LTO_CODEGEN_PIC_MODEL_DYNAMIC;
+ else
+ model = LTO_CODEGEN_PIC_MODEL_STATIC;
+ }
+ else {
+ if ( pie )
+ model = LTO_CODEGEN_PIC_MODEL_DYNAMIC;
+ else
+ model = LTO_CODEGEN_PIC_MODEL_DYNAMIC_NO_PIC;
+ }
+ }
+ else {
+ if ( allowTextRelocs )
+ model = LTO_CODEGEN_PIC_MODEL_DYNAMIC_NO_PIC;
+ else
+ model = LTO_CODEGEN_PIC_MODEL_DYNAMIC;
+ }
+ if ( ::lto_codegen_set_pic_model(generator, model) )
+ throwf("could not create set codegen model: %s", lto_get_error_message());
+
+ // 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);
+ }
+
+#if LTO_API_VERSION >= 3
+ // find assembler next to linker
+ char path[PATH_MAX];
+ uint32_t bufSize = PATH_MAX;
+ if ( _NSGetExecutablePath(path, &bufSize) != -1 ) {
+ char* lastSlash = strrchr(path, '/');
+ if ( lastSlash != NULL ) {
+ strcpy(lastSlash+1, "as");
+ struct stat statInfo;
+ if ( stat(path, &statInfo) == 0 )
+ ::lto_codegen_set_assembler_path(generator, path);
+ }
+ }
+#endif
+ // 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);
+ }
+ // save off merged bitcode file
+ char tempOptBitcodePath[MAXPATHLEN];
+ strcpy(tempOptBitcodePath, outputFilePath);
+ strcat(tempOptBitcodePath, ".lto.opt.bc");
+ ::lto_codegen_write_merged_modules(generator, tempOptBitcodePath);
+ }
+
+ // parse generated mach-o file into a MachOReader
+ ld::File* machoFile = parseMachOFile(machOFile, machOFileLen, nextInputOrdinal, arch);
+
+ // sync generated mach-o atoms with existing atoms ld knows about
+ AtomSyncer syncer(additionalUndefines,newAtoms,llvmAtoms,deadllvmAtoms);
+ machoFile->forEachAtom(syncer);
+
+ // Remove InternalAtoms from ld
+ for (std::vector<File*>::iterator it=_s_files.begin(); it != _s_files.end(); ++it) {
+ newlyDeadAtoms.push_back(&((*it)->internalAtom()));
+ }
+ // 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->compiledAtom() == NULL )
+ newlyDeadAtoms.push_back(li->second);
+ }
+
+ return true;
+}
+
+
+void Parser::AtomSyncer::doAtom(ld::Atom& machoAtom)
+{
+ // update proxy atoms to point to real atoms and find new atoms
+ const char* name = machoAtom.name();
+ if ( machoAtom.scope() >= ld::Atom::scopeLinkageUnit ) {
+ CStringToAtom::iterator pos = llvmAtoms.find(name);
+ if ( pos != llvmAtoms.end() ) {
+ // turn Atom into a proxy for this mach-o atom
+ pos->second->setCompiledAtom(machoAtom);
+ }
+ else {
+ // an atom of this name was not in the allAtoms list the linker gave us
+ if ( deadllvmAtoms.find(name) != deadllvmAtoms.end() ) {
+ // this corresponding to an atom that the linker coalesced away.
+ // Don't pass it back as a new atom
+ }
+ else
+ {
+ // this is something new that lto conjured up, tell ld its new
+ newAtoms.push_back(&machoAtom);
+ }
+ }
+ }
+ else {
+ // ld only knew about non-satic atoms, so this one must be new
+ newAtoms.push_back(&machoAtom);
+ }
+
+ // adjust fixups to go through proxy atoms
+ for (ld::Fixup::iterator fit=machoAtom.fixupsBegin(); fit != machoAtom.fixupsEnd(); ++fit) {
+ switch ( fit->binding ) {
+ case ld::Fixup::bindingNone:
+ break;
+ case ld::Fixup::bindingByNameUnbound:
+ // don't know if this target has been seen by linker before or if it is new
+ // be conservitive and tell linker it is new
+ additionalUndefines.push_back(fit->u.name);
+ break;
+ case ld::Fixup::bindingByNameBound:
+ break;
+ case ld::Fixup::bindingDirectlyBound:
+ // 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.
+ break;
+ case ld::Fixup::bindingByContentBound:
+ break;
+ }
+ }
+
+}
+
+
+
+}; // namespace lto
+
+
+#endif
+
projects / apple / ld64.git / blobdiff