FunctionInfo.cpp Source File (original) (raw)

15#include

17using namespace llvm;

18using namespace gsym;

28};

38 return OS;

39}

45 if ( Data .isValidOffsetForDataOfSize(Offset, 4))

47 "0x%8.8" PRIx64 ": missing FunctionInfo Size", Offset);

49 if ( Data .isValidOffsetForDataOfSize(Offset, 4))

51 "0x%8.8" PRIx64 ": missing FunctionInfo Name", Offset);

53 if (FI.Name == 0)

55 "0x%8.8" PRIx64 ": invalid FunctionInfo Name value 0x%8.8x",

57 bool Done = false;

58 while ( Done ) {

59 if ( Data .isValidOffsetForDataOfSize(Offset, 4))

61 "0x%8.8" PRIx64 ": missing FunctionInfo InfoType value", Offset);

63 if ( Data .isValidOffsetForDataOfSize(Offset, 4))

65 "0x%8.8" PRIx64 ": missing FunctionInfo InfoType length", Offset);

67 if ( Data .isValidOffsetForDataOfSize(Offset, InfoLength))

69 "0x%8.8" PRIx64 ": missing FunctionInfo data for InfoType %u",

72 Data.isLittleEndian(),

73 Data.getAddressSize());

74 switch (IT) {

75 case InfoType::EndOfList:

77 break;

79 case InfoType::LineTableInfo:

82 else

83 return LT.takeError();

84 break;

86 case InfoType::InlineInfo:

88 FI.Inline = std::move(II.get());

89 else

90 return II.takeError();

91 break;

93 case InfoType::MergedFunctionsInfo:

97 else

98 return MI.takeError();

99 break;

100

101 case InfoType::CallSiteInfo:

104 FI.CallSites = std::move(CI.get());

105 else

106 return CI.takeError();

107 break;

108

109 default:

111 "0x%8.8" PRIx64 ": unsupported InfoType %u",

113 }

114 Offset += InfoLength;

115 }

116 return std::move(FI);

117}

118

122 return 0;

126 if (!Result) {

129 return 0;

130 }

132}

133

135 bool NoPadding) const {

138 "attempted to encode invalid FunctionInfo object");

139

140 if (NoPadding == false)

143

144

145

146

149

152 return FuncInfoOffset;

153 }

154

155

157

159

161 Out.writeU32(InfoType::LineTableInfo);

162

163

165 const auto StartOffset = Out.tell();

167 if (err)

168 return std::move(err);

169 const auto Length = Out.tell() - StartOffset;

170 if (Length > UINT32_MAX)

172 "LineTable length is greater than UINT32_MAX");

173

175 }

176

177

179 Out.writeU32(InfoType::InlineInfo);

180

181

183 const auto StartOffset = Out.tell();

185 if (err)

186 return std::move(err);

187 const auto Length = Out.tell() - StartOffset;

188 if (Length > UINT32_MAX)

190 "InlineInfo length is greater than UINT32_MAX");

191

193 }

194

195

197 Out.writeU32(InfoType::MergedFunctionsInfo);

198

199

201 const auto StartOffset = Out.tell();

203 if (err)

204 return std::move(err);

205 const auto Length = Out.tell() - StartOffset;

206 if (Length > UINT32_MAX)

208 std::errc::invalid_argument,

209 "MergedFunctionsInfo length is greater than UINT32_MAX");

210

212 }

213

214

216 Out.writeU32(InfoType::CallSiteInfo);

217

218

220 const auto StartOffset = Out.tell();

222 if (Err)

223 return std::move(Err);

224 const auto Length = Out.tell() - StartOffset;

225 if (Length > UINT32_MAX)

227 "CallSites length is greater than UINT32_MAX");

228

230 }

231

232

233 Out.writeU32(InfoType::EndOfList);

235 return FuncInfoOffset;

236}

237

241 std::optional *MergedFuncsData) {

247

248

249

252 "FunctionInfo data is truncated");

253

254

255

258 "address 0x%" PRIx64 " is not in GSYM", Addr);

259

260 if (NameOffset == 0)

262 "0x%8.8" PRIx64 ": invalid FunctionInfo Name value 0x00000000",

265 bool Done = false;

266 std::optional LineEntry;

267 std::optional InlineInfoData;

268 while ( Done ) {

269 if ( Data .isValidOffsetForDataOfSize(Offset, 8))

271 "FunctionInfo data is truncated");

275 if (InfoLength != InfoBytes.size())

277 "FunctionInfo data is truncated");

279 Data.getAddressSize());

280 switch (IT) {

281 case InfoType::EndOfList:

283 break;

284

285 case InfoType::LineTableInfo:

288 else

289 return ExpectedLE.takeError();

290 break;

291

292 case InfoType::MergedFunctionsInfo:

293

294 if (MergedFuncsData)

295 *MergedFuncsData = InfoData;

296 break;

297

298 case InfoType::InlineInfo:

299

300

301 InlineInfoData = InfoData;

302 break;

303

304 default:

305 break;

306 }

