Chris Lattner | 2eff505 | 2010-03-12 18:44:54 +0000 | [diff] [blame] | 1 | //===-- LTOModule.cpp - LLVM Link Time Optimizer --------------------------===// |
Nick Kledzik | 07b4a62 | 2008-02-26 20:26:43 +0000 | [diff] [blame] | 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 7 | // |
Nick Kledzik | 07b4a62 | 2008-02-26 20:26:43 +0000 | [diff] [blame] | 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 10 | // This file implements the Link Time Optimization library. This library is |
Nick Kledzik | 07b4a62 | 2008-02-26 20:26:43 +0000 | [diff] [blame] | 11 | // intended to be used by linker to optimize code at link time. |
| 12 | // |
| 13 | //===----------------------------------------------------------------------===// |
| 14 | |
Peter Collingbourne | 4ccf0f1 | 2013-09-24 23:52:22 +0000 | [diff] [blame] | 15 | #include "llvm/LTO/LTOModule.h" |
Chandler Carruth | 4d88a1c | 2012-12-04 10:44:52 +0000 | [diff] [blame] | 16 | #include "llvm/ADT/Triple.h" |
| 17 | #include "llvm/Bitcode/ReaderWriter.h" |
Rafael Espindola | f21434c | 2014-07-30 19:42:16 +0000 | [diff] [blame] | 18 | #include "llvm/CodeGen/Analysis.h" |
Chandler Carruth | 9fb823b | 2013-01-02 11:36:10 +0000 | [diff] [blame] | 19 | #include "llvm/IR/Constants.h" |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 20 | #include "llvm/IR/DiagnosticPrinter.h" |
Chandler Carruth | 9fb823b | 2013-01-02 11:36:10 +0000 | [diff] [blame] | 21 | #include "llvm/IR/LLVMContext.h" |
Yunzhong Gao | a88d7ab | 2014-01-21 18:31:27 +0000 | [diff] [blame] | 22 | #include "llvm/IR/Metadata.h" |
Chandler Carruth | 9fb823b | 2013-01-02 11:36:10 +0000 | [diff] [blame] | 23 | #include "llvm/IR/Module.h" |
Rafael Espindola | 1e49a6d | 2011-03-02 04:14:42 +0000 | [diff] [blame] | 24 | #include "llvm/MC/MCExpr.h" |
| 25 | #include "llvm/MC/MCInst.h" |
Joey Gouly | db6144e | 2013-09-12 12:55:29 +0000 | [diff] [blame] | 26 | #include "llvm/MC/MCInstrInfo.h" |
Chandler Carruth | 4d88a1c | 2012-12-04 10:44:52 +0000 | [diff] [blame] | 27 | #include "llvm/MC/MCParser/MCAsmParser.h" |
Rafael Espindola | 20fcda7 | 2014-01-22 22:11:14 +0000 | [diff] [blame] | 28 | #include "llvm/MC/MCSection.h" |
Evan Cheng | 91111d2 | 2011-07-09 05:47:46 +0000 | [diff] [blame] | 29 | #include "llvm/MC/MCSubtargetInfo.h" |
Rafael Espindola | 1e49a6d | 2011-03-02 04:14:42 +0000 | [diff] [blame] | 30 | #include "llvm/MC/MCSymbol.h" |
Evan Cheng | 1142444 | 2011-07-26 00:24:13 +0000 | [diff] [blame] | 31 | #include "llvm/MC/MCTargetAsmParser.h" |
Bill Wendling | 8f6c8a9 | 2012-03-30 23:26:06 +0000 | [diff] [blame] | 32 | #include "llvm/MC/SubtargetFeature.h" |
Peter Collingbourne | 10039c0 | 2014-09-18 21:28:49 +0000 | [diff] [blame] | 33 | #include "llvm/Object/IRObjectFile.h" |
| 34 | #include "llvm/Object/ObjectFile.h" |
Bill Wendling | b8dcda7 | 2012-08-06 21:34:54 +0000 | [diff] [blame] | 35 | #include "llvm/Support/CommandLine.h" |
Rafael Espindola | 46ed353 | 2013-06-11 18:05:26 +0000 | [diff] [blame] | 36 | #include "llvm/Support/FileSystem.h" |
Chandler Carruth | 8a8cd2b | 2014-01-07 11:48:04 +0000 | [diff] [blame] | 37 | #include "llvm/Support/Host.h" |
Bill Wendling | 8f6c8a9 | 2012-03-30 23:26:06 +0000 | [diff] [blame] | 38 | #include "llvm/Support/MemoryBuffer.h" |
| 39 | #include "llvm/Support/Path.h" |
Bill Wendling | 8f6c8a9 | 2012-03-30 23:26:06 +0000 | [diff] [blame] | 40 | #include "llvm/Support/SourceMgr.h" |
Bill Wendling | 8f6c8a9 | 2012-03-30 23:26:06 +0000 | [diff] [blame] | 41 | #include "llvm/Support/TargetRegistry.h" |
| 42 | #include "llvm/Support/TargetSelect.h" |
Yunzhong Gao | a88d7ab | 2014-01-21 18:31:27 +0000 | [diff] [blame] | 43 | #include "llvm/Target/TargetLowering.h" |
| 44 | #include "llvm/Target/TargetLoweringObjectFile.h" |
Chandler Carruth | 4d88a1c | 2012-12-04 10:44:52 +0000 | [diff] [blame] | 45 | #include "llvm/Target/TargetRegisterInfo.h" |
Eric Christopher | d913448 | 2014-08-04 21:25:23 +0000 | [diff] [blame] | 46 | #include "llvm/Target/TargetSubtargetInfo.h" |
Rafael Espindola | 282a470 | 2013-10-31 20:51:58 +0000 | [diff] [blame] | 47 | #include "llvm/Transforms/Utils/GlobalStatus.h" |
Rafael Espindola | a6e9c3e | 2014-06-12 17:38:55 +0000 | [diff] [blame] | 48 | #include <system_error> |
Nick Kledzik | 07b4a62 | 2008-02-26 20:26:43 +0000 | [diff] [blame] | 49 | using namespace llvm; |
Peter Collingbourne | 10039c0 | 2014-09-18 21:28:49 +0000 | [diff] [blame] | 50 | using namespace llvm::object; |
Nick Kledzik | 07b4a62 | 2008-02-26 20:26:43 +0000 | [diff] [blame] | 51 | |
Rafael Espindola | dddd1fd | 2014-07-04 18:40:36 +0000 | [diff] [blame] | 52 | LTOModule::LTOModule(std::unique_ptr<object::IRObjectFile> Obj, |
| 53 | llvm::TargetMachine *TM) |
| 54 | : IRFile(std::move(Obj)), _target(TM) {} |
Bill Wendling | fb44050 | 2012-03-28 20:46:54 +0000 | [diff] [blame] | 55 | |
Duncan P. N. Exon Smith | 97b4587 | 2014-11-11 23:08:05 +0000 | [diff] [blame] | 56 | LTOModule::LTOModule(std::unique_ptr<object::IRObjectFile> Obj, |
| 57 | llvm::TargetMachine *TM, |
| 58 | std::unique_ptr<LLVMContext> Context) |
| 59 | : OwnedContext(std::move(Context)), IRFile(std::move(Obj)), _target(TM) {} |
| 60 | |
| 61 | LTOModule::~LTOModule() {} |
| 62 | |
Bill Wendling | fb44050 | 2012-03-28 20:46:54 +0000 | [diff] [blame] | 63 | /// isBitcodeFile - Returns 'true' if the file (or memory contents) is LLVM |
| 64 | /// bitcode. |
Peter Collingbourne | 10039c0 | 2014-09-18 21:28:49 +0000 | [diff] [blame] | 65 | bool LTOModule::isBitcodeFile(const void *Mem, size_t Length) { |
| 66 | ErrorOr<MemoryBufferRef> BCData = IRObjectFile::findBitcodeInMemBuffer( |
| 67 | MemoryBufferRef(StringRef((const char *)Mem, Length), "<mem>")); |
| 68 | return bool(BCData); |
Nick Kledzik | 07b4a62 | 2008-02-26 20:26:43 +0000 | [diff] [blame] | 69 | } |
| 70 | |
Peter Collingbourne | 10039c0 | 2014-09-18 21:28:49 +0000 | [diff] [blame] | 71 | bool LTOModule::isBitcodeFile(const char *Path) { |
| 72 | ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr = |
| 73 | MemoryBuffer::getFile(Path); |
| 74 | if (!BufferOrErr) |
Rafael Espindola | 71affba | 2013-06-12 15:13:57 +0000 | [diff] [blame] | 75 | return false; |
Peter Collingbourne | 10039c0 | 2014-09-18 21:28:49 +0000 | [diff] [blame] | 76 | |
| 77 | ErrorOr<MemoryBufferRef> BCData = IRObjectFile::findBitcodeInMemBuffer( |
| 78 | BufferOrErr.get()->getMemBufferRef()); |
| 79 | return bool(BCData); |
Nick Kledzik | 07b4a62 | 2008-02-26 20:26:43 +0000 | [diff] [blame] | 80 | } |
| 81 | |
Peter Collingbourne | 10039c0 | 2014-09-18 21:28:49 +0000 | [diff] [blame] | 82 | bool LTOModule::isBitcodeForTarget(MemoryBuffer *Buffer, |
| 83 | StringRef TriplePrefix) { |
| 84 | ErrorOr<MemoryBufferRef> BCOrErr = |
| 85 | IRObjectFile::findBitcodeInMemBuffer(Buffer->getMemBufferRef()); |
| 86 | if (!BCOrErr) |
| 87 | return false; |
Duncan P. N. Exon Smith | 97b4587 | 2014-11-11 23:08:05 +0000 | [diff] [blame] | 88 | LLVMContext Context; |
| 89 | std::string Triple = getBitcodeTargetTriple(*BCOrErr, Context); |
Peter Collingbourne | 10039c0 | 2014-09-18 21:28:49 +0000 | [diff] [blame] | 90 | return StringRef(Triple).startswith(TriplePrefix); |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 91 | } |
| 92 | |
Peter Collingbourne | 63086fe | 2014-07-03 23:28:00 +0000 | [diff] [blame] | 93 | LTOModule *LTOModule::createFromFile(const char *path, TargetOptions options, |
| 94 | std::string &errMsg) { |
Rafael Espindola | adf21f2 | 2014-07-06 17:43:13 +0000 | [diff] [blame] | 95 | ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr = |
| 96 | MemoryBuffer::getFile(path); |
| 97 | if (std::error_code EC = BufferOrErr.getError()) { |
| 98 | errMsg = EC.message(); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 99 | return nullptr; |
Michael J. Spencer | d422723 | 2010-12-09 18:06:07 +0000 | [diff] [blame] | 100 | } |
Rafael Espindola | 48af1c2 | 2014-08-19 18:44:46 +0000 | [diff] [blame] | 101 | std::unique_ptr<MemoryBuffer> Buffer = std::move(BufferOrErr.get()); |
Duncan P. N. Exon Smith | 97b4587 | 2014-11-11 23:08:05 +0000 | [diff] [blame] | 102 | return makeLTOModule(Buffer->getMemBufferRef(), options, errMsg, |
| 103 | &getGlobalContext()); |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 104 | } |
| 105 | |
Peter Collingbourne | 63086fe | 2014-07-03 23:28:00 +0000 | [diff] [blame] | 106 | LTOModule *LTOModule::createFromOpenFile(int fd, const char *path, size_t size, |
| 107 | TargetOptions options, |
| 108 | std::string &errMsg) { |
| 109 | return createFromOpenFileSlice(fd, path, size, 0, options, errMsg); |
Rafael Espindola | b39c7c7 | 2011-03-17 00:36:11 +0000 | [diff] [blame] | 110 | } |
| 111 | |
Peter Collingbourne | 63086fe | 2014-07-03 23:28:00 +0000 | [diff] [blame] | 112 | LTOModule *LTOModule::createFromOpenFileSlice(int fd, const char *path, |
| 113 | size_t map_size, off_t offset, |
| 114 | TargetOptions options, |
| 115 | std::string &errMsg) { |
Rafael Espindola | adf21f2 | 2014-07-06 17:43:13 +0000 | [diff] [blame] | 116 | ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr = |
| 117 | MemoryBuffer::getOpenFileSlice(fd, path, map_size, offset); |
| 118 | if (std::error_code EC = BufferOrErr.getError()) { |
| 119 | errMsg = EC.message(); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 120 | return nullptr; |
Rafael Espindola | 56e41f7 | 2011-02-08 22:40:47 +0000 | [diff] [blame] | 121 | } |
Rafael Espindola | 48af1c2 | 2014-08-19 18:44:46 +0000 | [diff] [blame] | 122 | std::unique_ptr<MemoryBuffer> Buffer = std::move(BufferOrErr.get()); |
Duncan P. N. Exon Smith | 97b4587 | 2014-11-11 23:08:05 +0000 | [diff] [blame] | 123 | return makeLTOModule(Buffer->getMemBufferRef(), options, errMsg, |
| 124 | &getGlobalContext()); |
Rafael Espindola | 56e41f7 | 2011-02-08 22:40:47 +0000 | [diff] [blame] | 125 | } |
| 126 | |
Peter Collingbourne | 63086fe | 2014-07-03 23:28:00 +0000 | [diff] [blame] | 127 | LTOModule *LTOModule::createFromBuffer(const void *mem, size_t length, |
| 128 | TargetOptions options, |
| 129 | std::string &errMsg, StringRef path) { |
Duncan P. N. Exon Smith | 97b4587 | 2014-11-11 23:08:05 +0000 | [diff] [blame] | 130 | return createInContext(mem, length, options, errMsg, path, |
| 131 | &getGlobalContext()); |
| 132 | } |
| 133 | |
| 134 | LTOModule *LTOModule::createInLocalContext(const void *mem, size_t length, |
| 135 | TargetOptions options, |
| 136 | std::string &errMsg, |
| 137 | StringRef path) { |
| 138 | return createInContext(mem, length, options, errMsg, path, nullptr); |
| 139 | } |
| 140 | |
| 141 | LTOModule *LTOModule::createInContext(const void *mem, size_t length, |
| 142 | TargetOptions options, |
| 143 | std::string &errMsg, StringRef path, |
| 144 | LLVMContext *Context) { |
Aaron Ballman | 4749725 | 2014-08-20 12:54:13 +0000 | [diff] [blame] | 145 | StringRef Data((const char *)mem, length); |
Rafael Espindola | 48af1c2 | 2014-08-19 18:44:46 +0000 | [diff] [blame] | 146 | MemoryBufferRef Buffer(Data, path); |
Duncan P. N. Exon Smith | 97b4587 | 2014-11-11 23:08:05 +0000 | [diff] [blame] | 147 | return makeLTOModule(Buffer, options, errMsg, Context); |
Bill Wendling | b8dcda7 | 2012-08-06 21:34:54 +0000 | [diff] [blame] | 148 | } |
| 149 | |
Rafael Espindola | dcd1dca | 2015-06-16 22:27:55 +0000 | [diff] [blame^] | 150 | static std::unique_ptr<Module> parseBitcodeFileImpl(MemoryBufferRef Buffer, |
| 151 | LLVMContext &Context, |
| 152 | bool ShouldBeLazy, |
| 153 | std::string &ErrMsg) { |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 154 | |
Duncan P. N. Exon Smith | 140d41b | 2014-12-17 22:05:42 +0000 | [diff] [blame] | 155 | // Find the buffer. |
| 156 | ErrorOr<MemoryBufferRef> MBOrErr = |
| 157 | IRObjectFile::findBitcodeInMemBuffer(Buffer); |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 158 | if (std::error_code EC = MBOrErr.getError()) { |
| 159 | ErrMsg = EC.message(); |
| 160 | return nullptr; |
| 161 | } |
Duncan P. N. Exon Smith | 140d41b | 2014-12-17 22:05:42 +0000 | [diff] [blame] | 162 | |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 163 | std::function<void(const DiagnosticInfo &)> DiagnosticHandler = |
| 164 | [&ErrMsg](const DiagnosticInfo &DI) { |
| 165 | raw_string_ostream Stream(ErrMsg); |
| 166 | DiagnosticPrinterRawOStream DP(Stream); |
| 167 | DI.print(DP); |
| 168 | }; |
| 169 | |
| 170 | if (!ShouldBeLazy) { |
Duncan P. N. Exon Smith | 140d41b | 2014-12-17 22:05:42 +0000 | [diff] [blame] | 171 | // Parse the full file. |
Rafael Espindola | dcd1dca | 2015-06-16 22:27:55 +0000 | [diff] [blame^] | 172 | ErrorOr<std::unique_ptr<Module>> M = |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 173 | parseBitcodeFile(*MBOrErr, Context, DiagnosticHandler); |
| 174 | if (!M) |
| 175 | return nullptr; |
Rafael Espindola | dcd1dca | 2015-06-16 22:27:55 +0000 | [diff] [blame^] | 176 | return std::move(*M); |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 177 | } |
Duncan P. N. Exon Smith | 140d41b | 2014-12-17 22:05:42 +0000 | [diff] [blame] | 178 | |
| 179 | // Parse lazily. |
| 180 | std::unique_ptr<MemoryBuffer> LightweightBuf = |
| 181 | MemoryBuffer::getMemBuffer(*MBOrErr, false); |
Rafael Espindola | dcd1dca | 2015-06-16 22:27:55 +0000 | [diff] [blame^] | 182 | ErrorOr<std::unique_ptr<Module>> M = |
| 183 | getLazyBitcodeModule(std::move(LightweightBuf), Context, |
| 184 | DiagnosticHandler, true /*ShouldLazyLoadMetadata*/); |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 185 | if (!M) |
| 186 | return nullptr; |
Rafael Espindola | dcd1dca | 2015-06-16 22:27:55 +0000 | [diff] [blame^] | 187 | return std::move(*M); |
Duncan P. N. Exon Smith | 140d41b | 2014-12-17 22:05:42 +0000 | [diff] [blame] | 188 | } |
| 189 | |
Rafael Espindola | 48af1c2 | 2014-08-19 18:44:46 +0000 | [diff] [blame] | 190 | LTOModule *LTOModule::makeLTOModule(MemoryBufferRef Buffer, |
Duncan P. N. Exon Smith | 97b4587 | 2014-11-11 23:08:05 +0000 | [diff] [blame] | 191 | TargetOptions options, std::string &errMsg, |
| 192 | LLVMContext *Context) { |
| 193 | std::unique_ptr<LLVMContext> OwnedContext; |
| 194 | if (!Context) { |
| 195 | OwnedContext = llvm::make_unique<LLVMContext>(); |
| 196 | Context = OwnedContext.get(); |
| 197 | } |
| 198 | |
Duncan P. N. Exon Smith | 140d41b | 2014-12-17 22:05:42 +0000 | [diff] [blame] | 199 | // If we own a context, we know this is being used only for symbol |
| 200 | // extraction, not linking. Be lazy in that case. |
Rafael Espindola | dcd1dca | 2015-06-16 22:27:55 +0000 | [diff] [blame^] | 201 | std::unique_ptr<Module> M = parseBitcodeFileImpl( |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 202 | Buffer, *Context, |
Rafael Espindola | dcd1dca | 2015-06-16 22:27:55 +0000 | [diff] [blame^] | 203 | /* ShouldBeLazy */ static_cast<bool>(OwnedContext), errMsg); |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 204 | if (!M) |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 205 | return nullptr; |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 206 | |
Rafael Espindola | dddd1fd | 2014-07-04 18:40:36 +0000 | [diff] [blame] | 207 | std::string TripleStr = M->getTargetTriple(); |
Bob Wilson | 3f7e7c0 | 2012-10-12 17:39:25 +0000 | [diff] [blame] | 208 | if (TripleStr.empty()) |
| 209 | TripleStr = sys::getDefaultTargetTriple(); |
| 210 | llvm::Triple Triple(TripleStr); |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 211 | |
| 212 | // find machine architecture for this module |
Bob Wilson | 3f7e7c0 | 2012-10-12 17:39:25 +0000 | [diff] [blame] | 213 | const Target *march = TargetRegistry::lookupTarget(TripleStr, errMsg); |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 214 | if (!march) |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 215 | return nullptr; |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 216 | |
Nick Lewycky | 364c04a | 2011-04-21 01:54:08 +0000 | [diff] [blame] | 217 | // construct LTOModule, hand over ownership of module and target |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 218 | SubtargetFeatures Features; |
Bob Wilson | 3f7e7c0 | 2012-10-12 17:39:25 +0000 | [diff] [blame] | 219 | Features.getDefaultSubtargetFeatures(Triple); |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 220 | std::string FeatureStr = Features.getString(); |
Bob Wilson | 3f7e7c0 | 2012-10-12 17:39:25 +0000 | [diff] [blame] | 221 | // Set a default CPU for Darwin triples. |
Evan Cheng | fe6e405 | 2011-06-30 01:53:36 +0000 | [diff] [blame] | 222 | std::string CPU; |
Bob Wilson | 3f7e7c0 | 2012-10-12 17:39:25 +0000 | [diff] [blame] | 223 | if (Triple.isOSDarwin()) { |
| 224 | if (Triple.getArch() == llvm::Triple::x86_64) |
| 225 | CPU = "core2"; |
| 226 | else if (Triple.getArch() == llvm::Triple::x86) |
| 227 | CPU = "yonah"; |
Tim Northover | e19bed7 | 2014-07-23 12:32:47 +0000 | [diff] [blame] | 228 | else if (Triple.getArch() == llvm::Triple::aarch64) |
Tim Northover | 00ed996 | 2014-03-29 10:18:08 +0000 | [diff] [blame] | 229 | CPU = "cyclone"; |
Bob Wilson | 3f7e7c0 | 2012-10-12 17:39:25 +0000 | [diff] [blame] | 230 | } |
Rafael Espindola | 0b385c7 | 2013-09-30 16:39:19 +0000 | [diff] [blame] | 231 | |
Bob Wilson | 3f7e7c0 | 2012-10-12 17:39:25 +0000 | [diff] [blame] | 232 | TargetMachine *target = march->createTargetMachine(TripleStr, CPU, FeatureStr, |
Rafael Espindola | 0b385c7 | 2013-09-30 16:39:19 +0000 | [diff] [blame] | 233 | options); |
Mehdi Amini | 46a4355 | 2015-03-04 18:43:29 +0000 | [diff] [blame] | 234 | M->setDataLayout(*target->getDataLayout()); |
Rafael Espindola | 282a470 | 2013-10-31 20:51:58 +0000 | [diff] [blame] | 235 | |
Rafael Espindola | dddd1fd | 2014-07-04 18:40:36 +0000 | [diff] [blame] | 236 | std::unique_ptr<object::IRObjectFile> IRObj( |
Rafael Espindola | 48af1c2 | 2014-08-19 18:44:46 +0000 | [diff] [blame] | 237 | new object::IRObjectFile(Buffer, std::move(M))); |
Rafael Espindola | daeafb4 | 2014-02-19 17:23:20 +0000 | [diff] [blame] | 238 | |
Duncan P. N. Exon Smith | 97b4587 | 2014-11-11 23:08:05 +0000 | [diff] [blame] | 239 | LTOModule *Ret; |
| 240 | if (OwnedContext) |
| 241 | Ret = new LTOModule(std::move(IRObj), target, std::move(OwnedContext)); |
| 242 | else |
| 243 | Ret = new LTOModule(std::move(IRObj), target); |
Rafael Espindola | daeafb4 | 2014-02-19 17:23:20 +0000 | [diff] [blame] | 244 | |
Bill Wendling | 7e58b38 | 2012-03-28 23:12:18 +0000 | [diff] [blame] | 245 | if (Ret->parseSymbols(errMsg)) { |
Rafael Espindola | 1e49a6d | 2011-03-02 04:14:42 +0000 | [diff] [blame] | 246 | delete Ret; |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 247 | return nullptr; |
Rafael Espindola | 1e49a6d | 2011-03-02 04:14:42 +0000 | [diff] [blame] | 248 | } |
Bill Wendling | 5f689e7 | 2011-11-04 18:48:00 +0000 | [diff] [blame] | 249 | |
Yunzhong Gao | a88d7ab | 2014-01-21 18:31:27 +0000 | [diff] [blame] | 250 | Ret->parseMetadata(); |
| 251 | |
Rafael Espindola | 1e49a6d | 2011-03-02 04:14:42 +0000 | [diff] [blame] | 252 | return Ret; |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 253 | } |
| 254 | |
Manman Ren | 03456a1 | 2014-02-10 23:26:14 +0000 | [diff] [blame] | 255 | /// Create a MemoryBuffer from a memory range with an optional name. |
Rafael Espindola | a6d0b2f | 2014-08-17 22:37:39 +0000 | [diff] [blame] | 256 | std::unique_ptr<MemoryBuffer> |
| 257 | LTOModule::makeBuffer(const void *mem, size_t length, StringRef name) { |
Roman Divacky | ad06cee | 2012-09-05 22:26:57 +0000 | [diff] [blame] | 258 | const char *startPtr = (const char*)mem; |
Rafael Espindola | 3560ff2 | 2014-08-27 20:03:13 +0000 | [diff] [blame] | 259 | return MemoryBuffer::getMemBuffer(StringRef(startPtr, length), name, false); |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 260 | } |
| 261 | |
Bill Wendling | fb44050 | 2012-03-28 20:46:54 +0000 | [diff] [blame] | 262 | /// objcClassNameFromExpression - Get string that the data pointer points to. |
Rafael Espindola | 6ee19d2 | 2012-12-11 03:10:43 +0000 | [diff] [blame] | 263 | bool |
| 264 | LTOModule::objcClassNameFromExpression(const Constant *c, std::string &name) { |
| 265 | if (const ConstantExpr *ce = dyn_cast<ConstantExpr>(c)) { |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 266 | Constant *op = ce->getOperand(0); |
| 267 | if (GlobalVariable *gvn = dyn_cast<GlobalVariable>(op)) { |
| 268 | Constant *cn = gvn->getInitializer(); |
Chris Lattner | cf9e8f6 | 2012-02-05 02:29:43 +0000 | [diff] [blame] | 269 | if (ConstantDataArray *ca = dyn_cast<ConstantDataArray>(cn)) { |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 270 | if (ca->isCString()) { |
Yaron Keren | 075759a | 2015-03-30 15:42:36 +0000 | [diff] [blame] | 271 | name = (".objc_class_name_" + ca->getAsCString()).str(); |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 272 | return true; |
Nick Kledzik | b481c20 | 2009-06-01 20:33:09 +0000 | [diff] [blame] | 273 | } |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 274 | } |
Nick Kledzik | b481c20 | 2009-06-01 20:33:09 +0000 | [diff] [blame] | 275 | } |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 276 | } |
| 277 | return false; |
| 278 | } |
| 279 | |
Bill Wendling | fb44050 | 2012-03-28 20:46:54 +0000 | [diff] [blame] | 280 | /// addObjCClass - Parse i386/ppc ObjC class data structure. |
Rafael Espindola | 6ee19d2 | 2012-12-11 03:10:43 +0000 | [diff] [blame] | 281 | void LTOModule::addObjCClass(const GlobalVariable *clgv) { |
| 282 | const ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer()); |
Bill Wendling | 5f689e7 | 2011-11-04 18:48:00 +0000 | [diff] [blame] | 283 | if (!c) return; |
Nick Kledzik | b481c20 | 2009-06-01 20:33:09 +0000 | [diff] [blame] | 284 | |
Bill Wendling | 5f689e7 | 2011-11-04 18:48:00 +0000 | [diff] [blame] | 285 | // second slot in __OBJC,__class is pointer to superclass name |
| 286 | std::string superclassName; |
| 287 | if (objcClassNameFromExpression(c->getOperand(1), superclassName)) { |
David Blaikie | 5106ce7 | 2014-11-19 05:49:42 +0000 | [diff] [blame] | 288 | auto IterBool = |
| 289 | _undefines.insert(std::make_pair(superclassName, NameAndAttributes())); |
| 290 | if (IterBool.second) { |
| 291 | NameAndAttributes &info = IterBool.first->second; |
| 292 | info.name = IterBool.first->first().data(); |
Rafael Espindola | 477d11f | 2011-02-20 16:27:25 +0000 | [diff] [blame] | 293 | info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED; |
Bill Wendling | 9ee2d33 | 2012-03-29 08:27:32 +0000 | [diff] [blame] | 294 | info.isFunction = false; |
| 295 | info.symbol = clgv; |
Nick Kledzik | b481c20 | 2009-06-01 20:33:09 +0000 | [diff] [blame] | 296 | } |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 297 | } |
Bill Wendling | 5f689e7 | 2011-11-04 18:48:00 +0000 | [diff] [blame] | 298 | |
| 299 | // third slot in __OBJC,__class is pointer to class name |
| 300 | std::string className; |
| 301 | if (objcClassNameFromExpression(c->getOperand(2), className)) { |
David Blaikie | 5106ce7 | 2014-11-19 05:49:42 +0000 | [diff] [blame] | 302 | auto Iter = _defines.insert(className).first; |
Bill Wendling | 9ee2d33 | 2012-03-29 08:27:32 +0000 | [diff] [blame] | 303 | |
Bill Wendling | 5f689e7 | 2011-11-04 18:48:00 +0000 | [diff] [blame] | 304 | NameAndAttributes info; |
David Blaikie | 5106ce7 | 2014-11-19 05:49:42 +0000 | [diff] [blame] | 305 | info.name = Iter->first().data(); |
Bill Wendling | 9ee2d33 | 2012-03-29 08:27:32 +0000 | [diff] [blame] | 306 | info.attributes = LTO_SYMBOL_PERMISSIONS_DATA | |
| 307 | LTO_SYMBOL_DEFINITION_REGULAR | LTO_SYMBOL_SCOPE_DEFAULT; |
| 308 | info.isFunction = false; |
| 309 | info.symbol = clgv; |
Bill Wendling | 5f689e7 | 2011-11-04 18:48:00 +0000 | [diff] [blame] | 310 | _symbols.push_back(info); |
| 311 | } |
| 312 | } |
| 313 | |
Bill Wendling | fb44050 | 2012-03-28 20:46:54 +0000 | [diff] [blame] | 314 | /// addObjCCategory - Parse i386/ppc ObjC category data structure. |
Rafael Espindola | 6ee19d2 | 2012-12-11 03:10:43 +0000 | [diff] [blame] | 315 | void LTOModule::addObjCCategory(const GlobalVariable *clgv) { |
| 316 | const ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer()); |
Bill Wendling | 5f689e7 | 2011-11-04 18:48:00 +0000 | [diff] [blame] | 317 | if (!c) return; |
| 318 | |
| 319 | // second slot in __OBJC,__category is pointer to target class name |
| 320 | std::string targetclassName; |
| 321 | if (!objcClassNameFromExpression(c->getOperand(1), targetclassName)) |
| 322 | return; |
| 323 | |
David Blaikie | 5106ce7 | 2014-11-19 05:49:42 +0000 | [diff] [blame] | 324 | auto IterBool = |
| 325 | _undefines.insert(std::make_pair(targetclassName, NameAndAttributes())); |
Bill Wendling | 5f689e7 | 2011-11-04 18:48:00 +0000 | [diff] [blame] | 326 | |
David Blaikie | 5106ce7 | 2014-11-19 05:49:42 +0000 | [diff] [blame] | 327 | if (!IterBool.second) |
Bill Wendling | 5f689e7 | 2011-11-04 18:48:00 +0000 | [diff] [blame] | 328 | return; |
| 329 | |
David Blaikie | 5106ce7 | 2014-11-19 05:49:42 +0000 | [diff] [blame] | 330 | NameAndAttributes &info = IterBool.first->second; |
| 331 | info.name = IterBool.first->first().data(); |
Bill Wendling | 5f689e7 | 2011-11-04 18:48:00 +0000 | [diff] [blame] | 332 | info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED; |
Bill Wendling | 9ee2d33 | 2012-03-29 08:27:32 +0000 | [diff] [blame] | 333 | info.isFunction = false; |
| 334 | info.symbol = clgv; |
Nick Kledzik | b481c20 | 2009-06-01 20:33:09 +0000 | [diff] [blame] | 335 | } |
| 336 | |
Bill Wendling | fb44050 | 2012-03-28 20:46:54 +0000 | [diff] [blame] | 337 | /// addObjCClassRef - Parse i386/ppc ObjC class list data structure. |
Rafael Espindola | 6ee19d2 | 2012-12-11 03:10:43 +0000 | [diff] [blame] | 338 | void LTOModule::addObjCClassRef(const GlobalVariable *clgv) { |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 339 | std::string targetclassName; |
Bill Wendling | 5f689e7 | 2011-11-04 18:48:00 +0000 | [diff] [blame] | 340 | if (!objcClassNameFromExpression(clgv->getInitializer(), targetclassName)) |
| 341 | return; |
Rafael Espindola | 477d11f | 2011-02-20 16:27:25 +0000 | [diff] [blame] | 342 | |
David Blaikie | 5106ce7 | 2014-11-19 05:49:42 +0000 | [diff] [blame] | 343 | auto IterBool = |
| 344 | _undefines.insert(std::make_pair(targetclassName, NameAndAttributes())); |
| 345 | |
| 346 | if (!IterBool.second) |
Bill Wendling | 5f689e7 | 2011-11-04 18:48:00 +0000 | [diff] [blame] | 347 | return; |
Rafael Espindola | 477d11f | 2011-02-20 16:27:25 +0000 | [diff] [blame] | 348 | |
David Blaikie | 5106ce7 | 2014-11-19 05:49:42 +0000 | [diff] [blame] | 349 | NameAndAttributes &info = IterBool.first->second; |
| 350 | info.name = IterBool.first->first().data(); |
Bill Wendling | 5f689e7 | 2011-11-04 18:48:00 +0000 | [diff] [blame] | 351 | info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED; |
Bill Wendling | 9ee2d33 | 2012-03-29 08:27:32 +0000 | [diff] [blame] | 352 | info.isFunction = false; |
| 353 | info.symbol = clgv; |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 354 | } |
| 355 | |
Rafael Espindola | dddd1fd | 2014-07-04 18:40:36 +0000 | [diff] [blame] | 356 | void LTOModule::addDefinedDataSymbol(const object::BasicSymbolRef &Sym) { |
Rafael Espindola | 0972d41 | 2014-07-04 16:37:02 +0000 | [diff] [blame] | 357 | SmallString<64> Buffer; |
Rafael Espindola | dddd1fd | 2014-07-04 18:40:36 +0000 | [diff] [blame] | 358 | { |
| 359 | raw_svector_ostream OS(Buffer); |
| 360 | Sym.printName(OS); |
| 361 | } |
| 362 | |
| 363 | const GlobalValue *V = IRFile->getSymbolGV(Sym.getRawDataRefImpl()); |
Rafael Espindola | 0972d41 | 2014-07-04 16:37:02 +0000 | [diff] [blame] | 364 | addDefinedDataSymbol(Buffer.c_str(), V); |
| 365 | } |
| 366 | |
| 367 | void LTOModule::addDefinedDataSymbol(const char *Name, const GlobalValue *v) { |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 368 | // Add to list of defined symbols. |
Rafael Espindola | 0972d41 | 2014-07-04 16:37:02 +0000 | [diff] [blame] | 369 | addDefinedSymbol(Name, v, false); |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 370 | |
Bill Wendling | 45f74e3 | 2012-08-06 22:52:45 +0000 | [diff] [blame] | 371 | if (!v->hasSection() /* || !isTargetDarwin */) |
| 372 | return; |
| 373 | |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 374 | // Special case i386/ppc ObjC data structures in magic sections: |
| 375 | // The issue is that the old ObjC object format did some strange |
| 376 | // contortions to avoid real linker symbols. For instance, the |
| 377 | // ObjC class data structure is allocated statically in the executable |
| 378 | // that defines that class. That data structures contains a pointer to |
| 379 | // its superclass. But instead of just initializing that part of the |
| 380 | // struct to the address of its superclass, and letting the static and |
| 381 | // dynamic linkers do the rest, the runtime works by having that field |
| 382 | // instead point to a C-string that is the name of the superclass. |
| 383 | // At runtime the objc initialization updates that pointer and sets |
| 384 | // it to point to the actual super class. As far as the linker |
| 385 | // knows it is just a pointer to a string. But then someone wanted the |
| 386 | // linker to issue errors at build time if the superclass was not found. |
| 387 | // So they figured out a way in mach-o object format to use an absolute |
| 388 | // symbols (.objc_class_name_Foo = 0) and a floating reference |
| 389 | // (.reference .objc_class_name_Bar) to cause the linker into erroring when |
| 390 | // a class was missing. |
| 391 | // The following synthesizes the implicit .objc_* symbols for the linker |
| 392 | // from the ObjC data structures generated by the front end. |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 393 | |
Bill Wendling | 45f74e3 | 2012-08-06 22:52:45 +0000 | [diff] [blame] | 394 | // special case if this data blob is an ObjC class definition |
Rafael Espindola | 64c1e18 | 2014-06-03 02:41:57 +0000 | [diff] [blame] | 395 | std::string Section = v->getSection(); |
| 396 | if (Section.compare(0, 15, "__OBJC,__class,") == 0) { |
Rafael Espindola | 6ee19d2 | 2012-12-11 03:10:43 +0000 | [diff] [blame] | 397 | if (const GlobalVariable *gv = dyn_cast<GlobalVariable>(v)) { |
Bill Wendling | 45f74e3 | 2012-08-06 22:52:45 +0000 | [diff] [blame] | 398 | addObjCClass(gv); |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 399 | } |
Bill Wendling | 45f74e3 | 2012-08-06 22:52:45 +0000 | [diff] [blame] | 400 | } |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 401 | |
Bill Wendling | 45f74e3 | 2012-08-06 22:52:45 +0000 | [diff] [blame] | 402 | // special case if this data blob is an ObjC category definition |
Rafael Espindola | 64c1e18 | 2014-06-03 02:41:57 +0000 | [diff] [blame] | 403 | else if (Section.compare(0, 18, "__OBJC,__category,") == 0) { |
Rafael Espindola | 6ee19d2 | 2012-12-11 03:10:43 +0000 | [diff] [blame] | 404 | if (const GlobalVariable *gv = dyn_cast<GlobalVariable>(v)) { |
Bill Wendling | 45f74e3 | 2012-08-06 22:52:45 +0000 | [diff] [blame] | 405 | addObjCCategory(gv); |
| 406 | } |
| 407 | } |
| 408 | |
| 409 | // special case if this data blob is the list of referenced classes |
Rafael Espindola | 64c1e18 | 2014-06-03 02:41:57 +0000 | [diff] [blame] | 410 | else if (Section.compare(0, 18, "__OBJC,__cls_refs,") == 0) { |
Rafael Espindola | 6ee19d2 | 2012-12-11 03:10:43 +0000 | [diff] [blame] | 411 | if (const GlobalVariable *gv = dyn_cast<GlobalVariable>(v)) { |
Bill Wendling | 45f74e3 | 2012-08-06 22:52:45 +0000 | [diff] [blame] | 412 | addObjCClassRef(gv); |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 413 | } |
| 414 | } |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 415 | } |
| 416 | |
Rafael Espindola | dddd1fd | 2014-07-04 18:40:36 +0000 | [diff] [blame] | 417 | void LTOModule::addDefinedFunctionSymbol(const object::BasicSymbolRef &Sym) { |
Rafael Espindola | 0972d41 | 2014-07-04 16:37:02 +0000 | [diff] [blame] | 418 | SmallString<64> Buffer; |
Rafael Espindola | dddd1fd | 2014-07-04 18:40:36 +0000 | [diff] [blame] | 419 | { |
| 420 | raw_svector_ostream OS(Buffer); |
| 421 | Sym.printName(OS); |
| 422 | } |
| 423 | |
| 424 | const Function *F = |
| 425 | cast<Function>(IRFile->getSymbolGV(Sym.getRawDataRefImpl())); |
Rafael Espindola | 0972d41 | 2014-07-04 16:37:02 +0000 | [diff] [blame] | 426 | addDefinedFunctionSymbol(Buffer.c_str(), F); |
| 427 | } |
| 428 | |
| 429 | void LTOModule::addDefinedFunctionSymbol(const char *Name, const Function *F) { |
Bill Wendling | fb44050 | 2012-03-28 20:46:54 +0000 | [diff] [blame] | 430 | // add to list of defined symbols |
Rafael Espindola | 0972d41 | 2014-07-04 16:37:02 +0000 | [diff] [blame] | 431 | addDefinedSymbol(Name, F, true); |
Bill Wendling | fb44050 | 2012-03-28 20:46:54 +0000 | [diff] [blame] | 432 | } |
| 433 | |
Rafael Espindola | 0972d41 | 2014-07-04 16:37:02 +0000 | [diff] [blame] | 434 | void LTOModule::addDefinedSymbol(const char *Name, const GlobalValue *def, |
| 435 | bool isFunction) { |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 436 | // set alignment part log2() can have rounding errors |
| 437 | uint32_t align = def->getAlignment(); |
Rafael Espindola | 9475117 | 2014-05-05 14:18:16 +0000 | [diff] [blame] | 438 | uint32_t attr = align ? countTrailingZeros(align) : 0; |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 439 | |
| 440 | // set permissions part |
Bill Wendling | 9ee2d33 | 2012-03-29 08:27:32 +0000 | [diff] [blame] | 441 | if (isFunction) { |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 442 | attr |= LTO_SYMBOL_PERMISSIONS_CODE; |
Bill Wendling | 9ee2d33 | 2012-03-29 08:27:32 +0000 | [diff] [blame] | 443 | } else { |
Rafael Espindola | 6ee19d2 | 2012-12-11 03:10:43 +0000 | [diff] [blame] | 444 | const GlobalVariable *gv = dyn_cast<GlobalVariable>(def); |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 445 | if (gv && gv->isConstant()) |
| 446 | attr |= LTO_SYMBOL_PERMISSIONS_RODATA; |
| 447 | else |
| 448 | attr |= LTO_SYMBOL_PERMISSIONS_DATA; |
| 449 | } |
| 450 | |
| 451 | // set definition part |
Rafael Espindola | 2fb5bc3 | 2014-03-13 23:18:37 +0000 | [diff] [blame] | 452 | if (def->hasWeakLinkage() || def->hasLinkOnceLinkage()) |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 453 | attr |= LTO_SYMBOL_DEFINITION_WEAK; |
Bill Wendling | dcd7c2b | 2010-09-27 20:17:45 +0000 | [diff] [blame] | 454 | else if (def->hasCommonLinkage()) |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 455 | attr |= LTO_SYMBOL_DEFINITION_TENTATIVE; |
Bill Wendling | dcd7c2b | 2010-09-27 20:17:45 +0000 | [diff] [blame] | 456 | else |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 457 | attr |= LTO_SYMBOL_DEFINITION_REGULAR; |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 458 | |
| 459 | // set scope part |
Duncan P. N. Exon Smith | 87121f8 | 2014-05-07 22:53:14 +0000 | [diff] [blame] | 460 | if (def->hasLocalLinkage()) |
| 461 | // Ignore visibility if linkage is local. |
| 462 | attr |= LTO_SYMBOL_SCOPE_INTERNAL; |
| 463 | else if (def->hasHiddenVisibility()) |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 464 | attr |= LTO_SYMBOL_SCOPE_HIDDEN; |
| 465 | else if (def->hasProtectedVisibility()) |
| 466 | attr |= LTO_SYMBOL_SCOPE_PROTECTED; |
Rafael Espindola | f21434c | 2014-07-30 19:42:16 +0000 | [diff] [blame] | 467 | else if (canBeOmittedFromSymbolTable(def)) |
Rafael Espindola | 282a470 | 2013-10-31 20:51:58 +0000 | [diff] [blame] | 468 | attr |= LTO_SYMBOL_SCOPE_DEFAULT_CAN_BE_HIDDEN; |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 469 | else |
Duncan P. N. Exon Smith | 87121f8 | 2014-05-07 22:53:14 +0000 | [diff] [blame] | 470 | attr |= LTO_SYMBOL_SCOPE_DEFAULT; |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 471 | |
Peter Collingbourne | 485ad48 | 2015-06-11 21:41:27 +0000 | [diff] [blame] | 472 | if (def->hasComdat()) |
| 473 | attr |= LTO_SYMBOL_COMDAT; |
| 474 | |
David Blaikie | 5106ce7 | 2014-11-19 05:49:42 +0000 | [diff] [blame] | 475 | auto Iter = _defines.insert(Name).first; |
Rafael Espindola | 477d11f | 2011-02-20 16:27:25 +0000 | [diff] [blame] | 476 | |
Bill Wendling | 9ee2d33 | 2012-03-29 08:27:32 +0000 | [diff] [blame] | 477 | // fill information structure |
| 478 | NameAndAttributes info; |
David Blaikie | 5106ce7 | 2014-11-19 05:49:42 +0000 | [diff] [blame] | 479 | StringRef NameRef = Iter->first(); |
Rafael Espindola | 0972d41 | 2014-07-04 16:37:02 +0000 | [diff] [blame] | 480 | info.name = NameRef.data(); |
| 481 | assert(info.name[NameRef.size()] == '\0'); |
Bill Wendling | 9ee2d33 | 2012-03-29 08:27:32 +0000 | [diff] [blame] | 482 | info.attributes = attr; |
| 483 | info.isFunction = isFunction; |
| 484 | info.symbol = def; |
| 485 | |
| 486 | // add to table of symbols |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 487 | _symbols.push_back(info); |
Nick Kledzik | 07b4a62 | 2008-02-26 20:26:43 +0000 | [diff] [blame] | 488 | } |
| 489 | |
Bill Wendling | fb44050 | 2012-03-28 20:46:54 +0000 | [diff] [blame] | 490 | /// addAsmGlobalSymbol - Add a global symbol from module-level ASM to the |
| 491 | /// defined list. |
Rafael Espindola | 1e49a6d | 2011-03-02 04:14:42 +0000 | [diff] [blame] | 492 | void LTOModule::addAsmGlobalSymbol(const char *name, |
| 493 | lto_symbol_attributes scope) { |
David Blaikie | 5106ce7 | 2014-11-19 05:49:42 +0000 | [diff] [blame] | 494 | auto IterBool = _defines.insert(name); |
Rafael Espindola | 477d11f | 2011-02-20 16:27:25 +0000 | [diff] [blame] | 495 | |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 496 | // only add new define if not already defined |
David Blaikie | 5106ce7 | 2014-11-19 05:49:42 +0000 | [diff] [blame] | 497 | if (!IterBool.second) |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 498 | return; |
| 499 | |
David Blaikie | 5106ce7 | 2014-11-19 05:49:42 +0000 | [diff] [blame] | 500 | NameAndAttributes &info = _undefines[IterBool.first->first().data()]; |
Bill Wendling | 9ee2d33 | 2012-03-29 08:27:32 +0000 | [diff] [blame] | 501 | |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 502 | if (info.symbol == nullptr) { |
Bill Wendling | 71b19bb | 2012-04-02 10:01:21 +0000 | [diff] [blame] | 503 | // FIXME: This is trying to take care of module ASM like this: |
| 504 | // |
| 505 | // module asm ".zerofill __FOO, __foo, _bar_baz_qux, 0" |
| 506 | // |
| 507 | // but is gross and its mother dresses it funny. Have the ASM parser give us |
| 508 | // more details for this type of situation so that we're not guessing so |
| 509 | // much. |
| 510 | |
| 511 | // fill information structure |
David Blaikie | 5106ce7 | 2014-11-19 05:49:42 +0000 | [diff] [blame] | 512 | info.name = IterBool.first->first().data(); |
Bill Wendling | 71b19bb | 2012-04-02 10:01:21 +0000 | [diff] [blame] | 513 | info.attributes = |
| 514 | LTO_SYMBOL_PERMISSIONS_DATA | LTO_SYMBOL_DEFINITION_REGULAR | scope; |
| 515 | info.isFunction = false; |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 516 | info.symbol = nullptr; |
Bill Wendling | 71b19bb | 2012-04-02 10:01:21 +0000 | [diff] [blame] | 517 | |
| 518 | // add to table of symbols |
| 519 | _symbols.push_back(info); |
Bill Wendling | 3a0bcf0 | 2012-04-02 03:33:31 +0000 | [diff] [blame] | 520 | return; |
| 521 | } |
| 522 | |
Bill Wendling | 9ee2d33 | 2012-03-29 08:27:32 +0000 | [diff] [blame] | 523 | if (info.isFunction) |
Rafael Espindola | 0972d41 | 2014-07-04 16:37:02 +0000 | [diff] [blame] | 524 | addDefinedFunctionSymbol(info.name, cast<Function>(info.symbol)); |
Bill Wendling | 9ee2d33 | 2012-03-29 08:27:32 +0000 | [diff] [blame] | 525 | else |
Rafael Espindola | 0972d41 | 2014-07-04 16:37:02 +0000 | [diff] [blame] | 526 | addDefinedDataSymbol(info.name, info.symbol); |
Bill Wendling | 8f6c8a9 | 2012-03-30 23:26:06 +0000 | [diff] [blame] | 527 | |
| 528 | _symbols.back().attributes &= ~LTO_SYMBOL_SCOPE_MASK; |
| 529 | _symbols.back().attributes |= scope; |
Devang Patel | a59fe95 | 2008-07-16 18:06:52 +0000 | [diff] [blame] | 530 | } |
Nick Kledzik | 07b4a62 | 2008-02-26 20:26:43 +0000 | [diff] [blame] | 531 | |
Bill Wendling | fb44050 | 2012-03-28 20:46:54 +0000 | [diff] [blame] | 532 | /// addAsmGlobalSymbolUndef - Add a global symbol from module-level ASM to the |
| 533 | /// undefined list. |
Rafael Espindola | 1e49a6d | 2011-03-02 04:14:42 +0000 | [diff] [blame] | 534 | void LTOModule::addAsmGlobalSymbolUndef(const char *name) { |
David Blaikie | 5106ce7 | 2014-11-19 05:49:42 +0000 | [diff] [blame] | 535 | auto IterBool = _undefines.insert(std::make_pair(name, NameAndAttributes())); |
Rafael Espindola | 1e49a6d | 2011-03-02 04:14:42 +0000 | [diff] [blame] | 536 | |
David Blaikie | 5106ce7 | 2014-11-19 05:49:42 +0000 | [diff] [blame] | 537 | _asm_undefines.push_back(IterBool.first->first().data()); |
Rafael Espindola | 1e49a6d | 2011-03-02 04:14:42 +0000 | [diff] [blame] | 538 | |
| 539 | // we already have the symbol |
David Blaikie | 5106ce7 | 2014-11-19 05:49:42 +0000 | [diff] [blame] | 540 | if (!IterBool.second) |
Rafael Espindola | 1e49a6d | 2011-03-02 04:14:42 +0000 | [diff] [blame] | 541 | return; |
| 542 | |
Alp Toker | 9844434 | 2014-04-19 23:56:35 +0000 | [diff] [blame] | 543 | uint32_t attr = LTO_SYMBOL_DEFINITION_UNDEFINED; |
Rafael Espindola | 1e49a6d | 2011-03-02 04:14:42 +0000 | [diff] [blame] | 544 | attr |= LTO_SYMBOL_SCOPE_DEFAULT; |
David Blaikie | 5106ce7 | 2014-11-19 05:49:42 +0000 | [diff] [blame] | 545 | NameAndAttributes &info = IterBool.first->second; |
| 546 | info.name = IterBool.first->first().data(); |
Bill Wendling | 9ee2d33 | 2012-03-29 08:27:32 +0000 | [diff] [blame] | 547 | info.attributes = attr; |
| 548 | info.isFunction = false; |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 549 | info.symbol = nullptr; |
Rafael Espindola | 1e49a6d | 2011-03-02 04:14:42 +0000 | [diff] [blame] | 550 | } |
| 551 | |
Rafael Espindola | dddd1fd | 2014-07-04 18:40:36 +0000 | [diff] [blame] | 552 | /// Add a symbol which isn't defined just yet to a list to be resolved later. |
| 553 | void LTOModule::addPotentialUndefinedSymbol(const object::BasicSymbolRef &Sym, |
| 554 | bool isFunc) { |
Rafael Espindola | 34b5938 | 2011-02-11 05:23:09 +0000 | [diff] [blame] | 555 | SmallString<64> name; |
Rafael Espindola | dddd1fd | 2014-07-04 18:40:36 +0000 | [diff] [blame] | 556 | { |
| 557 | raw_svector_ostream OS(name); |
| 558 | Sym.printName(OS); |
| 559 | } |
Rafael Espindola | 5654852 | 2009-04-24 16:55:21 +0000 | [diff] [blame] | 560 | |
David Blaikie | 5106ce7 | 2014-11-19 05:49:42 +0000 | [diff] [blame] | 561 | auto IterBool = _undefines.insert(std::make_pair(name, NameAndAttributes())); |
Rafael Espindola | 477d11f | 2011-02-20 16:27:25 +0000 | [diff] [blame] | 562 | |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 563 | // we already have the symbol |
David Blaikie | 5106ce7 | 2014-11-19 05:49:42 +0000 | [diff] [blame] | 564 | if (!IterBool.second) |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 565 | return; |
Rafael Espindola | 5654852 | 2009-04-24 16:55:21 +0000 | [diff] [blame] | 566 | |
David Blaikie | 5106ce7 | 2014-11-19 05:49:42 +0000 | [diff] [blame] | 567 | NameAndAttributes &info = IterBool.first->second; |
Rafael Espindola | 477d11f | 2011-02-20 16:27:25 +0000 | [diff] [blame] | 568 | |
David Blaikie | 5106ce7 | 2014-11-19 05:49:42 +0000 | [diff] [blame] | 569 | info.name = IterBool.first->first().data(); |
Bill Wendling | fb44050 | 2012-03-28 20:46:54 +0000 | [diff] [blame] | 570 | |
Rafael Espindola | dddd1fd | 2014-07-04 18:40:36 +0000 | [diff] [blame] | 571 | const GlobalValue *decl = IRFile->getSymbolGV(Sym.getRawDataRefImpl()); |
| 572 | |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 573 | if (decl->hasExternalWeakLinkage()) |
| 574 | info.attributes = LTO_SYMBOL_DEFINITION_WEAKUNDEF; |
| 575 | else |
| 576 | info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED; |
Rafael Espindola | 477d11f | 2011-02-20 16:27:25 +0000 | [diff] [blame] | 577 | |
Bill Wendling | 9ee2d33 | 2012-03-29 08:27:32 +0000 | [diff] [blame] | 578 | info.isFunction = isFunc; |
| 579 | info.symbol = decl; |
Nick Kledzik | 07b4a62 | 2008-02-26 20:26:43 +0000 | [diff] [blame] | 580 | } |
| 581 | |
Bill Wendling | 7e58b38 | 2012-03-28 23:12:18 +0000 | [diff] [blame] | 582 | /// parseSymbols - Parse the symbols from the module and model-level ASM and add |
Bill Wendling | fb44050 | 2012-03-28 20:46:54 +0000 | [diff] [blame] | 583 | /// them to either the defined or undefined lists. |
Bill Wendling | 7e58b38 | 2012-03-28 23:12:18 +0000 | [diff] [blame] | 584 | bool LTOModule::parseSymbols(std::string &errMsg) { |
Rafael Espindola | dddd1fd | 2014-07-04 18:40:36 +0000 | [diff] [blame] | 585 | for (auto &Sym : IRFile->symbols()) { |
| 586 | const GlobalValue *GV = IRFile->getSymbolGV(Sym.getRawDataRefImpl()); |
| 587 | uint32_t Flags = Sym.getFlags(); |
Rafael Espindola | 089a317 | 2014-07-04 19:31:27 +0000 | [diff] [blame] | 588 | if (Flags & object::BasicSymbolRef::SF_FormatSpecific) |
| 589 | continue; |
| 590 | |
Rafael Espindola | dddd1fd | 2014-07-04 18:40:36 +0000 | [diff] [blame] | 591 | bool IsUndefined = Flags & object::BasicSymbolRef::SF_Undefined; |
| 592 | |
| 593 | if (!GV) { |
| 594 | SmallString<64> Buffer; |
| 595 | { |
| 596 | raw_svector_ostream OS(Buffer); |
| 597 | Sym.printName(OS); |
| 598 | } |
| 599 | const char *Name = Buffer.c_str(); |
| 600 | |
| 601 | if (IsUndefined) |
| 602 | addAsmGlobalSymbolUndef(Name); |
| 603 | else if (Flags & object::BasicSymbolRef::SF_Global) |
| 604 | addAsmGlobalSymbol(Name, LTO_SYMBOL_SCOPE_DEFAULT); |
| 605 | else |
| 606 | addAsmGlobalSymbol(Name, LTO_SYMBOL_SCOPE_INTERNAL); |
| 607 | continue; |
| 608 | } |
| 609 | |
| 610 | auto *F = dyn_cast<Function>(GV); |
| 611 | if (IsUndefined) { |
| 612 | addPotentialUndefinedSymbol(Sym, F != nullptr); |
| 613 | continue; |
| 614 | } |
| 615 | |
| 616 | if (F) { |
| 617 | addDefinedFunctionSymbol(Sym); |
| 618 | continue; |
| 619 | } |
| 620 | |
| 621 | if (isa<GlobalVariable>(GV)) { |
| 622 | addDefinedDataSymbol(Sym); |
| 623 | continue; |
| 624 | } |
| 625 | |
| 626 | assert(isa<GlobalAlias>(GV)); |
| 627 | addDefinedDataSymbol(Sym); |
Daniel Dunbar | 919660b | 2010-08-10 23:46:46 +0000 | [diff] [blame] | 628 | } |
Nick Kledzik | 07b4a62 | 2008-02-26 20:26:43 +0000 | [diff] [blame] | 629 | |
Daniel Dunbar | 919660b | 2010-08-10 23:46:46 +0000 | [diff] [blame] | 630 | // make symbols for all undefines |
Bill Wendling | 9ee2d33 | 2012-03-29 08:27:32 +0000 | [diff] [blame] | 631 | for (StringMap<NameAndAttributes>::iterator u =_undefines.begin(), |
| 632 | e = _undefines.end(); u != e; ++u) { |
| 633 | // If this symbol also has a definition, then don't make an undefine because |
| 634 | // it is a tentative definition. |
| 635 | if (_defines.count(u->getKey())) continue; |
| 636 | NameAndAttributes info = u->getValue(); |
| 637 | _symbols.push_back(info); |
Daniel Dunbar | 5657e7b | 2010-08-10 23:46:39 +0000 | [diff] [blame] | 638 | } |
Bill Wendling | 9ee2d33 | 2012-03-29 08:27:32 +0000 | [diff] [blame] | 639 | |
Rafael Espindola | 1e49a6d | 2011-03-02 04:14:42 +0000 | [diff] [blame] | 640 | return false; |
Nick Kledzik | 91a6dcf | 2008-02-27 22:25:36 +0000 | [diff] [blame] | 641 | } |
Yunzhong Gao | a88d7ab | 2014-01-21 18:31:27 +0000 | [diff] [blame] | 642 | |
| 643 | /// parseMetadata - Parse metadata from the module |
| 644 | void LTOModule::parseMetadata() { |
| 645 | // Linker Options |
Duncan P. N. Exon Smith | 5bf8fef | 2014-12-09 18:38:53 +0000 | [diff] [blame] | 646 | if (Metadata *Val = getModule().getModuleFlag("Linker Options")) { |
Yunzhong Gao | a88d7ab | 2014-01-21 18:31:27 +0000 | [diff] [blame] | 647 | MDNode *LinkerOptions = cast<MDNode>(Val); |
| 648 | for (unsigned i = 0, e = LinkerOptions->getNumOperands(); i != e; ++i) { |
| 649 | MDNode *MDOptions = cast<MDNode>(LinkerOptions->getOperand(i)); |
| 650 | for (unsigned ii = 0, ie = MDOptions->getNumOperands(); ii != ie; ++ii) { |
| 651 | MDString *MDOption = cast<MDString>(MDOptions->getOperand(ii)); |
David Blaikie | 5106ce7 | 2014-11-19 05:49:42 +0000 | [diff] [blame] | 652 | // FIXME: Make StringSet::insert match Self-Associative Container |
| 653 | // requirements, returning <iter,bool> rather than bool, and use that |
| 654 | // here. |
| 655 | StringRef Op = |
| 656 | _linkeropt_strings.insert(MDOption->getString()).first->first(); |
Eric Christopher | 36fe028 | 2015-02-03 07:22:52 +0000 | [diff] [blame] | 657 | StringRef DepLibName = |
| 658 | _target->getObjFileLowering()->getDepLibFromLinkerOpt(Op); |
Yunzhong Gao | a88d7ab | 2014-01-21 18:31:27 +0000 | [diff] [blame] | 659 | if (!DepLibName.empty()) |
| 660 | _deplibs.push_back(DepLibName.data()); |
| 661 | else if (!Op.empty()) |
| 662 | _linkeropts.push_back(Op.data()); |
| 663 | } |
| 664 | } |
| 665 | } |
| 666 | |
| 667 | // Add other interesting metadata here. |
| 668 | } |