LLVM 22.0.0git
SFrameParser.cpp
Go to the documentation of this file.
1//===- SFrameParser.cpp ---------------------------------------------------===//
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
11#include "llvm/Object/Error.h"
14
15using namespace llvm;
16using namespace llvm::object;
17
21 // Data.size() cannot be UINT64_MAX, as it would occupy the whole address
22 // space.
23 if (End > Data.size()) {
24 return createStringError(
25 formatv("unexpected end of data at offset {0:x} while reading [{1:x}, "
26 "{2:x})",
27 Data.size(), Offset, End)
28 .str(),
29 object_error::unexpected_eof);
30 }
31 return Data.slice(Offset, Size);
32}
33
34template <typename T>
37 static_assert(std::is_trivial_v<T>);
39 getDataSlice(Data, Offset, sizeof(T) * Count);
40 if (!Slice)
41 return Slice.takeError();
42
43 return ArrayRef(reinterpret_cast<const T *>(Slice->data()), Count);
44}
45
46template <typename T>
49 Expected<ArrayRef<T>> Array = getDataSliceAsArrayOf<T>(Data, Offset, 1);
50 if (!Array)
51 return Array.takeError();
52
53 return Array->front();
54}
55
56template <endianness E>
58 uint64_t SectionAddress) {
60 getDataSliceAs<sframe::Preamble<E>>(Contents, 0);
61 if (!Preamble)
62 return Preamble.takeError();
63
64 if (Preamble->Magic != sframe::Magic)
65 return createError(
66 formatv("invalid magic number ({0:x+4})", Preamble->Magic.value()));
67 if (Preamble->Version != sframe::Version::V2)
68 return createError(
69 formatv("invalid/unsupported version number ({0})",
70 static_cast<unsigned>(Preamble->Version.value())));
71
73 getDataSliceAs<sframe::Header<E>>(Contents, 0);
74 if (!Header)
75 return Header.takeError();
76 return SFrameParser(Contents, SectionAddress, *Header);
77}
78
79template <endianness E>
81 return getDataSlice(Data, sizeof(Header), Header.AuxHdrLen);
82}
83
84template <endianness E>
87 Data, getFDEBase(), Header.NumFDEs * sizeof(sframe::FuncDescEntry<E>));
88 if (!Slice)
89 return Slice.takeError();
90 return ArrayRef(
91 reinterpret_cast<const sframe::FuncDescEntry<E> *>(Slice->data()),
92 Header.NumFDEs);
93}
94
95template <endianness E>
97 typename FDERange::iterator FDE) const {
98 uint64_t Result = SectionAddress + FDE->StartAddress;
99
100 if ((getPreamble().Flags.value() & sframe::Flags::FDEFuncStartPCRel) ==
101 sframe::Flags::FDEFuncStartPCRel)
102 Result += offsetOf(FDE);
103
104 return Result;
105}
106
107template <endianness E>
109 uintptr_t DataPtr = reinterpret_cast<uintptr_t>(Data.data());
110 uintptr_t FDEPtr = reinterpret_cast<uintptr_t>(&*FDE);
111
112 assert(DataPtr <= FDEPtr && FDEPtr < DataPtr + Data.size() &&
113 "Iterator does not belong to this object!");
114 return FDEPtr - DataPtr;
115}
116
117template <typename EndianT>
121 getDataSliceAsArrayOf<EndianT>(Data, Offset, Count);
122 if (!RawArray)
123 return RawArray.takeError();
124 Offset += Count * sizeof(EndianT);
125 Vec.resize(Count);
126 llvm::copy(*RawArray, Vec.begin());
127 return Error::success();
128}
129
130template <typename T, endianness E>
132 typename SFrameParser<E>::FrameRowEntry &FRE) {
134 getDataSliceAs<sframe::FrameRowEntry<T, E>>(Data, Offset);
135 if (!RawFRE)
136 return RawFRE.takeError();
137
138 Offset += sizeof(*RawFRE);
139 FRE.StartAddress = RawFRE->StartAddress;
140 FRE.Info.Info = RawFRE->Info.Info;
141
142 switch (FRE.Info.getOffsetSize()) {
143 case sframe::FREOffset::B1:
144 return readArray<sframe::detail::packed<int8_t, E>>(
145 Data, FRE.Info.getOffsetCount(), Offset, FRE.Offsets);
146 case sframe::FREOffset::B2:
147 return readArray<sframe::detail::packed<int16_t, E>>(
148 Data, FRE.Info.getOffsetCount(), Offset, FRE.Offsets);
149 case sframe::FREOffset::B4:
150 return readArray<sframe::detail::packed<int32_t, E>>(
151 Data, FRE.Info.getOffsetCount(), Offset, FRE.Offsets);
152 }
153 return createError(formatv("unsupported FRE offset size {0} at offset {1:x+}",
154 static_cast<unsigned>(FRE.Info.getOffsetSize()),
155 Offset));
156}
157
159 if (++Idx == Size)
160 return Error::success();
161
162 switch (FREType) {
163 case sframe::FREType::Addr1:
164 return readFRE<uint8_t, E>(Data, Offset, FRE);
165 case sframe::FREType::Addr2:
166 return readFRE<uint16_t, E>(Data, Offset, FRE);
167 case sframe::FREType::Addr4:
168 return readFRE<uint32_t, E>(Data, Offset, FRE);
169 }
170 return createError(formatv("unsupported FRE type {0} at offset {1:x+}",
171 static_cast<unsigned>(FREType), Offset));
172}
173
174template <endianness E>
177 uint64_t Offset = getFREBase() + FDE.StartFREOff;
178 fre_iterator BeforeBegin = make_fallible_itr(
179 FallibleFREIterator(Data, FDE.Info.getFREType(), -1, FDE.NumFREs, Offset),
180 Err);
182 FallibleFREIterator(Data, FDE.Info.getFREType(), FDE.NumFREs, FDE.NumFREs,
183 /*Offset=*/0));
184 return {++BeforeBegin, End};
185}
186
187static std::optional<int32_t> getOffset(ArrayRef<int32_t> Offsets, size_t Idx) {
188 if (Offsets.size() > Idx)
189 return Offsets[Idx];
190 return std::nullopt;
191}
192
193// The interpretation of offsets is ABI-specific. The implementation of this and
194// the following functions may need to be adjusted when adding support for a new
195// ABI.
196template <endianness E>
197std::optional<int32_t>
199 return getOffset(FRE.Offsets, 0);
200}
201
202template <endianness E>
203std::optional<int32_t>
205 if (usesFixedRAOffset())
206 return Header.CFAFixedRAOffset;
207 return getOffset(FRE.Offsets, 1);
208}
209
210template <endianness E>
211std::optional<int32_t>
213 if (usesFixedFPOffset())
214 return Header.CFAFixedFPOffset;
215 return getOffset(FRE.Offsets, usesFixedRAOffset() ? 1 : 2);
216}
217
218template <endianness E>
221 size_t UsedOffsets = 1; // CFA
222 if (!usesFixedRAOffset())
223 ++UsedOffsets;
224 if (!usesFixedFPOffset())
225 ++UsedOffsets;
226 if (FRE.Offsets.size() > UsedOffsets)
227 return ArrayRef<int32_t>(FRE.Offsets).drop_front(UsedOffsets);
228 return {};
229}
230
232template class LLVM_EXPORT_TEMPLATE
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
#define LLVM_EXPORT_TEMPLATE
Definition: Compiler.h:215
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
uint64_t Size
bool End
Definition: ELF_riscv.cpp:480
static Expected< const T & > getDataSliceAs(ArrayRef< uint8_t > Data, uint64_t Offset)
static Error readArray(ArrayRef< uint8_t > Data, uint64_t Count, uint64_t &Offset, SmallVectorImpl< int32_t > &Vec)
static Expected< ArrayRef< T > > getDataSliceAsArrayOf(ArrayRef< uint8_t > Data, uint64_t Offset, uint64_t Count)
static Error readFRE(ArrayRef< uint8_t > Data, uint64_t &Offset, typename SFrameParser< E >::FrameRowEntry &FRE)
static Expected< ArrayRef< uint8_t > > getDataSlice(ArrayRef< uint8_t > Data, uint64_t Offset, uint64_t Size)
This file contains data-structure definitions and constants to support unwinding based on ....
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
ArrayRef< T > drop_front(size_t N=1) const
Drop the first N elements of the array.
Definition: ArrayRef.h:200
Lightweight error class with error context and mandatory checking.
Definition: Error.h:159
static ErrorSuccess success()
Create a success value.
Definition: Error.h:336
Tagged union holding either a T or a Error.
Definition: Error.h:485
Error takeError()
Take ownership of the stored error.
Definition: Error.h:612
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:574
void resize(size_type N)
Definition: SmallVector.h:639
A wrapper class for fallible iterators.
A range adaptor for a pair of iterators.
Expected< ArrayRef< uint8_t > > getAuxHeader() const
std::optional< int32_t > getRAOffset(const FrameRowEntry &FRE) const
static Expected< SFrameParser > create(ArrayRef< uint8_t > Contents, uint64_t SectionAddress)
bool usesFixedFPOffset() const
Definition: SFrameParser.h:37
bool usesFixedRAOffset() const
Definition: SFrameParser.h:34
std::optional< int32_t > getCFAOffset(const FrameRowEntry &FRE) const
iterator_range< fre_iterator > fres(const sframe::FuncDescEntry< E > &FDE, Error &Err) const
std::optional< int32_t > getFPOffset(const FrameRowEntry &FRE) const
uint64_t offsetOf(typename FDERange::iterator FDE) const
ArrayRef< int32_t > getExtraOffsets(const FrameRowEntry &FRE) const
uint64_t getAbsoluteStartAddress(typename FDERange::iterator FDE) const
Expected< FDERange > fdes() const
Error createError(const Twine &Err)
Definition: Error.h:86
constexpr uint16_t Magic
Definition: SFrame.h:32
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:477
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition: Error.h:1305
static Error getOffset(const SymbolRef &Sym, SectionRef Sec, uint64_t &Result)
auto formatv(bool Validate, const char *Fmt, Ts &&...Vals)
fallible_iterator< Underlying > make_fallible_itr(Underlying I, Error &Err)
Convenience wrapper to make a fallible_iterator value from an instance of an underlying iterator and ...
fallible_iterator< Underlying > make_fallible_end(Underlying E)
Convenience wrapper to make a fallible_iterator end value from an instance of an underlying iterator.
OutputIt copy(R &&Range, OutputIt Out)
Definition: STLExtras.h:1854
std::enable_if_t< std::is_unsigned_v< T >, T > SaturatingAdd(T X, T Y, bool *ResultOverflowed=nullptr)
Add two unsigned integers, X and Y, of type T.
Definition: MathExtras.h:614
detail::packed< uint32_t, E > StartFREOff
Definition: SFrame.h:125
detail::packed< uint32_t, E > NumFREs
Definition: SFrame.h:126