]> git.saurik.com Git - apple/ld64.git/blobdiff - src/ld/OutputFile.h
ld64-264.3.101.tar.gz
[apple/ld64.git] / src / ld / OutputFile.h
index 415d24b29383ad2f6fa86f75d84fd4eb5905f891..5fd27d80592c0d72253598a2df33826e34edbb0c 100644 (file)
@@ -65,15 +65,14 @@ public:
        uint32_t                                        encryptedTextStartOffset()      { return _encryptedTEXTstartOffset; }
        uint32_t                                        encryptedTextEndOffset()        { return _encryptedTEXTendOffset; }
        int                                                     compressedOrdinalForAtom(const ld::Atom* target);
+       uint64_t                                        fileSize() const { return _fileSize; }
        
        
-       
-       bool                                            hasWeakExternalSymbols;
        bool                                            usesWeakExternalSymbols;
        bool                                            overridesWeakExternalSymbols;
        bool                                            _noReExportedDylibs;
-       bool                                            hasThreadLocalVariableDefinitions;
        bool                                            pieDisabled;
+       bool                                            hasDataInCode;
        ld::Internal::FinalSection*     headerAndLoadCommandsSection;
        ld::Internal::FinalSection*     rebaseSection;
        ld::Internal::FinalSection*     bindingSection;
@@ -82,6 +81,8 @@ public:
        ld::Internal::FinalSection*     exportSection;
        ld::Internal::FinalSection*     splitSegInfoSection;
        ld::Internal::FinalSection*     functionStartsSection;
+       ld::Internal::FinalSection*     dataInCodeSection;
+       ld::Internal::FinalSection*     optimizationHintsSection;
        ld::Internal::FinalSection*     symbolTableSection;
        ld::Internal::FinalSection*     stringPoolSection;
        ld::Internal::FinalSection*     localRelocationsSection;
@@ -130,13 +131,27 @@ public:
        };
        
        struct SplitSegInfoEntry {
-                                               SplitSegInfoEntry(uint64_t a, ld::Fixup::Kind k, uint32_t e=0) : address(a), kind(k), extra(e) {}
-               uint64_t                address;
+                                               SplitSegInfoEntry(uint64_t a, ld::Fixup::Kind k, uint32_t e=0)
+                                                       : fixupAddress(a), kind(k), extra(e) {}
+               uint64_t                fixupAddress;
                ld::Fixup::Kind kind;
         uint32_t        extra;
        };
        
+       struct SplitSegInfoV2Entry {
+                                               SplitSegInfoV2Entry(uint8_t fi, uint64_t fo, uint8_t ti, uint64_t to, uint8_t k)
+                                                       : fixupSectionOffset(fo), targetSectionOffset(to), fixupSectionIndex(fi), targetSectionIndex(ti), referenceKind(k) {}
+               uint64_t                fixupSectionOffset;
+               uint64_t                targetSectionOffset;
+               uint8_t                 fixupSectionIndex;
+               uint8_t                 targetSectionIndex;
+               uint8_t                 referenceKind;
+       };
+       static void                                     dumpAtomsBySection(ld::Internal& state, bool);
+
 private:
+       void                                            writeAtoms(ld::Internal& state, uint8_t* wholeBuffer);
+       void                                            computeContentUUID(ld::Internal& state, uint8_t* wholeBuffer);
        void                                            buildDylibOrdinalMapping(ld::Internal&);
        bool                                            hasOrdinalForInstallPath(const char* path, int* ordinal);
        void                                            addLoadCommands(ld::Internal& state);
@@ -145,11 +160,10 @@ private:
        void                                            generateLinkEditInfo(ld::Internal& state);
        void                                            buildSymbolTable(ld::Internal& state);
        void                                            writeOutputFile(ld::Internal& state);
-       void                                            assignFileOffsets(ld::Internal& state);
-       void                                            setSectionSizesAndAlignments(ld::Internal& state);
        void                                            addSectionRelocs(ld::Internal& state, ld::Internal::FinalSection* sect,  
                                                                                                const ld::Atom* atom, ld::Fixup* fixupWithTarget, 
-                                                                                               ld::Fixup* fixupWithMinusTarget, ld::Fixup* fixupWithStore,
+                                                                                               ld::Fixup* fixupWithMinusTarget, ld::Fixup* fixupWithAddend,
+                                                                                                ld::Fixup* fixupWithStore,
                                                                                                const ld::Atom* target, const ld::Atom* minusTarget, 
                                                                                                uint64_t targetAddend, uint64_t minusTargetAddend);
        void                                            addDyldInfo(ld::Internal& state, ld::Internal::FinalSection* sect,  
@@ -164,6 +178,7 @@ private:
                                                                                                uint64_t targetAddend, uint64_t minusTargetAddend);
        bool                                            useExternalSectionReloc(const ld::Atom* atom, const ld::Atom* target, 
                                                                                                                        ld::Fixup* fixupWithTarget);
+       bool                                            useSectionRelocAddend(ld::Fixup* fixupWithTarget);
        uint64_t                                        pageAlign(uint64_t addr);
        uint64_t                                        pageAlign(uint64_t addr, uint64_t pageSize);
        void                                            setLoadCommandsPadding(ld::Internal& state);