307 Offset += InfoLength;

308 }

309

311

312

317 return LR;

318 }

319

321 if (!LineEntryFile)

323 "failed to extract file[%" PRIu32 "]",

325

329 SrcLoc.Dir = GR.getString(LineEntryFile->Dir);

333

334 if (!InlineInfoData)

335 return LR;

336

337

340 if (Err)

341 return std::move(Err);

342 return LR;

343}

static cl::opt< ITMode > IT(cl::desc("IT block support"), cl::Hidden, cl::init(DefaultIT), cl::values(clEnumValN(DefaultIT, "arm-default-it", "Generate any type of IT block"), clEnumValN(RestrictedIT, "arm-restrict-it", "Disallow complex IT blocks")))

InfoType

FunctionInfo information type that is used to encode the optional data that is associated with a Func...

uint64_t IntrinsicInst * II

bool contains(uint64_t Addr) const

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

Lightweight error class with error context and mandatory checking.

Tagged union holding either a T or a Error.

pointer data()

Return a pointer to the vector's buffer, even if empty().

StringRef - Represent a constant reference to a string, i.e.

constexpr size_t size() const

size - Get the string size.

A simplified binary data writer class that doesn't require targets, target definitions,...

uint64_t tell()

Return the current offset within the file.

void fixup32(uint32_t Value, uint64_t Offset)

Fixup a uint32_t value at the specified offset in the stream.

void alignTo(size_t Align)

Pad with zeroes at the current file position until the current file position matches the specified al...

void writeU32(uint32_t Value)

Write a single uint32_t value into the stream at the current file position.

void writeData(llvm::ArrayRef< uint8_t > Data)

Write an array of uint8_t values into the stream at the current file position.

llvm::endianness getByteOrder() const

GsymReader is used to read GSYM data from a file or buffer.

std::optional< FileEntry > getFile(uint32_t Index) const

Get the a file entry for the suppplied file index.

StringRef getString(uint32_t Offset) const

Get a string from the string table.

static llvm::Expected< LineTable > decode(DataExtractor &Data, uint64_t BaseAddr)

Decode an LineTable object from a binary data stream.

static Expected< LineEntry > lookup(DataExtractor &Data, uint64_t BaseAddr, uint64_t Addr)

Lookup a single address within a line table's data.

This class implements an extremely fast bulk output stream that can only output to a stream.

A raw_ostream that writes to an SmallVector or SmallString.

raw_ostream & operator<<(raw_ostream &OS, const CallSiteInfo &CSI)

This is an optimization pass for GlobalISel generic memory operations.

Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)

Create formatted StringError object.

void consumeError(Error Err)

Consume a Error without doing anything.

static llvm::Expected< CallSiteInfoCollection > decode(DataExtractor &Data)

Decode a CallSiteInfoCollection object from a binary data stream.

Function information in GSYM files encodes information for one contiguous address range.

std::optional< InlineInfo > Inline

std::optional< MergedFunctionsInfo > MergedFunctions

bool isValid() const

Query if a FunctionInfo object is valid.

std::optional< CallSiteInfoCollection > CallSites

static llvm::Expected< LookupResult > lookup(DataExtractor &Data, const GsymReader &GR, uint64_t FuncAddr, uint64_t Addr, std::optional< DataExtractor > *MergedFuncsData=nullptr)

Lookup an address within a FunctionInfo object's data stream.

uint64_t cacheEncoding()

Encode this function info into the internal byte cache and return the size in bytes.

uint32_t Name

String table offset in the string table.

llvm::Expected< uint64_t > encode(FileWriter &O, bool NoPadding=false) const

Encode this object into FileWriter stream.

SmallString< 32 > EncodingCache

If we encode a FunctionInfo during segmenting so we know its size, we can cache that encoding here so...

std::optional< LineTable > OptLineTable

Inline information stores the name of the inline function along with an array of address ranges.

static llvm::Error lookup(const GsymReader &GR, DataExtractor &Data, uint64_t BaseAddr, uint64_t Addr, SourceLocations &SrcLocs)

Lookup a single address within the inline info data.

static llvm::Expected< InlineInfo > decode(DataExtractor &Data, uint64_t BaseAddr)

Decode an InlineInfo object from a binary data stream.

Line entries are used to encode the line tables in FunctionInfo objects.

uint32_t File

1 based index of file in FileTable

uint32_t Line

Source line number.

uint64_t LookupAddr

The address that this lookup pertains to.

AddressRange FuncRange

The concrete function address range.

StringRef FuncName

The concrete function name that contains LookupAddr.

SourceLocations Locations

The source locations that match this address.

static llvm::Expected< MergedFunctionsInfo > decode(DataExtractor &Data, uint64_t BaseAddr)

Decode an MergedFunctionsInfo object from a binary data stream.

StringRef Base

Line entry source file basename.

uint32_t Line

Source file line number.

uint32_t Offset

Byte size offset within the named function.

StringRef Dir

Line entry source file directory path.

StringRef Name

Function or symbol name.