10b57cec5SDimitry Andric //===-- LTOModule.cpp - LLVM Link Time Optimizer --------------------------===// 20b57cec5SDimitry Andric // 30b57cec5SDimitry Andric // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 40b57cec5SDimitry Andric // See https://llvm.org/LICENSE.txt for license information. 50b57cec5SDimitry Andric // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 60b57cec5SDimitry Andric // 70b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 80b57cec5SDimitry Andric // 90b57cec5SDimitry Andric // This file implements the Link Time Optimization library. This library is 100b57cec5SDimitry Andric // intended to be used by linker to optimize code at link time. 110b57cec5SDimitry Andric // 120b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 130b57cec5SDimitry Andric 140b57cec5SDimitry Andric #include "llvm/LTO/legacy/LTOModule.h" 150b57cec5SDimitry Andric #include "llvm/ADT/Triple.h" 160b57cec5SDimitry Andric #include "llvm/Bitcode/BitcodeReader.h" 170b57cec5SDimitry Andric #include "llvm/CodeGen/TargetSubtargetInfo.h" 180b57cec5SDimitry Andric #include "llvm/IR/Constants.h" 190b57cec5SDimitry Andric #include "llvm/IR/LLVMContext.h" 200b57cec5SDimitry Andric #include "llvm/IR/Mangler.h" 210b57cec5SDimitry Andric #include "llvm/IR/Metadata.h" 220b57cec5SDimitry Andric #include "llvm/IR/Module.h" 230b57cec5SDimitry Andric #include "llvm/MC/MCExpr.h" 240b57cec5SDimitry Andric #include "llvm/MC/MCInst.h" 250b57cec5SDimitry Andric #include "llvm/MC/MCParser/MCAsmParser.h" 260b57cec5SDimitry Andric #include "llvm/MC/MCSection.h" 270b57cec5SDimitry Andric #include "llvm/MC/MCSubtargetInfo.h" 280b57cec5SDimitry Andric #include "llvm/MC/MCSymbol.h" 290b57cec5SDimitry Andric #include "llvm/MC/SubtargetFeature.h" 300b57cec5SDimitry Andric #include "llvm/Object/IRObjectFile.h" 315ffd83dbSDimitry Andric #include "llvm/Object/MachO.h" 320b57cec5SDimitry Andric #include "llvm/Object/ObjectFile.h" 330b57cec5SDimitry Andric #include "llvm/Support/FileSystem.h" 340b57cec5SDimitry Andric #include "llvm/Support/Host.h" 350b57cec5SDimitry Andric #include "llvm/Support/MemoryBuffer.h" 360b57cec5SDimitry Andric #include "llvm/Support/Path.h" 370b57cec5SDimitry Andric #include "llvm/Support/SourceMgr.h" 380b57cec5SDimitry Andric #include "llvm/Support/TargetRegistry.h" 390b57cec5SDimitry Andric #include "llvm/Support/TargetSelect.h" 400b57cec5SDimitry Andric #include "llvm/Target/TargetLoweringObjectFile.h" 410b57cec5SDimitry Andric #include "llvm/Transforms/Utils/GlobalStatus.h" 420b57cec5SDimitry Andric #include <system_error> 430b57cec5SDimitry Andric using namespace llvm; 440b57cec5SDimitry Andric using namespace llvm::object; 450b57cec5SDimitry Andric 460b57cec5SDimitry Andric LTOModule::LTOModule(std::unique_ptr<Module> M, MemoryBufferRef MBRef, 470b57cec5SDimitry Andric llvm::TargetMachine *TM) 480b57cec5SDimitry Andric : Mod(std::move(M)), MBRef(MBRef), _target(TM) { 490b57cec5SDimitry Andric SymTab.addModule(Mod.get()); 500b57cec5SDimitry Andric } 510b57cec5SDimitry Andric 520b57cec5SDimitry Andric LTOModule::~LTOModule() {} 530b57cec5SDimitry Andric 540b57cec5SDimitry Andric /// isBitcodeFile - Returns 'true' if the file (or memory contents) is LLVM 550b57cec5SDimitry Andric /// bitcode. 560b57cec5SDimitry Andric bool LTOModule::isBitcodeFile(const void *Mem, size_t Length) { 570b57cec5SDimitry Andric Expected<MemoryBufferRef> BCData = IRObjectFile::findBitcodeInMemBuffer( 580b57cec5SDimitry Andric MemoryBufferRef(StringRef((const char *)Mem, Length), "<mem>")); 590b57cec5SDimitry Andric return !errorToBool(BCData.takeError()); 600b57cec5SDimitry Andric } 610b57cec5SDimitry Andric 620b57cec5SDimitry Andric bool LTOModule::isBitcodeFile(StringRef Path) { 630b57cec5SDimitry Andric ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr = 640b57cec5SDimitry Andric MemoryBuffer::getFile(Path); 650b57cec5SDimitry Andric if (!BufferOrErr) 660b57cec5SDimitry Andric return false; 670b57cec5SDimitry Andric 680b57cec5SDimitry Andric Expected<MemoryBufferRef> BCData = IRObjectFile::findBitcodeInMemBuffer( 690b57cec5SDimitry Andric BufferOrErr.get()->getMemBufferRef()); 700b57cec5SDimitry Andric return !errorToBool(BCData.takeError()); 710b57cec5SDimitry Andric } 720b57cec5SDimitry Andric 730b57cec5SDimitry Andric bool LTOModule::isThinLTO() { 740b57cec5SDimitry Andric Expected<BitcodeLTOInfo> Result = getBitcodeLTOInfo(MBRef); 750b57cec5SDimitry Andric if (!Result) { 760b57cec5SDimitry Andric logAllUnhandledErrors(Result.takeError(), errs()); 770b57cec5SDimitry Andric return false; 780b57cec5SDimitry Andric } 790b57cec5SDimitry Andric return Result->IsThinLTO; 800b57cec5SDimitry Andric } 810b57cec5SDimitry Andric 820b57cec5SDimitry Andric bool LTOModule::isBitcodeForTarget(MemoryBuffer *Buffer, 830b57cec5SDimitry Andric StringRef TriplePrefix) { 840b57cec5SDimitry Andric Expected<MemoryBufferRef> BCOrErr = 850b57cec5SDimitry Andric IRObjectFile::findBitcodeInMemBuffer(Buffer->getMemBufferRef()); 860b57cec5SDimitry Andric if (errorToBool(BCOrErr.takeError())) 870b57cec5SDimitry Andric return false; 880b57cec5SDimitry Andric LLVMContext Context; 890b57cec5SDimitry Andric ErrorOr<std::string> TripleOrErr = 900b57cec5SDimitry Andric expectedToErrorOrAndEmitErrors(Context, getBitcodeTargetTriple(*BCOrErr)); 910b57cec5SDimitry Andric if (!TripleOrErr) 920b57cec5SDimitry Andric return false; 930b57cec5SDimitry Andric return StringRef(*TripleOrErr).startswith(TriplePrefix); 940b57cec5SDimitry Andric } 950b57cec5SDimitry Andric 960b57cec5SDimitry Andric std::string LTOModule::getProducerString(MemoryBuffer *Buffer) { 970b57cec5SDimitry Andric Expected<MemoryBufferRef> BCOrErr = 980b57cec5SDimitry Andric IRObjectFile::findBitcodeInMemBuffer(Buffer->getMemBufferRef()); 990b57cec5SDimitry Andric if (errorToBool(BCOrErr.takeError())) 1000b57cec5SDimitry Andric return ""; 1010b57cec5SDimitry Andric LLVMContext Context; 1020b57cec5SDimitry Andric ErrorOr<std::string> ProducerOrErr = expectedToErrorOrAndEmitErrors( 1030b57cec5SDimitry Andric Context, getBitcodeProducerString(*BCOrErr)); 1040b57cec5SDimitry Andric if (!ProducerOrErr) 1050b57cec5SDimitry Andric return ""; 1060b57cec5SDimitry Andric return *ProducerOrErr; 1070b57cec5SDimitry Andric } 1080b57cec5SDimitry Andric 1090b57cec5SDimitry Andric ErrorOr<std::unique_ptr<LTOModule>> 1100b57cec5SDimitry Andric LTOModule::createFromFile(LLVMContext &Context, StringRef path, 1110b57cec5SDimitry Andric const TargetOptions &options) { 1120b57cec5SDimitry Andric ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr = 1130b57cec5SDimitry Andric MemoryBuffer::getFile(path); 1140b57cec5SDimitry Andric if (std::error_code EC = BufferOrErr.getError()) { 1150b57cec5SDimitry Andric Context.emitError(EC.message()); 1160b57cec5SDimitry Andric return EC; 1170b57cec5SDimitry Andric } 1180b57cec5SDimitry Andric std::unique_ptr<MemoryBuffer> Buffer = std::move(BufferOrErr.get()); 1190b57cec5SDimitry Andric return makeLTOModule(Buffer->getMemBufferRef(), options, Context, 1200b57cec5SDimitry Andric /* ShouldBeLazy*/ false); 1210b57cec5SDimitry Andric } 1220b57cec5SDimitry Andric 1230b57cec5SDimitry Andric ErrorOr<std::unique_ptr<LTOModule>> 1240b57cec5SDimitry Andric LTOModule::createFromOpenFile(LLVMContext &Context, int fd, StringRef path, 1250b57cec5SDimitry Andric size_t size, const TargetOptions &options) { 1260b57cec5SDimitry Andric return createFromOpenFileSlice(Context, fd, path, size, 0, options); 1270b57cec5SDimitry Andric } 1280b57cec5SDimitry Andric 1290b57cec5SDimitry Andric ErrorOr<std::unique_ptr<LTOModule>> 1300b57cec5SDimitry Andric LTOModule::createFromOpenFileSlice(LLVMContext &Context, int fd, StringRef path, 1310b57cec5SDimitry Andric size_t map_size, off_t offset, 1320b57cec5SDimitry Andric const TargetOptions &options) { 1330b57cec5SDimitry Andric ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr = 1340b57cec5SDimitry Andric MemoryBuffer::getOpenFileSlice(sys::fs::convertFDToNativeFile(fd), path, 1350b57cec5SDimitry Andric map_size, offset); 1360b57cec5SDimitry Andric if (std::error_code EC = BufferOrErr.getError()) { 1370b57cec5SDimitry Andric Context.emitError(EC.message()); 1380b57cec5SDimitry Andric return EC; 1390b57cec5SDimitry Andric } 1400b57cec5SDimitry Andric std::unique_ptr<MemoryBuffer> Buffer = std::move(BufferOrErr.get()); 1410b57cec5SDimitry Andric return makeLTOModule(Buffer->getMemBufferRef(), options, Context, 1420b57cec5SDimitry Andric /* ShouldBeLazy */ false); 1430b57cec5SDimitry Andric } 1440b57cec5SDimitry Andric 1450b57cec5SDimitry Andric ErrorOr<std::unique_ptr<LTOModule>> 1460b57cec5SDimitry Andric LTOModule::createFromBuffer(LLVMContext &Context, const void *mem, 1470b57cec5SDimitry Andric size_t length, const TargetOptions &options, 1480b57cec5SDimitry Andric StringRef path) { 1490b57cec5SDimitry Andric StringRef Data((const char *)mem, length); 1500b57cec5SDimitry Andric MemoryBufferRef Buffer(Data, path); 1510b57cec5SDimitry Andric return makeLTOModule(Buffer, options, Context, /* ShouldBeLazy */ false); 1520b57cec5SDimitry Andric } 1530b57cec5SDimitry Andric 1540b57cec5SDimitry Andric ErrorOr<std::unique_ptr<LTOModule>> 1550b57cec5SDimitry Andric LTOModule::createInLocalContext(std::unique_ptr<LLVMContext> Context, 1560b57cec5SDimitry Andric const void *mem, size_t length, 1570b57cec5SDimitry Andric const TargetOptions &options, StringRef path) { 1580b57cec5SDimitry Andric StringRef Data((const char *)mem, length); 1590b57cec5SDimitry Andric MemoryBufferRef Buffer(Data, path); 1600b57cec5SDimitry Andric // If we own a context, we know this is being used only for symbol extraction, 1610b57cec5SDimitry Andric // not linking. Be lazy in that case. 1620b57cec5SDimitry Andric ErrorOr<std::unique_ptr<LTOModule>> Ret = 1630b57cec5SDimitry Andric makeLTOModule(Buffer, options, *Context, /* ShouldBeLazy */ true); 1640b57cec5SDimitry Andric if (Ret) 1650b57cec5SDimitry Andric (*Ret)->OwnedContext = std::move(Context); 1660b57cec5SDimitry Andric return Ret; 1670b57cec5SDimitry Andric } 1680b57cec5SDimitry Andric 1690b57cec5SDimitry Andric static ErrorOr<std::unique_ptr<Module>> 1700b57cec5SDimitry Andric parseBitcodeFileImpl(MemoryBufferRef Buffer, LLVMContext &Context, 1710b57cec5SDimitry Andric bool ShouldBeLazy) { 1720b57cec5SDimitry Andric // Find the buffer. 1730b57cec5SDimitry Andric Expected<MemoryBufferRef> MBOrErr = 1740b57cec5SDimitry Andric IRObjectFile::findBitcodeInMemBuffer(Buffer); 1750b57cec5SDimitry Andric if (Error E = MBOrErr.takeError()) { 1760b57cec5SDimitry Andric std::error_code EC = errorToErrorCode(std::move(E)); 1770b57cec5SDimitry Andric Context.emitError(EC.message()); 1780b57cec5SDimitry Andric return EC; 1790b57cec5SDimitry Andric } 1800b57cec5SDimitry Andric 1810b57cec5SDimitry Andric if (!ShouldBeLazy) { 1820b57cec5SDimitry Andric // Parse the full file. 1830b57cec5SDimitry Andric return expectedToErrorOrAndEmitErrors(Context, 1840b57cec5SDimitry Andric parseBitcodeFile(*MBOrErr, Context)); 1850b57cec5SDimitry Andric } 1860b57cec5SDimitry Andric 1870b57cec5SDimitry Andric // Parse lazily. 1880b57cec5SDimitry Andric return expectedToErrorOrAndEmitErrors( 1890b57cec5SDimitry Andric Context, 1900b57cec5SDimitry Andric getLazyBitcodeModule(*MBOrErr, Context, true /*ShouldLazyLoadMetadata*/)); 1910b57cec5SDimitry Andric } 1920b57cec5SDimitry Andric 1930b57cec5SDimitry Andric ErrorOr<std::unique_ptr<LTOModule>> 1940b57cec5SDimitry Andric LTOModule::makeLTOModule(MemoryBufferRef Buffer, const TargetOptions &options, 1950b57cec5SDimitry Andric LLVMContext &Context, bool ShouldBeLazy) { 1960b57cec5SDimitry Andric ErrorOr<std::unique_ptr<Module>> MOrErr = 1970b57cec5SDimitry Andric parseBitcodeFileImpl(Buffer, Context, ShouldBeLazy); 1980b57cec5SDimitry Andric if (std::error_code EC = MOrErr.getError()) 1990b57cec5SDimitry Andric return EC; 2000b57cec5SDimitry Andric std::unique_ptr<Module> &M = *MOrErr; 2010b57cec5SDimitry Andric 2020b57cec5SDimitry Andric std::string TripleStr = M->getTargetTriple(); 2030b57cec5SDimitry Andric if (TripleStr.empty()) 2040b57cec5SDimitry Andric TripleStr = sys::getDefaultTargetTriple(); 2050b57cec5SDimitry Andric llvm::Triple Triple(TripleStr); 2060b57cec5SDimitry Andric 2070b57cec5SDimitry Andric // find machine architecture for this module 2080b57cec5SDimitry Andric std::string errMsg; 2090b57cec5SDimitry Andric const Target *march = TargetRegistry::lookupTarget(TripleStr, errMsg); 2100b57cec5SDimitry Andric if (!march) 2110b57cec5SDimitry Andric return make_error_code(object::object_error::arch_not_found); 2120b57cec5SDimitry Andric 2130b57cec5SDimitry Andric // construct LTOModule, hand over ownership of module and target 2140b57cec5SDimitry Andric SubtargetFeatures Features; 2150b57cec5SDimitry Andric Features.getDefaultSubtargetFeatures(Triple); 2160b57cec5SDimitry Andric std::string FeatureStr = Features.getString(); 2170b57cec5SDimitry Andric // Set a default CPU for Darwin triples. 2180b57cec5SDimitry Andric std::string CPU; 2190b57cec5SDimitry Andric if (Triple.isOSDarwin()) { 2200b57cec5SDimitry Andric if (Triple.getArch() == llvm::Triple::x86_64) 2210b57cec5SDimitry Andric CPU = "core2"; 2220b57cec5SDimitry Andric else if (Triple.getArch() == llvm::Triple::x86) 2230b57cec5SDimitry Andric CPU = "yonah"; 2248bcb0991SDimitry Andric else if (Triple.getArch() == llvm::Triple::aarch64 || 2258bcb0991SDimitry Andric Triple.getArch() == llvm::Triple::aarch64_32) 2260b57cec5SDimitry Andric CPU = "cyclone"; 2270b57cec5SDimitry Andric } 2280b57cec5SDimitry Andric 2290b57cec5SDimitry Andric TargetMachine *target = 2300b57cec5SDimitry Andric march->createTargetMachine(TripleStr, CPU, FeatureStr, options, None); 2310b57cec5SDimitry Andric 2320b57cec5SDimitry Andric std::unique_ptr<LTOModule> Ret(new LTOModule(std::move(M), Buffer, target)); 2330b57cec5SDimitry Andric Ret->parseSymbols(); 2340b57cec5SDimitry Andric Ret->parseMetadata(); 2350b57cec5SDimitry Andric 2360b57cec5SDimitry Andric return std::move(Ret); 2370b57cec5SDimitry Andric } 2380b57cec5SDimitry Andric 2390b57cec5SDimitry Andric /// Create a MemoryBuffer from a memory range with an optional name. 2400b57cec5SDimitry Andric std::unique_ptr<MemoryBuffer> 2410b57cec5SDimitry Andric LTOModule::makeBuffer(const void *mem, size_t length, StringRef name) { 2420b57cec5SDimitry Andric const char *startPtr = (const char*)mem; 2430b57cec5SDimitry Andric return MemoryBuffer::getMemBuffer(StringRef(startPtr, length), name, false); 2440b57cec5SDimitry Andric } 2450b57cec5SDimitry Andric 2460b57cec5SDimitry Andric /// objcClassNameFromExpression - Get string that the data pointer points to. 2470b57cec5SDimitry Andric bool 2480b57cec5SDimitry Andric LTOModule::objcClassNameFromExpression(const Constant *c, std::string &name) { 2490b57cec5SDimitry Andric if (const ConstantExpr *ce = dyn_cast<ConstantExpr>(c)) { 2500b57cec5SDimitry Andric Constant *op = ce->getOperand(0); 2510b57cec5SDimitry Andric if (GlobalVariable *gvn = dyn_cast<GlobalVariable>(op)) { 2520b57cec5SDimitry Andric Constant *cn = gvn->getInitializer(); 2530b57cec5SDimitry Andric if (ConstantDataArray *ca = dyn_cast<ConstantDataArray>(cn)) { 2540b57cec5SDimitry Andric if (ca->isCString()) { 2550b57cec5SDimitry Andric name = (".objc_class_name_" + ca->getAsCString()).str(); 2560b57cec5SDimitry Andric return true; 2570b57cec5SDimitry Andric } 2580b57cec5SDimitry Andric } 2590b57cec5SDimitry Andric } 2600b57cec5SDimitry Andric } 2610b57cec5SDimitry Andric return false; 2620b57cec5SDimitry Andric } 2630b57cec5SDimitry Andric 2640b57cec5SDimitry Andric /// addObjCClass - Parse i386/ppc ObjC class data structure. 2650b57cec5SDimitry Andric void LTOModule::addObjCClass(const GlobalVariable *clgv) { 2660b57cec5SDimitry Andric const ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer()); 2670b57cec5SDimitry Andric if (!c) return; 2680b57cec5SDimitry Andric 2690b57cec5SDimitry Andric // second slot in __OBJC,__class is pointer to superclass name 2700b57cec5SDimitry Andric std::string superclassName; 2710b57cec5SDimitry Andric if (objcClassNameFromExpression(c->getOperand(1), superclassName)) { 2720b57cec5SDimitry Andric auto IterBool = 2730b57cec5SDimitry Andric _undefines.insert(std::make_pair(superclassName, NameAndAttributes())); 2740b57cec5SDimitry Andric if (IterBool.second) { 2750b57cec5SDimitry Andric NameAndAttributes &info = IterBool.first->second; 2760b57cec5SDimitry Andric info.name = IterBool.first->first(); 2770b57cec5SDimitry Andric info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED; 2780b57cec5SDimitry Andric info.isFunction = false; 2790b57cec5SDimitry Andric info.symbol = clgv; 2800b57cec5SDimitry Andric } 2810b57cec5SDimitry Andric } 2820b57cec5SDimitry Andric 2830b57cec5SDimitry Andric // third slot in __OBJC,__class is pointer to class name 2840b57cec5SDimitry Andric std::string className; 2850b57cec5SDimitry Andric if (objcClassNameFromExpression(c->getOperand(2), className)) { 2860b57cec5SDimitry Andric auto Iter = _defines.insert(className).first; 2870b57cec5SDimitry Andric 2880b57cec5SDimitry Andric NameAndAttributes info; 2890b57cec5SDimitry Andric info.name = Iter->first(); 2900b57cec5SDimitry Andric info.attributes = LTO_SYMBOL_PERMISSIONS_DATA | 2910b57cec5SDimitry Andric LTO_SYMBOL_DEFINITION_REGULAR | LTO_SYMBOL_SCOPE_DEFAULT; 2920b57cec5SDimitry Andric info.isFunction = false; 2930b57cec5SDimitry Andric info.symbol = clgv; 2940b57cec5SDimitry Andric _symbols.push_back(info); 2950b57cec5SDimitry Andric } 2960b57cec5SDimitry Andric } 2970b57cec5SDimitry Andric 2980b57cec5SDimitry Andric /// addObjCCategory - Parse i386/ppc ObjC category data structure. 2990b57cec5SDimitry Andric void LTOModule::addObjCCategory(const GlobalVariable *clgv) { 3000b57cec5SDimitry Andric const ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer()); 3010b57cec5SDimitry Andric if (!c) return; 3020b57cec5SDimitry Andric 3030b57cec5SDimitry Andric // second slot in __OBJC,__category is pointer to target class name 3040b57cec5SDimitry Andric std::string targetclassName; 3050b57cec5SDimitry Andric if (!objcClassNameFromExpression(c->getOperand(1), targetclassName)) 3060b57cec5SDimitry Andric return; 3070b57cec5SDimitry Andric 3080b57cec5SDimitry Andric auto IterBool = 3090b57cec5SDimitry Andric _undefines.insert(std::make_pair(targetclassName, NameAndAttributes())); 3100b57cec5SDimitry Andric 3110b57cec5SDimitry Andric if (!IterBool.second) 3120b57cec5SDimitry Andric return; 3130b57cec5SDimitry Andric 3140b57cec5SDimitry Andric NameAndAttributes &info = IterBool.first->second; 3150b57cec5SDimitry Andric info.name = IterBool.first->first(); 3160b57cec5SDimitry Andric info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED; 3170b57cec5SDimitry Andric info.isFunction = false; 3180b57cec5SDimitry Andric info.symbol = clgv; 3190b57cec5SDimitry Andric } 3200b57cec5SDimitry Andric 3210b57cec5SDimitry Andric /// addObjCClassRef - Parse i386/ppc ObjC class list data structure. 3220b57cec5SDimitry Andric void LTOModule::addObjCClassRef(const GlobalVariable *clgv) { 3230b57cec5SDimitry Andric std::string targetclassName; 3240b57cec5SDimitry Andric if (!objcClassNameFromExpression(clgv->getInitializer(), targetclassName)) 3250b57cec5SDimitry Andric return; 3260b57cec5SDimitry Andric 3270b57cec5SDimitry Andric auto IterBool = 3280b57cec5SDimitry Andric _undefines.insert(std::make_pair(targetclassName, NameAndAttributes())); 3290b57cec5SDimitry Andric 3300b57cec5SDimitry Andric if (!IterBool.second) 3310b57cec5SDimitry Andric return; 3320b57cec5SDimitry Andric 3330b57cec5SDimitry Andric NameAndAttributes &info = IterBool.first->second; 3340b57cec5SDimitry Andric info.name = IterBool.first->first(); 3350b57cec5SDimitry Andric info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED; 3360b57cec5SDimitry Andric info.isFunction = false; 3370b57cec5SDimitry Andric info.symbol = clgv; 3380b57cec5SDimitry Andric } 3390b57cec5SDimitry Andric 3400b57cec5SDimitry Andric void LTOModule::addDefinedDataSymbol(ModuleSymbolTable::Symbol Sym) { 3410b57cec5SDimitry Andric SmallString<64> Buffer; 3420b57cec5SDimitry Andric { 3430b57cec5SDimitry Andric raw_svector_ostream OS(Buffer); 3440b57cec5SDimitry Andric SymTab.printSymbolName(OS, Sym); 3450b57cec5SDimitry Andric Buffer.c_str(); 3460b57cec5SDimitry Andric } 3470b57cec5SDimitry Andric 3480b57cec5SDimitry Andric const GlobalValue *V = Sym.get<GlobalValue *>(); 3490b57cec5SDimitry Andric addDefinedDataSymbol(Buffer, V); 3500b57cec5SDimitry Andric } 3510b57cec5SDimitry Andric 3520b57cec5SDimitry Andric void LTOModule::addDefinedDataSymbol(StringRef Name, const GlobalValue *v) { 3530b57cec5SDimitry Andric // Add to list of defined symbols. 3540b57cec5SDimitry Andric addDefinedSymbol(Name, v, false); 3550b57cec5SDimitry Andric 3560b57cec5SDimitry Andric if (!v->hasSection() /* || !isTargetDarwin */) 3570b57cec5SDimitry Andric return; 3580b57cec5SDimitry Andric 3590b57cec5SDimitry Andric // Special case i386/ppc ObjC data structures in magic sections: 3600b57cec5SDimitry Andric // The issue is that the old ObjC object format did some strange 3610b57cec5SDimitry Andric // contortions to avoid real linker symbols. For instance, the 3620b57cec5SDimitry Andric // ObjC class data structure is allocated statically in the executable 3630b57cec5SDimitry Andric // that defines that class. That data structures contains a pointer to 3640b57cec5SDimitry Andric // its superclass. But instead of just initializing that part of the 3650b57cec5SDimitry Andric // struct to the address of its superclass, and letting the static and 3660b57cec5SDimitry Andric // dynamic linkers do the rest, the runtime works by having that field 3670b57cec5SDimitry Andric // instead point to a C-string that is the name of the superclass. 3680b57cec5SDimitry Andric // At runtime the objc initialization updates that pointer and sets 3690b57cec5SDimitry Andric // it to point to the actual super class. As far as the linker 3700b57cec5SDimitry Andric // knows it is just a pointer to a string. But then someone wanted the 3710b57cec5SDimitry Andric // linker to issue errors at build time if the superclass was not found. 3720b57cec5SDimitry Andric // So they figured out a way in mach-o object format to use an absolute 3730b57cec5SDimitry Andric // symbols (.objc_class_name_Foo = 0) and a floating reference 3740b57cec5SDimitry Andric // (.reference .objc_class_name_Bar) to cause the linker into erroring when 3750b57cec5SDimitry Andric // a class was missing. 3760b57cec5SDimitry Andric // The following synthesizes the implicit .objc_* symbols for the linker 3770b57cec5SDimitry Andric // from the ObjC data structures generated by the front end. 3780b57cec5SDimitry Andric 3790b57cec5SDimitry Andric // special case if this data blob is an ObjC class definition 3800b57cec5SDimitry Andric if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(v)) { 3810b57cec5SDimitry Andric StringRef Section = GV->getSection(); 3820b57cec5SDimitry Andric if (Section.startswith("__OBJC,__class,")) { 3830b57cec5SDimitry Andric addObjCClass(GV); 3840b57cec5SDimitry Andric } 3850b57cec5SDimitry Andric 3860b57cec5SDimitry Andric // special case if this data blob is an ObjC category definition 3870b57cec5SDimitry Andric else if (Section.startswith("__OBJC,__category,")) { 3880b57cec5SDimitry Andric addObjCCategory(GV); 3890b57cec5SDimitry Andric } 3900b57cec5SDimitry Andric 3910b57cec5SDimitry Andric // special case if this data blob is the list of referenced classes 3920b57cec5SDimitry Andric else if (Section.startswith("__OBJC,__cls_refs,")) { 3930b57cec5SDimitry Andric addObjCClassRef(GV); 3940b57cec5SDimitry Andric } 3950b57cec5SDimitry Andric } 3960b57cec5SDimitry Andric } 3970b57cec5SDimitry Andric 3980b57cec5SDimitry Andric void LTOModule::addDefinedFunctionSymbol(ModuleSymbolTable::Symbol Sym) { 3990b57cec5SDimitry Andric SmallString<64> Buffer; 4000b57cec5SDimitry Andric { 4010b57cec5SDimitry Andric raw_svector_ostream OS(Buffer); 4020b57cec5SDimitry Andric SymTab.printSymbolName(OS, Sym); 4030b57cec5SDimitry Andric Buffer.c_str(); 4040b57cec5SDimitry Andric } 4050b57cec5SDimitry Andric 4060b57cec5SDimitry Andric const Function *F = cast<Function>(Sym.get<GlobalValue *>()); 4070b57cec5SDimitry Andric addDefinedFunctionSymbol(Buffer, F); 4080b57cec5SDimitry Andric } 4090b57cec5SDimitry Andric 4100b57cec5SDimitry Andric void LTOModule::addDefinedFunctionSymbol(StringRef Name, const Function *F) { 4110b57cec5SDimitry Andric // add to list of defined symbols 4120b57cec5SDimitry Andric addDefinedSymbol(Name, F, true); 4130b57cec5SDimitry Andric } 4140b57cec5SDimitry Andric 4150b57cec5SDimitry Andric void LTOModule::addDefinedSymbol(StringRef Name, const GlobalValue *def, 4160b57cec5SDimitry Andric bool isFunction) { 4175ffd83dbSDimitry Andric const GlobalObject *go = dyn_cast<GlobalObject>(def); 4185ffd83dbSDimitry Andric uint32_t attr = go ? Log2(go->getAlign().valueOrOne()) : 0; 4190b57cec5SDimitry Andric 4200b57cec5SDimitry Andric // set permissions part 4210b57cec5SDimitry Andric if (isFunction) { 4220b57cec5SDimitry Andric attr |= LTO_SYMBOL_PERMISSIONS_CODE; 4230b57cec5SDimitry Andric } else { 4240b57cec5SDimitry Andric const GlobalVariable *gv = dyn_cast<GlobalVariable>(def); 4250b57cec5SDimitry Andric if (gv && gv->isConstant()) 4260b57cec5SDimitry Andric attr |= LTO_SYMBOL_PERMISSIONS_RODATA; 4270b57cec5SDimitry Andric else 4280b57cec5SDimitry Andric attr |= LTO_SYMBOL_PERMISSIONS_DATA; 4290b57cec5SDimitry Andric } 4300b57cec5SDimitry Andric 4310b57cec5SDimitry Andric // set definition part 4320b57cec5SDimitry Andric if (def->hasWeakLinkage() || def->hasLinkOnceLinkage()) 4330b57cec5SDimitry Andric attr |= LTO_SYMBOL_DEFINITION_WEAK; 4340b57cec5SDimitry Andric else if (def->hasCommonLinkage()) 4350b57cec5SDimitry Andric attr |= LTO_SYMBOL_DEFINITION_TENTATIVE; 4360b57cec5SDimitry Andric else 4370b57cec5SDimitry Andric attr |= LTO_SYMBOL_DEFINITION_REGULAR; 4380b57cec5SDimitry Andric 4390b57cec5SDimitry Andric // set scope part 4400b57cec5SDimitry Andric if (def->hasLocalLinkage()) 4410b57cec5SDimitry Andric // Ignore visibility if linkage is local. 4420b57cec5SDimitry Andric attr |= LTO_SYMBOL_SCOPE_INTERNAL; 4430b57cec5SDimitry Andric else if (def->hasHiddenVisibility()) 4440b57cec5SDimitry Andric attr |= LTO_SYMBOL_SCOPE_HIDDEN; 4450b57cec5SDimitry Andric else if (def->hasProtectedVisibility()) 4460b57cec5SDimitry Andric attr |= LTO_SYMBOL_SCOPE_PROTECTED; 4470b57cec5SDimitry Andric else if (def->canBeOmittedFromSymbolTable()) 4480b57cec5SDimitry Andric attr |= LTO_SYMBOL_SCOPE_DEFAULT_CAN_BE_HIDDEN; 4490b57cec5SDimitry Andric else 4500b57cec5SDimitry Andric attr |= LTO_SYMBOL_SCOPE_DEFAULT; 4510b57cec5SDimitry Andric 4520b57cec5SDimitry Andric if (def->hasComdat()) 4530b57cec5SDimitry Andric attr |= LTO_SYMBOL_COMDAT; 4540b57cec5SDimitry Andric 4550b57cec5SDimitry Andric if (isa<GlobalAlias>(def)) 4560b57cec5SDimitry Andric attr |= LTO_SYMBOL_ALIAS; 4570b57cec5SDimitry Andric 4580b57cec5SDimitry Andric auto Iter = _defines.insert(Name).first; 4590b57cec5SDimitry Andric 4600b57cec5SDimitry Andric // fill information structure 4610b57cec5SDimitry Andric NameAndAttributes info; 4620b57cec5SDimitry Andric StringRef NameRef = Iter->first(); 4630b57cec5SDimitry Andric info.name = NameRef; 4640b57cec5SDimitry Andric assert(NameRef.data()[NameRef.size()] == '\0'); 4650b57cec5SDimitry Andric info.attributes = attr; 4660b57cec5SDimitry Andric info.isFunction = isFunction; 4670b57cec5SDimitry Andric info.symbol = def; 4680b57cec5SDimitry Andric 4690b57cec5SDimitry Andric // add to table of symbols 4700b57cec5SDimitry Andric _symbols.push_back(info); 4710b57cec5SDimitry Andric } 4720b57cec5SDimitry Andric 4730b57cec5SDimitry Andric /// addAsmGlobalSymbol - Add a global symbol from module-level ASM to the 4740b57cec5SDimitry Andric /// defined list. 4750b57cec5SDimitry Andric void LTOModule::addAsmGlobalSymbol(StringRef name, 4760b57cec5SDimitry Andric lto_symbol_attributes scope) { 4770b57cec5SDimitry Andric auto IterBool = _defines.insert(name); 4780b57cec5SDimitry Andric 4790b57cec5SDimitry Andric // only add new define if not already defined 4800b57cec5SDimitry Andric if (!IterBool.second) 4810b57cec5SDimitry Andric return; 4820b57cec5SDimitry Andric 4830b57cec5SDimitry Andric NameAndAttributes &info = _undefines[IterBool.first->first()]; 4840b57cec5SDimitry Andric 4850b57cec5SDimitry Andric if (info.symbol == nullptr) { 4860b57cec5SDimitry Andric // FIXME: This is trying to take care of module ASM like this: 4870b57cec5SDimitry Andric // 4880b57cec5SDimitry Andric // module asm ".zerofill __FOO, __foo, _bar_baz_qux, 0" 4890b57cec5SDimitry Andric // 4900b57cec5SDimitry Andric // but is gross and its mother dresses it funny. Have the ASM parser give us 4910b57cec5SDimitry Andric // more details for this type of situation so that we're not guessing so 4920b57cec5SDimitry Andric // much. 4930b57cec5SDimitry Andric 4940b57cec5SDimitry Andric // fill information structure 4950b57cec5SDimitry Andric info.name = IterBool.first->first(); 4960b57cec5SDimitry Andric info.attributes = 4970b57cec5SDimitry Andric LTO_SYMBOL_PERMISSIONS_DATA | LTO_SYMBOL_DEFINITION_REGULAR | scope; 4980b57cec5SDimitry Andric info.isFunction = false; 4990b57cec5SDimitry Andric info.symbol = nullptr; 5000b57cec5SDimitry Andric 5010b57cec5SDimitry Andric // add to table of symbols 5020b57cec5SDimitry Andric _symbols.push_back(info); 5030b57cec5SDimitry Andric return; 5040b57cec5SDimitry Andric } 5050b57cec5SDimitry Andric 5060b57cec5SDimitry Andric if (info.isFunction) 5070b57cec5SDimitry Andric addDefinedFunctionSymbol(info.name, cast<Function>(info.symbol)); 5080b57cec5SDimitry Andric else 5090b57cec5SDimitry Andric addDefinedDataSymbol(info.name, info.symbol); 5100b57cec5SDimitry Andric 5110b57cec5SDimitry Andric _symbols.back().attributes &= ~LTO_SYMBOL_SCOPE_MASK; 5120b57cec5SDimitry Andric _symbols.back().attributes |= scope; 5130b57cec5SDimitry Andric } 5140b57cec5SDimitry Andric 5150b57cec5SDimitry Andric /// addAsmGlobalSymbolUndef - Add a global symbol from module-level ASM to the 5160b57cec5SDimitry Andric /// undefined list. 5170b57cec5SDimitry Andric void LTOModule::addAsmGlobalSymbolUndef(StringRef name) { 5180b57cec5SDimitry Andric auto IterBool = _undefines.insert(std::make_pair(name, NameAndAttributes())); 5190b57cec5SDimitry Andric 5200b57cec5SDimitry Andric _asm_undefines.push_back(IterBool.first->first()); 5210b57cec5SDimitry Andric 5220b57cec5SDimitry Andric // we already have the symbol 5230b57cec5SDimitry Andric if (!IterBool.second) 5240b57cec5SDimitry Andric return; 5250b57cec5SDimitry Andric 5260b57cec5SDimitry Andric uint32_t attr = LTO_SYMBOL_DEFINITION_UNDEFINED; 5270b57cec5SDimitry Andric attr |= LTO_SYMBOL_SCOPE_DEFAULT; 5280b57cec5SDimitry Andric NameAndAttributes &info = IterBool.first->second; 5290b57cec5SDimitry Andric info.name = IterBool.first->first(); 5300b57cec5SDimitry Andric info.attributes = attr; 5310b57cec5SDimitry Andric info.isFunction = false; 5320b57cec5SDimitry Andric info.symbol = nullptr; 5330b57cec5SDimitry Andric } 5340b57cec5SDimitry Andric 5350b57cec5SDimitry Andric /// Add a symbol which isn't defined just yet to a list to be resolved later. 5360b57cec5SDimitry Andric void LTOModule::addPotentialUndefinedSymbol(ModuleSymbolTable::Symbol Sym, 5370b57cec5SDimitry Andric bool isFunc) { 5380b57cec5SDimitry Andric SmallString<64> name; 5390b57cec5SDimitry Andric { 5400b57cec5SDimitry Andric raw_svector_ostream OS(name); 5410b57cec5SDimitry Andric SymTab.printSymbolName(OS, Sym); 5420b57cec5SDimitry Andric name.c_str(); 5430b57cec5SDimitry Andric } 5440b57cec5SDimitry Andric 5450b57cec5SDimitry Andric auto IterBool = _undefines.insert(std::make_pair(name, NameAndAttributes())); 5460b57cec5SDimitry Andric 5470b57cec5SDimitry Andric // we already have the symbol 5480b57cec5SDimitry Andric if (!IterBool.second) 5490b57cec5SDimitry Andric return; 5500b57cec5SDimitry Andric 5510b57cec5SDimitry Andric NameAndAttributes &info = IterBool.first->second; 5520b57cec5SDimitry Andric 5530b57cec5SDimitry Andric info.name = IterBool.first->first(); 5540b57cec5SDimitry Andric 5550b57cec5SDimitry Andric const GlobalValue *decl = Sym.dyn_cast<GlobalValue *>(); 5560b57cec5SDimitry Andric 5570b57cec5SDimitry Andric if (decl->hasExternalWeakLinkage()) 5580b57cec5SDimitry Andric info.attributes = LTO_SYMBOL_DEFINITION_WEAKUNDEF; 5590b57cec5SDimitry Andric else 5600b57cec5SDimitry Andric info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED; 5610b57cec5SDimitry Andric 5620b57cec5SDimitry Andric info.isFunction = isFunc; 5630b57cec5SDimitry Andric info.symbol = decl; 5640b57cec5SDimitry Andric } 5650b57cec5SDimitry Andric 5660b57cec5SDimitry Andric void LTOModule::parseSymbols() { 5670b57cec5SDimitry Andric for (auto Sym : SymTab.symbols()) { 5680b57cec5SDimitry Andric auto *GV = Sym.dyn_cast<GlobalValue *>(); 5690b57cec5SDimitry Andric uint32_t Flags = SymTab.getSymbolFlags(Sym); 5700b57cec5SDimitry Andric if (Flags & object::BasicSymbolRef::SF_FormatSpecific) 5710b57cec5SDimitry Andric continue; 5720b57cec5SDimitry Andric 5730b57cec5SDimitry Andric bool IsUndefined = Flags & object::BasicSymbolRef::SF_Undefined; 5740b57cec5SDimitry Andric 5750b57cec5SDimitry Andric if (!GV) { 5760b57cec5SDimitry Andric SmallString<64> Buffer; 5770b57cec5SDimitry Andric { 5780b57cec5SDimitry Andric raw_svector_ostream OS(Buffer); 5790b57cec5SDimitry Andric SymTab.printSymbolName(OS, Sym); 5800b57cec5SDimitry Andric Buffer.c_str(); 5810b57cec5SDimitry Andric } 5820b57cec5SDimitry Andric StringRef Name(Buffer); 5830b57cec5SDimitry Andric 5840b57cec5SDimitry Andric if (IsUndefined) 5850b57cec5SDimitry Andric addAsmGlobalSymbolUndef(Name); 5860b57cec5SDimitry Andric else if (Flags & object::BasicSymbolRef::SF_Global) 5870b57cec5SDimitry Andric addAsmGlobalSymbol(Name, LTO_SYMBOL_SCOPE_DEFAULT); 5880b57cec5SDimitry Andric else 5890b57cec5SDimitry Andric addAsmGlobalSymbol(Name, LTO_SYMBOL_SCOPE_INTERNAL); 5900b57cec5SDimitry Andric continue; 5910b57cec5SDimitry Andric } 5920b57cec5SDimitry Andric 5930b57cec5SDimitry Andric auto *F = dyn_cast<Function>(GV); 5940b57cec5SDimitry Andric if (IsUndefined) { 5950b57cec5SDimitry Andric addPotentialUndefinedSymbol(Sym, F != nullptr); 5960b57cec5SDimitry Andric continue; 5970b57cec5SDimitry Andric } 5980b57cec5SDimitry Andric 5990b57cec5SDimitry Andric if (F) { 6000b57cec5SDimitry Andric addDefinedFunctionSymbol(Sym); 6010b57cec5SDimitry Andric continue; 6020b57cec5SDimitry Andric } 6030b57cec5SDimitry Andric 6040b57cec5SDimitry Andric if (isa<GlobalVariable>(GV)) { 6050b57cec5SDimitry Andric addDefinedDataSymbol(Sym); 6060b57cec5SDimitry Andric continue; 6070b57cec5SDimitry Andric } 6080b57cec5SDimitry Andric 6090b57cec5SDimitry Andric assert(isa<GlobalAlias>(GV)); 6100b57cec5SDimitry Andric addDefinedDataSymbol(Sym); 6110b57cec5SDimitry Andric } 6120b57cec5SDimitry Andric 6130b57cec5SDimitry Andric // make symbols for all undefines 6140b57cec5SDimitry Andric for (StringMap<NameAndAttributes>::iterator u =_undefines.begin(), 6150b57cec5SDimitry Andric e = _undefines.end(); u != e; ++u) { 6160b57cec5SDimitry Andric // If this symbol also has a definition, then don't make an undefine because 6170b57cec5SDimitry Andric // it is a tentative definition. 6180b57cec5SDimitry Andric if (_defines.count(u->getKey())) continue; 6190b57cec5SDimitry Andric NameAndAttributes info = u->getValue(); 6200b57cec5SDimitry Andric _symbols.push_back(info); 6210b57cec5SDimitry Andric } 6220b57cec5SDimitry Andric } 6230b57cec5SDimitry Andric 6240b57cec5SDimitry Andric /// parseMetadata - Parse metadata from the module 6250b57cec5SDimitry Andric void LTOModule::parseMetadata() { 6260b57cec5SDimitry Andric raw_string_ostream OS(LinkerOpts); 6270b57cec5SDimitry Andric 6280b57cec5SDimitry Andric // Linker Options 6290b57cec5SDimitry Andric if (NamedMDNode *LinkerOptions = 6300b57cec5SDimitry Andric getModule().getNamedMetadata("llvm.linker.options")) { 6310b57cec5SDimitry Andric for (unsigned i = 0, e = LinkerOptions->getNumOperands(); i != e; ++i) { 6320b57cec5SDimitry Andric MDNode *MDOptions = LinkerOptions->getOperand(i); 6330b57cec5SDimitry Andric for (unsigned ii = 0, ie = MDOptions->getNumOperands(); ii != ie; ++ii) { 6340b57cec5SDimitry Andric MDString *MDOption = cast<MDString>(MDOptions->getOperand(ii)); 6350b57cec5SDimitry Andric OS << " " << MDOption->getString(); 6360b57cec5SDimitry Andric } 6370b57cec5SDimitry Andric } 6380b57cec5SDimitry Andric } 6390b57cec5SDimitry Andric 6400b57cec5SDimitry Andric // Globals - we only need to do this for COFF. 6410b57cec5SDimitry Andric const Triple TT(_target->getTargetTriple()); 6420b57cec5SDimitry Andric if (!TT.isOSBinFormatCOFF()) 6430b57cec5SDimitry Andric return; 6440b57cec5SDimitry Andric Mangler M; 6450b57cec5SDimitry Andric for (const NameAndAttributes &Sym : _symbols) { 6460b57cec5SDimitry Andric if (!Sym.symbol) 6470b57cec5SDimitry Andric continue; 6480b57cec5SDimitry Andric emitLinkerFlagsForGlobalCOFF(OS, Sym.symbol, TT, M); 6490b57cec5SDimitry Andric } 6500b57cec5SDimitry Andric } 6510b57cec5SDimitry Andric 6520b57cec5SDimitry Andric lto::InputFile *LTOModule::createInputFile(const void *buffer, 6530b57cec5SDimitry Andric size_t buffer_size, const char *path, 6540b57cec5SDimitry Andric std::string &outErr) { 6550b57cec5SDimitry Andric StringRef Data((const char *)buffer, buffer_size); 6560b57cec5SDimitry Andric MemoryBufferRef BufferRef(Data, path); 6570b57cec5SDimitry Andric 6580b57cec5SDimitry Andric Expected<std::unique_ptr<lto::InputFile>> ObjOrErr = 6590b57cec5SDimitry Andric lto::InputFile::create(BufferRef); 6600b57cec5SDimitry Andric 6610b57cec5SDimitry Andric if (ObjOrErr) 6620b57cec5SDimitry Andric return ObjOrErr->release(); 6630b57cec5SDimitry Andric 6640b57cec5SDimitry Andric outErr = std::string(path) + 6650b57cec5SDimitry Andric ": Could not read LTO input file: " + toString(ObjOrErr.takeError()); 6660b57cec5SDimitry Andric return nullptr; 6670b57cec5SDimitry Andric } 6680b57cec5SDimitry Andric 6690b57cec5SDimitry Andric size_t LTOModule::getDependentLibraryCount(lto::InputFile *input) { 6700b57cec5SDimitry Andric return input->getDependentLibraries().size(); 6710b57cec5SDimitry Andric } 6720b57cec5SDimitry Andric 6730b57cec5SDimitry Andric const char *LTOModule::getDependentLibrary(lto::InputFile *input, size_t index, 6740b57cec5SDimitry Andric size_t *size) { 6750b57cec5SDimitry Andric StringRef S = input->getDependentLibraries()[index]; 6760b57cec5SDimitry Andric *size = S.size(); 6770b57cec5SDimitry Andric return S.data(); 6780b57cec5SDimitry Andric } 6795ffd83dbSDimitry Andric 6805ffd83dbSDimitry Andric Expected<uint32_t> LTOModule::getMachOCPUType() const { 6815ffd83dbSDimitry Andric return MachO::getCPUType(Triple(Mod->getTargetTriple())); 6825ffd83dbSDimitry Andric } 6835ffd83dbSDimitry Andric 6845ffd83dbSDimitry Andric Expected<uint32_t> LTOModule::getMachOCPUSubType() const { 6855ffd83dbSDimitry Andric return MachO::getCPUSubType(Triple(Mod->getTargetTriple())); 6865ffd83dbSDimitry Andric } 687