@@ -188,12 +203,17 @@ private:
        void                                            makeSectionRelocations(ld::Internal& state);
        void                                            makeDyldInfo(ld::Internal& state);
        void                                            makeSplitSegInfo(ld::Internal& state);
+       void                                            makeSplitSegInfoV2(ld::Internal& state);
        void                                            writeMapFile(ld::Internal& state);
        uint64_t                                        lookBackAddend(ld::Fixup::iterator fit);
        bool                                            takesNoDiskSpace(const ld::Section* sect);
        bool                                            hasZeroForFileOffset(const ld::Section* sect);
        
        void                                            printSectionLayout(ld::Internal& state);
+       
+       bool                                            checkThumbBranch22Displacement(int64_t displacement);
+       bool                                            checkArmBranch24Displacement(int64_t displacement);
+
        void                                            rangeCheck8(int64_t delta, ld::Internal& state, const ld::Atom* atom, 
                                                                                                                                                                                        const ld::Fixup* fixup);
        void                                            rangeCheck16(int64_t delta, ld::Internal& state, const ld::Atom* atom, 
@@ -210,18 +230,32 @@ private:
                                                                                                                                                                                        const ld::Fixup* fixup);
        void                                            rangeCheckThumbBranch22(int64_t delta, ld::Internal& state, const ld::Atom* atom, 
                                                                                                                                                                                        const ld::Fixup* fixup);
-       void                                            rangeCheckPPCBranch24(int64_t delta, ld::Internal& state, const ld::Atom* atom, 
+       void                                            rangeCheckARM64Branch26(int64_t delta, ld::Internal& state, const ld::Atom* atom, 
                                                                                                                                                                                        const ld::Fixup* fixup);
-       void                                            rangeCheckPPCBranch14(int64_t delta, ld::Internal& state, const ld::Atom* atom, 
+       void                                            rangeCheckARM64Page21(int64_t delta, ld::Internal& state, const ld::Atom* atom, 
                                                                                                                                                                                        const ld::Fixup* fixup);
+                                                                                                                                                                                       
+                                                                                                                                                                                       
        uint64_t                                        sectionOffsetOf(const ld::Internal& state, const ld::Fixup* fixup);
        uint64_t                                        tlvTemplateOffsetOf(const ld::Internal& state, const ld::Fixup* fixup);
-       void                                            dumpAtomsBySection(ld::Internal& state, bool);
        void                                            synthesizeDebugNotes(ld::Internal& state);
        const char*                                     assureFullPath(const char* path);
        void                                            noteTextReloc(const ld::Atom* atom, const ld::Atom* target);
 
        
+       struct InstructionInfo {
+               uint32_t                        offsetInAtom;
+               const ld::Fixup*        fixup; 
+               const ld::Atom*         target; 
+               uint64_t                        targetAddress;
+               uint8_t*                        instructionContent;
+               uint64_t                        instructionAddress;
+               uint32_t                        instruction;
+       };
+
+       void setInfo(ld::Internal& state, const ld::Atom* atom, uint8_t* buffer, const std::map<uint32_t, const Fixup*>& usedHints, 
+                                               uint32_t offsetInAtom, uint32_t delta, InstructionInfo* info);
+
        static uint16_t                         get16LE(uint8_t* loc);
        static void                                     set16LE(uint8_t* loc, uint16_t value);
        static uint32_t                         get32LE(uint8_t* loc);
@@ -247,9 +281,11 @@ private:
        const bool                                                              _hasSectionRelocations;
        const bool                                                              _hasSplitSegInfo;
        const bool                                                              _hasFunctionStartsInfo;
+       const bool                                                              _hasDataInCodeInfo;
                  bool                                                          _hasDynamicSymbolTable;
                  bool                                                          _hasLocalRelocations;
                  bool                                                          _hasExternalRelocations;
+                 bool                                                          _hasOptimizationHints;
        uint64_t                                                                _fileSize;
        std::map<uint64_t, uint32_t>                    _lazyPointerAddressToInfoOffset;
        uint32_t                                                                _encryptedTEXTstartOffset;
@@ -270,6 +306,7 @@ public:
        std::vector<BindingInfo>                                _lazyBindingInfo;
        std::vector<BindingInfo>                                _weakBindingInfo;
        std::vector<SplitSegInfoEntry>                  _splitSegInfos;
+       std::vector<SplitSegInfoV2Entry>                _splitSegV2Infos;
        class HeaderAndLoadCommandsAbtract*             _headersAndLoadCommandAtom;
        class RelocationsAtomAbstract*                  _sectionsRelocationsAtom;
        class RelocationsAtomAbstract*                  _localRelocsAtom;
@@ -284,6 +321,8 @@ public:
        class LinkEditAtom*                                             _exportInfoAtom;
        class LinkEditAtom*                                             _splitSegInfoAtom;
        class LinkEditAtom*                                             _functionStartsAtom;
+       class LinkEditAtom*                                             _dataInCodeAtom;
+       class LinkEditAtom*                                             _optimizationHintsAtom;
 };
 
 } // namespace tool