--- /dev/null
+/* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
+ *
+ * Copyright (c) 2006-2007 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 __LLVM_READER_H__
+#define __LLVM_READER_H__
+
+#include <stdlib.h>
+#include <vector>
+#include "MachOFileAbstraction.hpp"
+#include "Architectures.hpp"
+#include "ObjectFile.h"
+#include "llvm/LinkTimeOptimizer.h"
+
+#define LLVMLinkTimeOptimizer "LLVMlto.dylib"
+
+class LLVMReader;
+
+//
+// LLVMReference handles LLVMAtom references. These references facilitate
+// symbol resolution.
+//
+
+class LLVMReference : public ObjectFile::Reference
+{
+public:
+ LLVMReference (const char *n) : fName(n), fAtom(0), fFromAtom(0) { }
+
+ bool isTargetUnbound() const { return fAtom == 0; }
+ bool isFromTargetUnbound() const { return true; }
+ uint8_t getKind() const { return 0; }
+ uint64_t getFixUpOffset() const { return 0; }
+ const char * getTargetName() const { return fName; }
+ ObjectFile::Atom& getTarget() const { return *fAtom; }
+ uint64_t getTargetOffset() const { return 0; }
+ bool hasFromTarget() const { return false; }
+ ObjectFile::Atom& getFromTarget() const { return *fFromAtom; }
+ 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)
+ { fAtom = &a; }
+ void setFromTarget(ObjectFile::Atom &a) { }
+ const char * getDescription() const { return NULL; }
+
+private:
+ const char * fName;
+ ObjectFile::Atom * fAtom;
+ ObjectFile::Atom * fFromAtom;
+};
+
+ObjectFile::Reference::TargetBinding LLVMReference::getTargetBinding() const
+{
+ if (strncmp (fName, "__ld64.llvm", 11) == 0)
+ return kDontBind;
+ else return kUnboundByName;
+}
+
+//
+// LLVMAtom acts as a proxy Atom for the symbols that are exported by LLVM bytecode file. Initially,
+// LLVMReader creates LLVMAtoms 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. LLVMAtom holds real Atom and forwards appropriate
+// methods to real atom.
+//
+
+class LLVMAtom : public ObjectFile::Atom
+{
+public:
+ ObjectFile::Reader * getFile() const { return fOwner; }
+ bool getTranslationUnitSource (const char **dir, const char **name) const
+ { return fRealAtom->getTranslationUnitSource (dir, name); }
+ const char * getName () const { return fAtomName; }
+ const char * getDisplayName() const { return this->getName(); }
+ Scope getScope() const { return fScope; }
+ DefinitionKind getDefinitionKind() const;
+ SymbolTableInclusion getSymbolTableInclusion() const
+ { return fRealAtom->getSymbolTableInclusion(); }
+ bool dontDeadStrip() const { return false; }
+ bool isZeroFill() const { return fRealAtom->isZeroFill(); }
+ uint64_t getSize() const { return fRealAtom->getSize(); }
+ 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->getSegment(); }
+ uint32_t getOrdinal() const { return (fRealAtom ? fRealAtom->getOrdinal() : 0); }
+ ObjectFile::Atom& getFollowOnAtom() const { return fRealAtom->getFollowOnAtom(); }
+ std::vector<ObjectFile::LineInfo>* getLineInfo() const { return fRealAtom->getLineInfo(); }
+ ObjectFile::Alignment getAlignment() const;
+ void copyRawContent(uint8_t buffer[]) const
+ { fRealAtom->copyRawContent(buffer); }
+ void setScope(Scope s) { if (fRealAtom) fRealAtom->setScope(s); }
+
+ LLVMAtom(ObjectFile::Reader *owner, const char *n, llvm::LLVMSymbol *ls);
+
+ void setRealAtom (ObjectFile::Atom *atom)
+ { fRealAtom = atom; }
+ 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:
+ ObjectFile::Reader * fOwner;
+ const char * fAtomName;
+ llvm::LLVMSymbol * fLLVMSymbol;
+ ObjectFile::Atom * fRealAtom;
+ std::vector<ObjectFile::Reference*> fReferences;
+ ObjectFile::Atom::Scope fScope;
+ ObjectFile::Atom::DefinitionKind fDefKind;
+};
+
+ObjectFile::Atom::DefinitionKind LLVMAtom::getDefinitionKind() const
+{
+ if (fRealAtom)
+ return fRealAtom->getDefinitionKind();
+ else
+ return fDefKind;
+}
+
+LLVMAtom::LLVMAtom(ObjectFile::Reader *owner, const char *n, llvm::LLVMSymbol *ls) : fOwner(owner), fAtomName(n), fLLVMSymbol(ls), fRealAtom(0)
+{
+
+ if (!ls) return;
+
+ switch (ls->getLinkage()) {
+ case llvm::LTOExternalLinkage:
+ fScope = scopeGlobal;
+ fDefKind = kRegularDefinition;
+ break;
+ case llvm::LTOLinkOnceLinkage:
+ case llvm::LTOWeakLinkage:
+ // ??? How to differentiate between this two linkage types ?
+ fScope = scopeGlobal;
+ fDefKind = kWeakDefinition;
+ break;
+ default:
+ throw "Unexpected LLVM Symbol Linkage info\n";
+ break;
+ }
+}
+
+ObjectFile::Alignment LLVMAtom::getAlignment() const
+{
+ if (fRealAtom)
+ return fRealAtom->getAlignment();
+ else {
+ ObjectFile::Alignment alignment(fLLVMSymbol->getAlignment());
+ return alignment;
+ }
+}
+
+//
+// LLVMReader does not expose internal symbols defined and used inside bytecode file. However,
+// these symbols may refere other external symbols. IntercessorAtom facilitate by acting as a
+// orignator of such references during pre-optimization symbol resoultion phase. These atoms
+// are immediately removed after optimization.
+//
+
+class IntercessorAtom : public ObjectFile::Atom
+{
+public:
+ ObjectFile::Reader * getFile() const { return fOwner; }
+ bool getTranslationUnitSource (const char **dir, const char **name) const
+ { return false; }
+ const char * getName () const { return fAtomName; }
+ const char * getDisplayName() const { return this->getName(); }
+ Scope getScope() const { return scopeGlobal; }
+ DefinitionKind getDefinitionKind() const { return kRegularDefinition; }
+ SymbolTableInclusion getSymbolTableInclusion() const
+ { return kSymbolTableNotIn; }
+ bool dontDeadStrip() const { return false; }
+ bool isZeroFill() 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 this->getSegment(); }
+ uint32_t getOrdinal() const { return 0; }
+ ObjectFile::Atom& getFollowOnAtom() const { return this->getFollowOnAtom(); }
+ std::vector<ObjectFile::LineInfo>* getLineInfo() const { return NULL; }
+ ObjectFile::Alignment getAlignment() const { ObjectFile::Alignment a(0); return a; }
+ void copyRawContent(uint8_t buffer[]) const
+ { }
+ void setScope(Scope s) { }
+
+
+ IntercessorAtom(ObjectFile::Reader *owner, std::set<std::string> &references);
+
+ void addReference(ObjectFile::Reference *ref)
+ { fReferences.push_back(ref); }
+ void addReferences(std::set<std::string> &references);
+private:
+ ObjectFile::Reader * fOwner;
+ char * fAtomName;
+ std::vector<ObjectFile::Reference*> fReferences;
+ ObjectFile::Atom::Scope fScope;
+ ObjectFile::Atom::DefinitionKind fDefKind;
+};
+
+IntercessorAtom::IntercessorAtom(ObjectFile::Reader *owner, std::set<std::string> &references)
+{
+ static int sCount = 0;
+ fOwner = owner;
+ fAtomName = (char *) malloc (sizeof(char)*20);
+ sprintf (fAtomName,"__ld64.llvm%d__",sCount++);
+
+ for (std::set<std::string>::iterator it = references.begin(); it != references.end(); it++) {
+ std::string r = *it;
+ this->addReference(new LLVMReference(r.c_str()));
+ }
+}
+
+void IntercessorAtom::addReferences(std::set<std::string> &references)
+{
+ for (std::set<std::string>::iterator it = references.begin(); it != references.end(); it++) {
+ std::string r = *it;
+ this->addReference(new LLVMReference(r.c_str()));
+ }
+}
+
+class InIntercessorSet
+{
+public:
+ InIntercessorSet(std::set<ObjectFile::Atom*>& iAtoms) : fIntercessorAtoms(iAtoms) {}
+
+ bool operator()(ObjectFile::Atom*& atom) const {
+ return ( fIntercessorAtoms.count(atom) != 0 );
+ }
+
+private:
+ std::set<ObjectFile::Atom*>& fIntercessorAtoms;
+};
+
+//
+// LLVMOptimizer class is responsible for communicating with LLVM LTO library.
+// One LLVMOptimizer object is created per Linker invocation. All LLVMReaders share this
+// one single optimizer object.
+//
+
+class LLVMOptimizer
+{
+public:
+ LLVMOptimizer(Options &opt);
+ ~LLVMOptimizer() { if (fLLVMHandle) dlclose(fLLVMHandle); }
+
+
+ void optimize(std::vector<ObjectFile::Atom *>&, std::vector<ObjectFile::Atom*>&, uint32_t);
+ void read(ObjectFile::Reader *, const char *, std::set<std::string>&, std::vector<ObjectFile::Atom*>&, const char *);
+ void reconcileOptimizedAtoms(std::vector<class ObjectFile::Atom*>&, std::vector<class ObjectFile::Atom*>&);
+ void addIntercessor(IntercessorAtom * atom) { fIntercessorAtoms.insert(atom); }
+ void addReader(ObjectFile::Reader *reader) { fLLVMReaders[reader->getPath()] = reader; }
+ cpu_type_t getCpuType(std::string &targetTriple);
+ bool validArchitecture(const char *path, cpu_type_t architecture);
+ class LCStringEquals
+ {
+ public:
+ bool operator()(const char* left, const char* right) const { return (strcmp(left, right) == 0); }
+ };
+ typedef hash_map<const char*, LLVMAtom*, hash<const char*>, LCStringEquals> LLVMAtomToNameMapper;
+ typedef hash_map<const char*, ObjectFile::Reader*, hash<const char*>, LCStringEquals> ReaderToPathMapper;
+
+ typedef llvm::LinkTimeOptimizer * (*createLLVMOptimizer_func_t) ();
+private:
+ bool fOptimized;
+ llvm::LinkTimeOptimizer *fOptimizer;
+ void *fLLVMHandle;
+ LLVMAtomToNameMapper fLLVMSymbols;
+ Options& fOptions;
+ std::set<ObjectFile::Atom*> fIntercessorAtoms;
+ ReaderToPathMapper fLLVMReaders;
+};
+
+LLVMOptimizer::LLVMOptimizer(Options &opts) : fOptions(opts)
+{
+ fLLVMHandle = (llvm::LinkTimeOptimizer *) dlopen (LLVMLinkTimeOptimizer, RTLD_LAZY);
+ if (!fLLVMHandle)
+ throwf("Unable to load LLVM library: \n", dlerror());
+
+ createLLVMOptimizer_func_t createLLVMOptimizer_fp = (createLLVMOptimizer_func_t)dlsym(fLLVMHandle, "createLLVMOptimizer");
+ if (createLLVMOptimizer_fp == NULL)
+ throwf("couldn't find \"createLLVMOptimizer\" ", dlerror());
+ fOptimizer = createLLVMOptimizer_fp();
+ fOptimized = false;
+}
+
+cpu_type_t LLVMOptimizer::getCpuType(std::string &targetTriple)
+{
+ if ( strncmp (targetTriple.c_str(), "powerpc-", 8) == 0)
+ return CPU_TYPE_POWERPC;
+ else if ( strncmp (targetTriple.c_str(), "powerpc64-", 10))
+ return CPU_TYPE_POWERPC64;
+ // match "i[3-9]86-*".
+ else if ( targetTriple.size() >= 5 && targetTriple[0] == 'i' && targetTriple[2] == '8' && targetTriple[3] == '6' && targetTriple[4] == '-' && targetTriple[1] - '3' < 6 )
+ return CPU_TYPE_I386;
+ else
+ return CPU_TYPE_ANY;
+}
+
+bool LLVMOptimizer::validArchitecture(const char *path, cpu_type_t architecture)
+{
+ std::string targetTriple;
+ fOptimizer->getTargetTriple(path, targetTriple);
+ if (architecture != getCpuType(targetTriple)) {
+ fOptimizer->removeModule(path);
+ return false;
+ }
+
+ return true;
+}
+
+void LLVMOptimizer::optimize(std::vector<ObjectFile::Atom*> &allAtoms, std::vector<ObjectFile::Atom*> &newAtoms, uint32_t nextInputOrdinal)
+{
+ if (fOptimized)
+ return;
+
+ char * tmp = "/tmp/ld64XXXXXXXX";
+ char * bigOfile = (char *) malloc (strlen (tmp) + 3);
+ if (!bigOfile)
+ throw "Unable to create temp file name";
+ strcpy (bigOfile, tmp);
+ mktemp (bigOfile);
+ strcat (bigOfile, ".o");
+
+ std::vector <const char *> exportList;
+ for (std::vector<ObjectFile::Atom*>::iterator it = allAtoms.begin(); it != allAtoms.end(); ++it) {
+ ObjectFile::Atom *atom = *it;
+ if (atom->getName()) {
+ ReaderToPathMapper::iterator pos = fLLVMReaders.find(atom->getFile()->getPath());
+ if (pos != fLLVMReaders.end())
+ exportList.push_back(atom->getName());
+ }
+
+ }
+
+ std::string targetTriple;
+ llvm::LTOStatus status = fOptimizer->optimizeModules(bigOfile, exportList, targetTriple, fOptions.saveTempFiles(), fOptions.getOutputFilePath());
+ if (status != llvm::LTO_OPT_SUCCESS) {
+ if (status == llvm::LTO_WRITE_FAILURE)
+ throw "Unable to write optimized output file";
+ if (status == llvm::LTO_ASM_FAILURE)
+ throw "Unable to assemble optimized output file";
+ if (status == llvm::LTO_MODULE_MERGE_FAILURE)
+ throw "Unable to merge bytecode files";
+ if (status == llvm::LTO_NO_TARGET)
+ throw "Unable to load target optimizer";
+ }
+ fOptimized = true;
+
+ Options::FileInfo info = fOptions.findFile (bigOfile);
+ ObjectFile::Reader* nr = NULL;
+ int fd = ::open(info.path, O_RDONLY, 0);
+ if ( fd == -1 )
+ throwf("can't open file, errno=%d", errno);
+ if ( info.fileLen < 20 )
+ throw "file too small";
+
+ uint8_t* p = (uint8_t*)::mmap(NULL, info.fileLen, PROT_READ, MAP_FILE | MAP_PRIVATE, fd, 0);
+ if ( p == (uint8_t*)(-1) )
+ throwf("can't map file, errno=%d", errno);
+
+ cpu_type_t cpt = getCpuType(targetTriple);
+ switch (cpt) {
+ case CPU_TYPE_POWERPC:
+ if ( mach_o::relocatable::Reader<ppc>::validFile(p) )
+ nr = new mach_o::relocatable::Reader<ppc>(p, info.path, info.modTime, fOptions.readerOptions(), nextInputOrdinal);
+ break;
+ case CPU_TYPE_POWERPC64:
+ if ( mach_o::relocatable::Reader<ppc64>::validFile(p) )
+ nr = new mach_o::relocatable::Reader<ppc64>(p, info.path, info.modTime, fOptions.readerOptions(), nextInputOrdinal);
+ break;
+ case CPU_TYPE_I386:
+ if ( mach_o::relocatable::Reader<x86>::validFile(p) )
+ nr = new mach_o::relocatable::Reader<x86>(p, info.path, info.modTime, fOptions.readerOptions(), nextInputOrdinal);
+ break;
+ default:
+ throw "file is not of required architecture";
+ break;
+ }
+
+ std::vector<class ObjectFile::Atom*> optimizedAtoms;
+ optimizedAtoms = nr->getAtoms();
+ reconcileOptimizedAtoms(optimizedAtoms, newAtoms);
+
+ allAtoms.erase(std::remove_if(allAtoms.begin(), allAtoms.end(), InIntercessorSet(fIntercessorAtoms)), allAtoms.end());
+ unlink(bigOfile);
+ free(bigOfile);
+}
+
+void LLVMOptimizer::read(ObjectFile::Reader *reader, const char *path, std::set<std::string> &references, std::vector<ObjectFile::Atom*> &atoms, const char *intercessorName)
+{
+ llvm::LinkTimeOptimizer::NameToSymbolMap symbols;
+ llvm::LTOStatus status = fOptimizer->readLLVMObjectFile (path, symbols, references);
+ if (status != llvm::LTO_READ_SUCCESS)
+ throw "Unable to read LLVM bytecode file";
+
+ for (llvm::LinkTimeOptimizer::NameToSymbolMap::iterator itr = symbols.begin();
+ itr != symbols.end(); itr++) {
+ const char *name = itr->first;
+ llvm::LLVMSymbol *ls = itr->second;
+ LLVMAtom *a = new LLVMAtom(reader, name, ls);
+
+ LLVMAtomToNameMapper::iterator pos = fLLVMSymbols.find(name);
+ bool insertNewAtom = true;
+ if (pos != fLLVMSymbols.end()) {
+ LLVMAtom *existingAtom = pos->second;
+ ObjectFile::Atom::DefinitionKind newDefKind = a->getDefinitionKind();
+ ObjectFile::Atom::DefinitionKind existingDefKind = existingAtom->getDefinitionKind();
+ if (newDefKind == ObjectFile::Atom::kRegularDefinition
+ && existingDefKind == ObjectFile::Atom::kRegularDefinition)
+ throwf ("duplicate symbol %s in %s and %s\n", name, a->getFile()->getPath(), existingAtom->getFile()->getPath());
+ else if (newDefKind == ObjectFile::Atom::kWeakDefinition
+ && existingDefKind == ObjectFile::Atom::kRegularDefinition)
+ insertNewAtom = false;
+ else if (newDefKind == ObjectFile::Atom::kWeakDefinition
+ && existingDefKind == ObjectFile::Atom::kWeakDefinition)
+ // pick one
+ insertNewAtom = false;
+ else if (newDefKind == ObjectFile::Atom::kRegularDefinition
+ && existingDefKind == ObjectFile::Atom::kWeakDefinition)
+ insertNewAtom = true;
+ }
+ if (insertNewAtom) {
+ atoms.push_back(a);
+ fLLVMSymbols[name] = a;
+ a->addReference(new LLVMReference (intercessorName));
+ }
+ }
+}
+
+void LLVMOptimizer::reconcileOptimizedAtoms(std::vector<class ObjectFile::Atom*>& optimizedAtoms,
+ std::vector<class ObjectFile::Atom*>& newAtoms)
+{
+ for (std::vector<ObjectFile::Atom *>::iterator itr = optimizedAtoms.begin();
+ itr != optimizedAtoms.end(); ++itr) {
+
+ ObjectFile::Atom* atom = *itr;
+ if (!atom->getName()) {
+ newAtoms.push_back(atom);
+ continue;
+ }
+
+ LLVMAtomToNameMapper::iterator pos = fLLVMSymbols.find(atom->getName());
+ if ( pos != fLLVMSymbols.end() ) {
+
+ LLVMAtom *la = fLLVMSymbols[atom->getName()];
+ la->setRealAtom(atom);
+
+ }
+ else
+ newAtoms.push_back(atom);
+ }
+}
+
+//
+// LLVM bytecode file reader
+//
+
+class LLVMReader : public ObjectFile::Reader
+{
+public:
+ static bool validFile(const uint8_t* fileContent, const char *path, cpu_type_t architecture, Options &opts);
+ static LLVMReader* make(const uint8_t* fileContent, const char* path, time_t modTime, Options& options)
+ { return new LLVMReader(fileContent, path, modTime, options); }
+ virtual ~LLVMReader();
+ 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; }
+
+ ObjectFile::Atom * retriveIntercessorAtom() { fAtoms.pop_back();return fIntercessorAtom; }
+ ObjectFile::Atom * getIntercessorAtom() { return fIntercessorAtom; }
+
+private:
+
+ LLVMReader(const uint8_t* fileContent, const char* path, time_t modTime, Options& options);
+ void optimize(std::vector<ObjectFile::Atom*>& allAtoms, std::vector<ObjectFile::Atom*> &newAtoms, uint32_t);
+
+ const char* fPath;
+ time_t fModTime;
+ std::vector<ObjectFile::Atom*> fAtoms;
+ IntercessorAtom * fIntercessorAtom;
+ static LLVMOptimizer *fOptimizer;
+ std::set<std::string> fLLVMReferences;
+};
+
+LLVMOptimizer *LLVMReader::fOptimizer = NULL;
+
+LLVMReader::~LLVMReader()
+{
+ if (fOptimizer)
+ delete fOptimizer;
+}
+
+LLVMReader::LLVMReader (const uint8_t* fileContent, const char *path, time_t modTime, Options& options)
+{
+
+ fPath = path;
+ fModTime = modTime;
+ fIntercessorAtom = new IntercessorAtom(this, fLLVMReferences);
+ fOptimizer->read(this, path, fLLVMReferences, fAtoms, fIntercessorAtom->getName());
+ fIntercessorAtom->addReferences(fLLVMReferences);
+ fAtoms.push_back(fIntercessorAtom);
+ fOptimizer->addIntercessor(fIntercessorAtom);
+ fOptimizer->addReader(this);
+}
+
+bool LLVMReader::validFile(const uint8_t* fileContent, const char *path, cpu_type_t architecture, Options &opts)
+{
+ if (fileContent[0] == 'l'
+ && fileContent[1] == 'l'
+ && fileContent[2] == 'v'
+ && (fileContent[3] == 'c' || fileContent[3] == 'm')) {
+
+ // create optimizer
+ if (!fOptimizer)
+ fOptimizer = new LLVMOptimizer(opts);
+
+ if (fOptimizer->validArchitecture(path, architecture))
+ return true;
+ }
+
+ return false;
+}
+
+void LLVMReader::optimize(std::vector<ObjectFile::Atom *> &allAtoms, std::vector<ObjectFile::Atom*> &newAtoms, uint32_t nextInputOrdinal)
+{
+ if (fOptimizer)
+ fOptimizer->optimize(allAtoms, newAtoms, nextInputOrdinal);
+}
+
+#endif
+
projects / apple / ld64.git / blobdiff