1 //===- MCAssembler.h - Object File Generation -------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef LLVM_MC_MCASSEMBLER_H 10 #define LLVM_MC_MCASSEMBLER_H 11 12 #include "llvm/ADT/ArrayRef.h" 13 #include "llvm/ADT/STLExtras.h" 14 #include "llvm/ADT/SmallPtrSet.h" 15 #include "llvm/ADT/StringRef.h" 16 #include "llvm/ADT/iterator.h" 17 #include "llvm/ADT/iterator_range.h" 18 #include "llvm/BinaryFormat/MachO.h" 19 #include "llvm/MC/MCDirectives.h" 20 #include "llvm/MC/MCDwarf.h" 21 #include "llvm/MC/MCFixup.h" 22 #include "llvm/MC/MCFragment.h" 23 #include "llvm/MC/MCLinkerOptimizationHint.h" 24 #include "llvm/MC/MCSymbol.h" 25 #include "llvm/Support/VersionTuple.h" 26 #include <cassert> 27 #include <cstddef> 28 #include <cstdint> 29 #include <string> 30 #include <utility> 31 #include <vector> 32 33 namespace llvm { 34 35 class MCAsmBackend; 36 class MCAsmLayout; 37 class MCContext; 38 class MCCodeEmitter; 39 class MCFragment; 40 class MCObjectWriter; 41 class MCSection; 42 class MCValue; 43 44 // FIXME: This really doesn't belong here. See comments below. 45 struct IndirectSymbolData { 46 MCSymbol *Symbol; 47 MCSection *Section; 48 }; 49 50 // FIXME: Ditto this. Purely so the Streamer and the ObjectWriter can talk 51 // to one another. 52 struct DataRegionData { 53 // This enum should be kept in sync w/ the mach-o definition in 54 // llvm/Object/MachOFormat.h. 55 enum KindTy { Data = 1, JumpTable8, JumpTable16, JumpTable32 } Kind; 56 MCSymbol *Start; 57 MCSymbol *End; 58 }; 59 60 class MCAssembler { 61 friend class MCAsmLayout; 62 63 public: 64 using SectionListType = std::vector<MCSection *>; 65 using SymbolDataListType = std::vector<const MCSymbol *>; 66 67 using const_iterator = pointee_iterator<SectionListType::const_iterator>; 68 using iterator = pointee_iterator<SectionListType::iterator>; 69 70 using const_symbol_iterator = 71 pointee_iterator<SymbolDataListType::const_iterator>; 72 using symbol_iterator = pointee_iterator<SymbolDataListType::iterator>; 73 74 using symbol_range = iterator_range<symbol_iterator>; 75 using const_symbol_range = iterator_range<const_symbol_iterator>; 76 77 using const_indirect_symbol_iterator = 78 std::vector<IndirectSymbolData>::const_iterator; 79 using indirect_symbol_iterator = std::vector<IndirectSymbolData>::iterator; 80 81 using const_data_region_iterator = 82 std::vector<DataRegionData>::const_iterator; 83 using data_region_iterator = std::vector<DataRegionData>::iterator; 84 85 /// MachO specific deployment target version info. 86 // A Major version of 0 indicates that no version information was supplied 87 // and so the corresponding load command should not be emitted. 88 using VersionInfoType = struct { 89 bool EmitBuildVersion; 90 union { 91 MCVersionMinType Type; ///< Used when EmitBuildVersion==false. 92 MachO::PlatformType Platform; ///< Used when EmitBuildVersion==true. 93 } TypeOrPlatform; 94 unsigned Major; 95 unsigned Minor; 96 unsigned Update; 97 /// An optional version of the SDK that was used to build the source. 98 VersionTuple SDKVersion; 99 }; 100 101 private: 102 MCContext &Context; 103 104 std::unique_ptr<MCAsmBackend> Backend; 105 106 std::unique_ptr<MCCodeEmitter> Emitter; 107 108 std::unique_ptr<MCObjectWriter> Writer; 109 110 SectionListType Sections; 111 112 SymbolDataListType Symbols; 113 114 std::vector<IndirectSymbolData> IndirectSymbols; 115 116 std::vector<DataRegionData> DataRegions; 117 118 /// The list of linker options to propagate into the object file. 119 std::vector<std::vector<std::string>> LinkerOptions; 120 121 /// List of declared file names 122 std::vector<std::pair<std::string, size_t>> FileNames; 123 124 MCDwarfLineTableParams LTParams; 125 126 /// The set of function symbols for which a .thumb_func directive has 127 /// been seen. 128 // 129 // FIXME: We really would like this in target specific code rather than 130 // here. Maybe when the relocation stuff moves to target specific, 131 // this can go with it? The streamer would need some target specific 132 // refactoring too. 133 mutable SmallPtrSet<const MCSymbol *, 32> ThumbFuncs; 134 135 /// The bundle alignment size currently set in the assembler. 136 /// 137 /// By default it's 0, which means bundling is disabled. 138 unsigned BundleAlignSize; 139 140 bool RelaxAll : 1; 141 bool SubsectionsViaSymbols : 1; 142 bool IncrementalLinkerCompatible : 1; 143 144 /// ELF specific e_header flags 145 // It would be good if there were an MCELFAssembler class to hold this. 146 // ELF header flags are used both by the integrated and standalone assemblers. 147 // Access to the flags is necessary in cases where assembler directives affect 148 // which flags to be set. 149 unsigned ELFHeaderEFlags; 150 151 /// Used to communicate Linker Optimization Hint information between 152 /// the Streamer and the .o writer 153 MCLOHContainer LOHContainer; 154 155 VersionInfoType VersionInfo; 156 157 /// Evaluate a fixup to a relocatable expression and the value which should be 158 /// placed into the fixup. 159 /// 160 /// \param Layout The layout to use for evaluation. 161 /// \param Fixup The fixup to evaluate. 162 /// \param DF The fragment the fixup is inside. 163 /// \param Target [out] On return, the relocatable expression the fixup 164 /// evaluates to. 165 /// \param Value [out] On return, the value of the fixup as currently laid 166 /// out. 167 /// \param WasForced [out] On return, the value in the fixup is set to the 168 /// correct value if WasForced is true, even if evaluateFixup returns false. 169 /// \return Whether the fixup value was fully resolved. This is true if the 170 /// \p Value result is fixed, otherwise the value may change due to 171 /// relocation. 172 bool evaluateFixup(const MCAsmLayout &Layout, const MCFixup &Fixup, 173 const MCFragment *DF, MCValue &Target, 174 uint64_t &Value, bool &WasForced) const; 175 176 /// Check whether a fixup can be satisfied, or whether it needs to be relaxed 177 /// (increased in size, in order to hold its value correctly). 178 bool fixupNeedsRelaxation(const MCFixup &Fixup, const MCRelaxableFragment *DF, 179 const MCAsmLayout &Layout) const; 180 181 /// Check whether the given fragment needs relaxation. 182 bool fragmentNeedsRelaxation(const MCRelaxableFragment *IF, 183 const MCAsmLayout &Layout) const; 184 185 /// Perform one layout iteration and return true if any offsets 186 /// were adjusted. 187 bool layoutOnce(MCAsmLayout &Layout); 188 189 /// Perform one layout iteration of the given section and return true 190 /// if any offsets were adjusted. 191 bool layoutSectionOnce(MCAsmLayout &Layout, MCSection &Sec); 192 193 /// Perform relaxation on a single fragment - returns true if the fragment 194 /// changes as a result of relaxation. 195 bool relaxFragment(MCAsmLayout &Layout, MCFragment &F); 196 bool relaxInstruction(MCAsmLayout &Layout, MCRelaxableFragment &IF); 197 bool relaxLEB(MCAsmLayout &Layout, MCLEBFragment &IF); 198 bool relaxBoundaryAlign(MCAsmLayout &Layout, MCBoundaryAlignFragment &BF); 199 bool relaxDwarfLineAddr(MCAsmLayout &Layout, MCDwarfLineAddrFragment &DF); 200 bool relaxDwarfCallFrameFragment(MCAsmLayout &Layout, 201 MCDwarfCallFrameFragment &DF); 202 bool relaxCVInlineLineTable(MCAsmLayout &Layout, 203 MCCVInlineLineTableFragment &DF); 204 bool relaxCVDefRange(MCAsmLayout &Layout, MCCVDefRangeFragment &DF); 205 bool relaxPseudoProbeAddr(MCAsmLayout &Layout, MCPseudoProbeAddrFragment &DF); 206 207 /// finishLayout - Finalize a layout, including fragment lowering. 208 void finishLayout(MCAsmLayout &Layout); 209 210 std::tuple<MCValue, uint64_t, bool> 211 handleFixup(const MCAsmLayout &Layout, MCFragment &F, const MCFixup &Fixup); 212 213 public: 214 struct Symver { 215 SMLoc Loc; 216 const MCSymbol *Sym; 217 StringRef Name; 218 // True if .symver *, *@@@* or .symver *, *, remove. 219 bool KeepOriginalSym; 220 }; 221 std::vector<Symver> Symvers; 222 223 /// Construct a new assembler instance. 224 // 225 // FIXME: How are we going to parameterize this? Two obvious options are stay 226 // concrete and require clients to pass in a target like object. The other 227 // option is to make this abstract, and have targets provide concrete 228 // implementations as we do with AsmParser. 229 MCAssembler(MCContext &Context, std::unique_ptr<MCAsmBackend> Backend, 230 std::unique_ptr<MCCodeEmitter> Emitter, 231 std::unique_ptr<MCObjectWriter> Writer); 232 MCAssembler(const MCAssembler &) = delete; 233 MCAssembler &operator=(const MCAssembler &) = delete; 234 ~MCAssembler(); 235 236 /// Compute the effective fragment size assuming it is laid out at the given 237 /// \p SectionAddress and \p FragmentOffset. 238 uint64_t computeFragmentSize(const MCAsmLayout &Layout, 239 const MCFragment &F) const; 240 241 /// Find the symbol which defines the atom containing the given symbol, or 242 /// null if there is no such symbol. 243 const MCSymbol *getAtom(const MCSymbol &S) const; 244 245 /// Check whether a particular symbol is visible to the linker and is required 246 /// in the symbol table, or whether it can be discarded by the assembler. This 247 /// also effects whether the assembler treats the label as potentially 248 /// defining a separate atom. 249 bool isSymbolLinkerVisible(const MCSymbol &SD) const; 250 251 /// Emit the section contents to \p OS. 252 void writeSectionData(raw_ostream &OS, const MCSection *Section, 253 const MCAsmLayout &Layout) const; 254 255 /// Check whether a given symbol has been flagged with .thumb_func. 256 bool isThumbFunc(const MCSymbol *Func) const; 257 258 /// Flag a function symbol as the target of a .thumb_func directive. setIsThumbFunc(const MCSymbol * Func)259 void setIsThumbFunc(const MCSymbol *Func) { ThumbFuncs.insert(Func); } 260 261 /// ELF e_header flags getELFHeaderEFlags()262 unsigned getELFHeaderEFlags() const { return ELFHeaderEFlags; } setELFHeaderEFlags(unsigned Flags)263 void setELFHeaderEFlags(unsigned Flags) { ELFHeaderEFlags = Flags; } 264 265 /// MachO deployment target version information. getVersionInfo()266 const VersionInfoType &getVersionInfo() const { return VersionInfo; } 267 void setVersionMin(MCVersionMinType Type, unsigned Major, unsigned Minor, 268 unsigned Update, 269 VersionTuple SDKVersion = VersionTuple()) { 270 VersionInfo.EmitBuildVersion = false; 271 VersionInfo.TypeOrPlatform.Type = Type; 272 VersionInfo.Major = Major; 273 VersionInfo.Minor = Minor; 274 VersionInfo.Update = Update; 275 VersionInfo.SDKVersion = SDKVersion; 276 } 277 void setBuildVersion(MachO::PlatformType Platform, unsigned Major, 278 unsigned Minor, unsigned Update, 279 VersionTuple SDKVersion = VersionTuple()) { 280 VersionInfo.EmitBuildVersion = true; 281 VersionInfo.TypeOrPlatform.Platform = Platform; 282 VersionInfo.Major = Major; 283 VersionInfo.Minor = Minor; 284 VersionInfo.Update = Update; 285 VersionInfo.SDKVersion = SDKVersion; 286 } 287 288 /// Reuse an assembler instance 289 /// 290 void reset(); 291 getContext()292 MCContext &getContext() const { return Context; } 293 getBackendPtr()294 MCAsmBackend *getBackendPtr() const { return Backend.get(); } 295 getEmitterPtr()296 MCCodeEmitter *getEmitterPtr() const { return Emitter.get(); } 297 getWriterPtr()298 MCObjectWriter *getWriterPtr() const { return Writer.get(); } 299 getBackend()300 MCAsmBackend &getBackend() const { return *Backend; } 301 getEmitter()302 MCCodeEmitter &getEmitter() const { return *Emitter; } 303 getWriter()304 MCObjectWriter &getWriter() const { return *Writer; } 305 getDWARFLinetableParams()306 MCDwarfLineTableParams getDWARFLinetableParams() const { return LTParams; } setDWARFLinetableParams(MCDwarfLineTableParams P)307 void setDWARFLinetableParams(MCDwarfLineTableParams P) { LTParams = P; } 308 309 /// Finish - Do final processing and write the object to the output stream. 310 /// \p Writer is used for custom object writer (as the MCJIT does), 311 /// if not specified it is automatically created from backend. 312 void Finish(); 313 314 // Layout all section and prepare them for emission. 315 void layout(MCAsmLayout &Layout); 316 317 // FIXME: This does not belong here. getSubsectionsViaSymbols()318 bool getSubsectionsViaSymbols() const { return SubsectionsViaSymbols; } setSubsectionsViaSymbols(bool Value)319 void setSubsectionsViaSymbols(bool Value) { SubsectionsViaSymbols = Value; } 320 isIncrementalLinkerCompatible()321 bool isIncrementalLinkerCompatible() const { 322 return IncrementalLinkerCompatible; 323 } setIncrementalLinkerCompatible(bool Value)324 void setIncrementalLinkerCompatible(bool Value) { 325 IncrementalLinkerCompatible = Value; 326 } 327 getRelaxAll()328 bool getRelaxAll() const { return RelaxAll; } setRelaxAll(bool Value)329 void setRelaxAll(bool Value) { RelaxAll = Value; } 330 isBundlingEnabled()331 bool isBundlingEnabled() const { return BundleAlignSize != 0; } 332 getBundleAlignSize()333 unsigned getBundleAlignSize() const { return BundleAlignSize; } 334 setBundleAlignSize(unsigned Size)335 void setBundleAlignSize(unsigned Size) { 336 assert((Size == 0 || !(Size & (Size - 1))) && 337 "Expect a power-of-two bundle align size"); 338 BundleAlignSize = Size; 339 } 340 341 /// \name Section List Access 342 /// @{ 343 begin()344 iterator begin() { return Sections.begin(); } begin()345 const_iterator begin() const { return Sections.begin(); } 346 end()347 iterator end() { return Sections.end(); } end()348 const_iterator end() const { return Sections.end(); } 349 size()350 size_t size() const { return Sections.size(); } 351 352 /// @} 353 /// \name Symbol List Access 354 /// @{ symbol_begin()355 symbol_iterator symbol_begin() { return Symbols.begin(); } symbol_begin()356 const_symbol_iterator symbol_begin() const { return Symbols.begin(); } 357 symbol_end()358 symbol_iterator symbol_end() { return Symbols.end(); } symbol_end()359 const_symbol_iterator symbol_end() const { return Symbols.end(); } 360 symbols()361 symbol_range symbols() { return make_range(symbol_begin(), symbol_end()); } symbols()362 const_symbol_range symbols() const { 363 return make_range(symbol_begin(), symbol_end()); 364 } 365 symbol_size()366 size_t symbol_size() const { return Symbols.size(); } 367 368 /// @} 369 /// \name Indirect Symbol List Access 370 /// @{ 371 372 // FIXME: This is a total hack, this should not be here. Once things are 373 // factored so that the streamer has direct access to the .o writer, it can 374 // disappear. getIndirectSymbols()375 std::vector<IndirectSymbolData> &getIndirectSymbols() { 376 return IndirectSymbols; 377 } 378 indirect_symbol_begin()379 indirect_symbol_iterator indirect_symbol_begin() { 380 return IndirectSymbols.begin(); 381 } indirect_symbol_begin()382 const_indirect_symbol_iterator indirect_symbol_begin() const { 383 return IndirectSymbols.begin(); 384 } 385 indirect_symbol_end()386 indirect_symbol_iterator indirect_symbol_end() { 387 return IndirectSymbols.end(); 388 } indirect_symbol_end()389 const_indirect_symbol_iterator indirect_symbol_end() const { 390 return IndirectSymbols.end(); 391 } 392 indirect_symbol_size()393 size_t indirect_symbol_size() const { return IndirectSymbols.size(); } 394 395 /// @} 396 /// \name Linker Option List Access 397 /// @{ 398 getLinkerOptions()399 std::vector<std::vector<std::string>> &getLinkerOptions() { 400 return LinkerOptions; 401 } 402 403 /// @} 404 /// \name Data Region List Access 405 /// @{ 406 407 // FIXME: This is a total hack, this should not be here. Once things are 408 // factored so that the streamer has direct access to the .o writer, it can 409 // disappear. getDataRegions()410 std::vector<DataRegionData> &getDataRegions() { return DataRegions; } 411 data_region_begin()412 data_region_iterator data_region_begin() { return DataRegions.begin(); } data_region_begin()413 const_data_region_iterator data_region_begin() const { 414 return DataRegions.begin(); 415 } 416 data_region_end()417 data_region_iterator data_region_end() { return DataRegions.end(); } data_region_end()418 const_data_region_iterator data_region_end() const { 419 return DataRegions.end(); 420 } 421 data_region_size()422 size_t data_region_size() const { return DataRegions.size(); } 423 424 /// @} 425 /// \name Data Region List Access 426 /// @{ 427 428 // FIXME: This is a total hack, this should not be here. Once things are 429 // factored so that the streamer has direct access to the .o writer, it can 430 // disappear. getLOHContainer()431 MCLOHContainer &getLOHContainer() { return LOHContainer; } getLOHContainer()432 const MCLOHContainer &getLOHContainer() const { 433 return const_cast<MCAssembler *>(this)->getLOHContainer(); 434 } 435 436 struct CGProfileEntry { 437 const MCSymbolRefExpr *From; 438 const MCSymbolRefExpr *To; 439 uint64_t Count; 440 }; 441 std::vector<CGProfileEntry> CGProfile; 442 /// @} 443 /// \name Backend Data Access 444 /// @{ 445 446 bool registerSection(MCSection &Section); 447 448 void registerSymbol(const MCSymbol &Symbol, bool *Created = nullptr); 449 getFileNames()450 MutableArrayRef<std::pair<std::string, size_t>> getFileNames() { 451 return FileNames; 452 } 453 addFileName(StringRef FileName)454 void addFileName(StringRef FileName) { 455 FileNames.emplace_back(std::string(FileName), Symbols.size()); 456 } 457 458 /// Write the necessary bundle padding to \p OS. 459 /// Expects a fragment \p F containing instructions and its size \p FSize. 460 void writeFragmentPadding(raw_ostream &OS, const MCEncodedFragment &F, 461 uint64_t FSize) const; 462 463 /// @} 464 465 void dump() const; 466 }; 467 468 /// Compute the amount of padding required before the fragment \p F to 469 /// obey bundling restrictions, where \p FOffset is the fragment's offset in 470 /// its section and \p FSize is the fragment's size. 471 uint64_t computeBundlePadding(const MCAssembler &Assembler, 472 const MCEncodedFragment *F, uint64_t FOffset, 473 uint64_t FSize); 474 475 } // end namespace llvm 476 477 #endif // LLVM_MC_MCASSEMBLER_H 478