llvm/llvm/lib/ExecutionEngine/JITLink/EHFrameSupport.cpp

//===-------- JITLink_EHFrameSupport.cpp - JITLink eh-frame utils ---------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "EHFrameSupportImpl.h"

#include "llvm/BinaryFormat/Dwarf.h"
#include "llvm/Config/config.h"
#include "llvm/ExecutionEngine/JITLink/DWARFRecordSectionSplitter.h"
#include "llvm/ExecutionEngine/Orc/TargetProcess/RegisterEHFrames.h"
#include "llvm/Support/DynamicLibrary.h"

#define DEBUG_TYPE …

namespace llvm {
namespace jitlink {

EHFrameEdgeFixer::EHFrameEdgeFixer(StringRef EHFrameSectionName,
                                   unsigned PointerSize, Edge::Kind Pointer32,
                                   Edge::Kind Pointer64, Edge::Kind Delta32,
                                   Edge::Kind Delta64, Edge::Kind NegDelta32)
    : … { … }

Error EHFrameEdgeFixer::operator()(LinkGraph &G) { … }

static Expected<size_t> readCFIRecordLength(const Block &B,
                                            BinaryStreamReader &R) { … }

Error EHFrameEdgeFixer::processBlock(ParseContext &PC, Block &B) { … }

Error EHFrameEdgeFixer::processCIE(ParseContext &PC, Block &B,
                                   size_t CIEDeltaFieldOffset,
                                   const BlockEdgesInfo &BlockEdges) { … }

Error EHFrameEdgeFixer::processFDE(ParseContext &PC, Block &B,
                                   size_t CIEDeltaFieldOffset,
                                   uint32_t CIEDelta,
                                   const BlockEdgesInfo &BlockEdges) { … }

Expected<EHFrameEdgeFixer::AugmentationInfo>
EHFrameEdgeFixer::parseAugmentationString(BinaryStreamReader &RecordReader) { … }

Expected<uint8_t> EHFrameEdgeFixer::readPointerEncoding(BinaryStreamReader &R,
                                                        Block &InBlock,
                                                        const char *FieldName) { … }

Error EHFrameEdgeFixer::skipEncodedPointer(uint8_t PointerEncoding,
                                           BinaryStreamReader &RecordReader) { … }

Expected<Symbol *> EHFrameEdgeFixer::getOrCreateEncodedPointerEdge(
    ParseContext &PC, const BlockEdgesInfo &BlockEdges, uint8_t PointerEncoding,
    BinaryStreamReader &RecordReader, Block &BlockToFix,
    size_t PointerFieldOffset, const char *FieldName) { … }

Expected<Symbol &> EHFrameEdgeFixer::getOrCreateSymbol(ParseContext &PC,
                                                       orc::ExecutorAddr Addr) { … }

char EHFrameNullTerminator::NullTerminatorBlockContent[4] = …;

EHFrameNullTerminator::EHFrameNullTerminator(StringRef EHFrameSectionName)
    : … { … }

Error EHFrameNullTerminator::operator()(LinkGraph &G) { … }

EHFrameRegistrar::~EHFrameRegistrar() = default;

Error InProcessEHFrameRegistrar::registerEHFrames(
    orc::ExecutorAddrRange EHFrameSection) { … }

Error InProcessEHFrameRegistrar::deregisterEHFrames(
    orc::ExecutorAddrRange EHFrameSection) { … }

EHFrameCFIBlockInspector EHFrameCFIBlockInspector::FromEdgeScan(Block &B) { … }

EHFrameCFIBlockInspector::EHFrameCFIBlockInspector(Edge *PersonalityEdge)
    : … { … }

EHFrameCFIBlockInspector::EHFrameCFIBlockInspector(Edge &CIEEdge,
                                                   Edge &PCBeginEdge,
                                                   Edge *LSDAEdge)
    : … { … }

LinkGraphPassFunction
createEHFrameRecorderPass(const Triple &TT,
                          StoreFrameRangeFunction StoreRangeAddress) { … }

} // end namespace jitlink
} // end namespace llvm