DWARFDebugArangeSet.cpp Source File (original) (raw)

25 OS << '[';

27 OS << ", ";

29 OS << ')';

30}

33 Offset = -1ULL;

34 std::memset(&HeaderData, 0, sizeof(Header));

35 ArangeDescriptors.clear();

36}

41 assert(data.isValidOffset(*offset_ptr));

42 ArangeDescriptors.clear();

43 Offset = *offset_ptr;

69 std::tie(HeaderData.Length, HeaderData.Format) =

70 data.getInitialLength(offset_ptr, &Err);

71 HeaderData.Version = data.getU16(offset_ptr, &Err);

72 HeaderData.CuOffset = data.getUnsigned(

74 HeaderData.AddrSize = data.getU8(offset_ptr, &Err);

75 HeaderData.SegSize = data.getU8(offset_ptr, &Err);

76 if (Err) {

78 "parsing address ranges table at offset 0x%" PRIx64

79 ": %s",

81 }

86 if ( data .isValidOffsetForDataOfSize(Offset, full_length))

88 "the length of address range table at offset "

89 "0x%" PRIx64 " exceeds section size",

90 Offset);

93 "address range table at offset 0x%" PRIx64, Offset))

94 return SizeErr;

95 if (HeaderData.SegSize != 0)

97 "non-zero segment selector size in address range "

98 "table at offset 0x%" PRIx64 " is not supported",

99 Offset);

100

101

102

103

104

105 const uint32_t tuple_size = HeaderData.AddrSize * 2;

106 if (full_length % tuple_size != 0)

109 "address range table at offset 0x%" PRIx64

110 " has length that is not a multiple of the tuple size",

111 Offset);

112

113

114 const uint32_t header_size = *offset_ptr - Offset;

115 uint32_t first_tuple_offset = 0;

116 while (first_tuple_offset < header_size)

117 first_tuple_offset += tuple_size;

118

119

120 if (full_length <= first_tuple_offset)

123 "address range table at offset 0x%" PRIx64

124 " has an insufficient length to contain any entries",

125 Offset);

126

127 *offset_ptr = Offset + first_tuple_offset;

128

130

131 static_assert(sizeof(arangeDescriptor.Address) ==

132 sizeof(arangeDescriptor.Length),

133 "Different datatypes for addresses and sizes!");

134 assert(sizeof(arangeDescriptor.Address) >= HeaderData.AddrSize);

135

136 uint64_t end_offset = Offset + full_length;

137 while (*offset_ptr < end_offset) {

138 uint64_t EntryOffset = *offset_ptr;

139 arangeDescriptor.Address = data.getUnsigned(offset_ptr, HeaderData.AddrSize);

140 arangeDescriptor.Length = data.getUnsigned(offset_ptr, HeaderData.AddrSize);

141

142

143

144 if (arangeDescriptor.Length == 0 && arangeDescriptor.Address == 0) {

145 if (*offset_ptr == end_offset)

147 if (WarningHandler) {

150 "address range table at offset 0x%" PRIx64

151 " has a premature terminator entry at offset 0x%" PRIx64,

152 Offset, EntryOffset));

153 }

154 }

155

156 ArangeDescriptors.push_back(arangeDescriptor);

157 }

158

160 "address range table at offset 0x%" PRIx64

161 " is not terminated by null entry",

162 Offset);

163}

167 OS << "Address Range Header: "

168 << format("length = 0x%0*" PRIx64 ", ", OffsetDumpWidth, HeaderData.Length)

170 << format("version = 0x%4.4x, ", HeaderData.Version)

171 << format("cu_offset = 0x%0*" PRIx64 ", ", OffsetDumpWidth,

172 HeaderData.CuOffset)

173 << format("addr_size = 0x%2.2x, ", HeaderData.AddrSize)

174 << format("seg_size = 0x%2.2x\n", HeaderData.SegSize);

175

176 for (const auto &Desc : ArangeDescriptors) {

177 Desc.dump(OS, HeaderData.AddrSize);

178 OS << '\n';

179 }

180}

static Error checkAddressSizeSupported(unsigned AddressSize, std::error_code EC, char const *Fmt, const Ts &...Vals)