mirror of
https://github.com/RPCS3/llvm.git
synced 2026-01-31 01:25:19 +01:00
4534bcb33a
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@364638 91177308-0d34-0410-b5e6-96231b3b80d8
108 lines
4.1 KiB
C++
108 lines
4.1 KiB
C++
//===- FunctionInfo.h -------------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_DEBUGINFO_GSYM_FUNCTIONINFO_H
|
|
#define LLVM_DEBUGINFO_GSYM_FUNCTIONINFO_H
|
|
|
|
#include "llvm/DebugInfo/GSYM/InlineInfo.h"
|
|
#include "llvm/DebugInfo/GSYM/LineEntry.h"
|
|
#include "llvm/DebugInfo/GSYM/Range.h"
|
|
#include "llvm/DebugInfo/GSYM/StringTable.h"
|
|
#include <tuple>
|
|
#include <vector>
|
|
|
|
namespace llvm {
|
|
class raw_ostream;
|
|
namespace gsym {
|
|
|
|
/// Function information in GSYM files encodes information for one
|
|
/// contiguous address range. The name of the function is encoded as
|
|
/// a string table offset and allows multiple functions with the same
|
|
/// name to share the name string in the string table. Line tables are
|
|
/// stored in a sorted vector of gsym::LineEntry objects and are split
|
|
/// into line tables for each function. If a function has a discontiguous
|
|
/// range, it will be split into two gsym::FunctionInfo objects. If the
|
|
/// function has inline functions, the information will be encoded in
|
|
/// the "Inline" member, see gsym::InlineInfo for more information.
|
|
struct FunctionInfo {
|
|
AddressRange Range;
|
|
uint32_t Name; ///< String table offset in the string table.
|
|
std::vector<gsym::LineEntry> Lines;
|
|
InlineInfo Inline;
|
|
|
|
FunctionInfo(uint64_t Addr = 0, uint64_t Size = 0, uint32_t N = 0)
|
|
: Range(Addr, Addr + Size), Name(N) {}
|
|
|
|
bool hasRichInfo() const {
|
|
/// Returns whether we have something else than range and name. When
|
|
/// converting information from a symbol table and from debug info, we
|
|
/// might end up with multiple FunctionInfo objects for the same range
|
|
/// and we need to be able to tell which one is the better object to use.
|
|
return !Lines.empty() || Inline.isValid();
|
|
}
|
|
|
|
bool isValid() const {
|
|
/// Address and size can be zero and there can be no line entries for a
|
|
/// symbol so the only indication this entry is valid is if the name is
|
|
/// not zero. This can happen when extracting information from symbol
|
|
/// tables that do not encode symbol sizes. In that case only the
|
|
/// address and name will be filled in.
|
|
return Name != 0;
|
|
}
|
|
|
|
uint64_t startAddress() const { return Range.Start; }
|
|
uint64_t endAddress() const { return Range.End; }
|
|
uint64_t size() const { return Range.size(); }
|
|
void setStartAddress(uint64_t Addr) { Range.Start = Addr; }
|
|
void setEndAddress(uint64_t Addr) { Range.End = Addr; }
|
|
void setSize(uint64_t Size) { Range.End = Range.Start + Size; }
|
|
|
|
void clear() {
|
|
Range = {0, 0};
|
|
Name = 0;
|
|
Lines.clear();
|
|
Inline.clear();
|
|
}
|
|
};
|
|
|
|
inline bool operator==(const FunctionInfo &LHS, const FunctionInfo &RHS) {
|
|
return LHS.Range == RHS.Range && LHS.Name == RHS.Name &&
|
|
LHS.Lines == RHS.Lines && LHS.Inline == RHS.Inline;
|
|
}
|
|
inline bool operator!=(const FunctionInfo &LHS, const FunctionInfo &RHS) {
|
|
return !(LHS == RHS);
|
|
}
|
|
/// This sorting will order things consistently by address range first, but then
|
|
/// followed by inlining being valid and line tables. We might end up with a
|
|
/// FunctionInfo from debug info that will have the same range as one from the
|
|
/// symbol table, but we want to quickly be able to sort and use the best version
|
|
/// when creating the final GSYM file.
|
|
inline bool operator<(const FunctionInfo &LHS, const FunctionInfo &RHS) {
|
|
// First sort by address range
|
|
if (LHS.Range != RHS.Range)
|
|
return LHS.Range < RHS.Range;
|
|
|
|
// Then sort by inline
|
|
if (LHS.Inline.isValid() != RHS.Inline.isValid())
|
|
return RHS.Inline.isValid();
|
|
|
|
// If the number of lines is the same, then compare line table entries
|
|
if (LHS.Lines.size() == RHS.Lines.size())
|
|
return LHS.Lines < RHS.Lines;
|
|
// Then sort by number of line table entries (more is better)
|
|
return LHS.Lines.size() < RHS.Lines.size();
|
|
}
|
|
|
|
raw_ostream &operator<<(raw_ostream &OS, const FunctionInfo &R);
|
|
|
|
} // namespace gsym
|
|
} // namespace llvm
|
|
|
|
#endif // #ifndef LLVM_DEBUGINFO_GSYM_FUNCTIONINFO_H
|