+++ /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