Coverage Report

Created: 2022-01-15 10:30

/Users/buildslave/jenkins/workspace/coverage/llvm-project/lldb/include/lldb/Symbol/DWARFCallFrameInfo.h
Line
Count
Source
1
//===-- DWARFCallFrameInfo.h ------------------------------------*- C++ -*-===//
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
9
#ifndef LLDB_SYMBOL_DWARFCALLFRAMEINFO_H
10
#define LLDB_SYMBOL_DWARFCALLFRAMEINFO_H
11
12
#include <map>
13
#include <mutex>
14
15
#include "lldb/Core/AddressRange.h"
16
#include "lldb/Core/dwarf.h"
17
#include "lldb/Symbol/ObjectFile.h"
18
#include "lldb/Symbol/UnwindPlan.h"
19
#include "lldb/Utility/Flags.h"
20
#include "lldb/Utility/RangeMap.h"
21
#include "lldb/Utility/VMRange.h"
22
#include "lldb/lldb-private.h"
23
24
namespace lldb_private {
25
26
// DWARFCallFrameInfo is a class which can read eh_frame and DWARF Call Frame
27
// Information FDEs.  It stores little information internally. Only two APIs
28
// are exported - one to find the high/low pc values of a function given a text
29
// address via the information in the eh_frame / debug_frame, and one to
30
// generate an UnwindPlan based on the FDE in the eh_frame / debug_frame
31
// section.
32
33
class DWARFCallFrameInfo {
34
public:
35
  enum Type { EH, DWARF };
36
37
  DWARFCallFrameInfo(ObjectFile &objfile, lldb::SectionSP &section, Type type);
38
39
6.94k
  ~DWARFCallFrameInfo() = default;
40
41
  // Locate an AddressRange that includes the provided Address in this object's
42
  // eh_frame/debug_info Returns true if a range is found to cover that
43
  // address.
44
  bool GetAddressRange(Address addr, AddressRange &range);
45
46
  /// Return an UnwindPlan based on the call frame information encoded in the
47
  /// FDE of this DWARFCallFrameInfo section. The returned plan will be valid
48
  /// (at least) for the given address.
49
  bool GetUnwindPlan(const Address &addr, UnwindPlan &unwind_plan);
50
51
  /// Return an UnwindPlan based on the call frame information encoded in the
52
  /// FDE of this DWARFCallFrameInfo section. The returned plan will be valid
53
  /// (at least) for some address in the given range.
54
  bool GetUnwindPlan(const AddressRange &range, UnwindPlan &unwind_plan);
55
56
  typedef RangeVector<lldb::addr_t, uint32_t> FunctionAddressAndSizeVector;
57
58
  // Build a vector of file address and size for all functions in this Module
59
  // based on the eh_frame FDE entries.
60
  //
61
  // The eh_frame information can be a useful source of file address and size
62
  // of the functions in a Module.  Often a binary's non-exported symbols are
63
  // stripped before shipping so lldb won't know the start addr / size of many
64
  // functions in the Module.  But the eh_frame can help to give the addresses
65
  // of these stripped symbols, at least.
66
  //
67
  // \param[out] function_info
68
  //      A vector provided by the caller is filled out.  May be empty if no
69
  //      FDEs/no eh_frame
70
  //      is present in this Module.
71
72
  void
73
  GetFunctionAddressAndSizeVector(FunctionAddressAndSizeVector &function_info);
74
75
  void ForEachFDEEntries(
76
      const std::function<bool(lldb::addr_t, uint32_t, dw_offset_t)> &callback);
77
78
private:
79
  enum { CFI_AUG_MAX_SIZE = 8, CFI_HEADER_SIZE = 8 };
80
  enum CFIVersion {
81
    CFI_VERSION1 = 1, // DWARF v.2
82
    CFI_VERSION3 = 3, // DWARF v.3
83
    CFI_VERSION4 = 4  // DWARF v.4, v.5
84
  };
85
86
  struct CIE {
87
    dw_offset_t cie_offset;
88
    uint8_t version;
89
    char augmentation[CFI_AUG_MAX_SIZE]; // This is typically empty or very
90
                                         // short.
91
    uint8_t address_size = sizeof(uint32_t); // The size of a target address.
92
    uint8_t segment_size = 0;                // The size of a segment selector.
93
94
    uint32_t code_align;
95
    int32_t data_align;
96
    uint32_t return_addr_reg_num;
97
    dw_offset_t inst_offset; // offset of CIE instructions in mCFIData
98
    uint32_t inst_length;    // length of CIE instructions in mCFIData
99
    uint8_t ptr_encoding;
100
    uint8_t lsda_addr_encoding;   // The encoding of the LSDA address in the FDE
101
                                  // augmentation data
102
    lldb::addr_t personality_loc; // (file) address of the pointer to the
103
                                  // personality routine
104
    lldb_private::UnwindPlan::Row initial_row;
105
106
    CIE(dw_offset_t offset)
107
        : cie_offset(offset), version(-1), code_align(0), data_align(0),
108
          return_addr_reg_num(LLDB_INVALID_REGNUM), inst_offset(0),
109
          inst_length(0), ptr_encoding(0), lsda_addr_encoding(DW_EH_PE_omit),
110
63.9k
          personality_loc(LLDB_INVALID_ADDRESS) {}
111
  };
112
113
  typedef std::shared_ptr<CIE> CIESP;
114
115
  typedef std::map<dw_offset_t, CIESP> cie_map_t;
116
117
  // Start address (file address), size, offset of FDE location used for
118
  // finding an FDE for a given File address; the start address field is an
119
  // offset into an individual Module.
120
  typedef RangeDataVector<lldb::addr_t, uint32_t, dw_offset_t> FDEEntryMap;
121
122
  bool IsEHFrame() const;
123
124
  llvm::Optional<FDEEntryMap::Entry>
125
  GetFirstFDEEntryInRange(const AddressRange &range);
126
127
  void GetFDEIndex();
128
129
  bool FDEToUnwindPlan(uint32_t offset, Address startaddr,
130
                       UnwindPlan &unwind_plan);
131
132
  const CIE *GetCIE(dw_offset_t cie_offset);
133
134
  void GetCFIData();
135
136
  // Applies the specified DWARF opcode to the given row. This function handle
137
  // the commands operates only on a single row (these are the ones what can
138
  // appear both in
139
  // CIE and in FDE).
140
  // Returns true if the opcode is handled and false otherwise.
141
  bool HandleCommonDwarfOpcode(uint8_t primary_opcode, uint8_t extended_opcode,
142
                               int32_t data_align, lldb::offset_t &offset,
143
                               UnwindPlan::Row &row);
144
145
  ObjectFile &m_objfile;
146
  lldb::SectionSP m_section_sp;
147
  Flags m_flags = 0;
148
  cie_map_t m_cie_map;
149
150
  DataExtractor m_cfi_data;
151
  bool m_cfi_data_initialized = false; // only copy the section into the DE once
152
153
  FDEEntryMap m_fde_index;
154
  bool m_fde_index_initialized = false; // only scan the section for FDEs once
155
  std::mutex m_fde_index_mutex; // and isolate the thread that does it
156
157
  Type m_type;
158
159
  CIESP
160
  ParseCIE(const uint32_t cie_offset);
161
162
57
  lldb::RegisterKind GetRegisterKind() const {
163
57
    return m_type == EH ? 
lldb::eRegisterKindEHFrame51
:
lldb::eRegisterKindDWARF6
;
164
57
  }
165
};
166
167
} // namespace lldb_private
168
169
#endif // LLDB_SYMBOL_DWARFCALLFRAMEINFO_H