| File: | src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Support/Alignment.h |
| Warning: | line 85, column 47 The result of the left shift is undefined due to shifting by '255', which is greater or equal to the width of type 'uint64_t' |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
| 1 | //===--- lib/CodeGen/DIE.cpp - DWARF Info Entries -------------------------===// | |||
| 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 | // Data structures for DWARF info entries. | |||
| 10 | // | |||
| 11 | //===----------------------------------------------------------------------===// | |||
| 12 | ||||
| 13 | #include "llvm/CodeGen/DIE.h" | |||
| 14 | #include "DwarfCompileUnit.h" | |||
| 15 | #include "DwarfDebug.h" | |||
| 16 | #include "DwarfUnit.h" | |||
| 17 | #include "llvm/ADT/Twine.h" | |||
| 18 | #include "llvm/CodeGen/AsmPrinter.h" | |||
| 19 | #include "llvm/Config/llvm-config.h" | |||
| 20 | #include "llvm/IR/DataLayout.h" | |||
| 21 | #include "llvm/MC/MCAsmInfo.h" | |||
| 22 | #include "llvm/MC/MCContext.h" | |||
| 23 | #include "llvm/MC/MCStreamer.h" | |||
| 24 | #include "llvm/MC/MCSymbol.h" | |||
| 25 | #include "llvm/Support/Debug.h" | |||
| 26 | #include "llvm/Support/ErrorHandling.h" | |||
| 27 | #include "llvm/Support/Format.h" | |||
| 28 | #include "llvm/Support/FormattedStream.h" | |||
| 29 | #include "llvm/Support/LEB128.h" | |||
| 30 | #include "llvm/Support/MD5.h" | |||
| 31 | #include "llvm/Support/raw_ostream.h" | |||
| 32 | using namespace llvm; | |||
| 33 | ||||
| 34 | #define DEBUG_TYPE"dwarfdebug" "dwarfdebug" | |||
| 35 | ||||
| 36 | //===----------------------------------------------------------------------===// | |||
| 37 | // DIEAbbrevData Implementation | |||
| 38 | //===----------------------------------------------------------------------===// | |||
| 39 | ||||
| 40 | /// Profile - Used to gather unique data for the abbreviation folding set. | |||
| 41 | /// | |||
| 42 | void DIEAbbrevData::Profile(FoldingSetNodeID &ID) const { | |||
| 43 | // Explicitly cast to an integer type for which FoldingSetNodeID has | |||
| 44 | // overloads. Otherwise MSVC 2010 thinks this call is ambiguous. | |||
| 45 | ID.AddInteger(unsigned(Attribute)); | |||
| 46 | ID.AddInteger(unsigned(Form)); | |||
| 47 | if (Form == dwarf::DW_FORM_implicit_const) | |||
| 48 | ID.AddInteger(Value); | |||
| 49 | } | |||
| 50 | ||||
| 51 | //===----------------------------------------------------------------------===// | |||
| 52 | // DIEAbbrev Implementation | |||
| 53 | //===----------------------------------------------------------------------===// | |||
| 54 | ||||
| 55 | /// Profile - Used to gather unique data for the abbreviation folding set. | |||
| 56 | /// | |||
| 57 | void DIEAbbrev::Profile(FoldingSetNodeID &ID) const { | |||
| 58 | ID.AddInteger(unsigned(Tag)); | |||
| 59 | ID.AddInteger(unsigned(Children)); | |||
| 60 | ||||
| 61 | // For each attribute description. | |||
| 62 | for (unsigned i = 0, N = Data.size(); i < N; ++i) | |||
| 63 | Data[i].Profile(ID); | |||
| 64 | } | |||
| 65 | ||||
| 66 | /// Emit - Print the abbreviation using the specified asm printer. | |||
| 67 | /// | |||
| 68 | void DIEAbbrev::Emit(const AsmPrinter *AP) const { | |||
| 69 | // Emit its Dwarf tag type. | |||
| 70 | AP->emitULEB128(Tag, dwarf::TagString(Tag).data()); | |||
| 71 | ||||
| 72 | // Emit whether it has children DIEs. | |||
| 73 | AP->emitULEB128((unsigned)Children, dwarf::ChildrenString(Children).data()); | |||
| 74 | ||||
| 75 | // For each attribute description. | |||
| 76 | for (unsigned i = 0, N = Data.size(); i < N; ++i) { | |||
| 77 | const DIEAbbrevData &AttrData = Data[i]; | |||
| 78 | ||||
| 79 | // Emit attribute type. | |||
| 80 | AP->emitULEB128(AttrData.getAttribute(), | |||
| 81 | dwarf::AttributeString(AttrData.getAttribute()).data()); | |||
| 82 | ||||
| 83 | // Emit form type. | |||
| 84 | #ifndef NDEBUG1 | |||
| 85 | // Could be an assertion, but this way we can see the failing form code | |||
| 86 | // easily, which helps track down where it came from. | |||
| 87 | if (!dwarf::isValidFormForVersion(AttrData.getForm(), | |||
| 88 | AP->getDwarfVersion())) { | |||
| 89 | LLVM_DEBUG(dbgs() << "Invalid form " << format("0x%x", AttrData.getForm())do { } while (false) | |||
| 90 | << " for DWARF version " << AP->getDwarfVersion()do { } while (false) | |||
| 91 | << "\n")do { } while (false); | |||
| 92 | llvm_unreachable("Invalid form for specified DWARF version")__builtin_unreachable(); | |||
| 93 | } | |||
| 94 | #endif | |||
| 95 | AP->emitULEB128(AttrData.getForm(), | |||
| 96 | dwarf::FormEncodingString(AttrData.getForm()).data()); | |||
| 97 | ||||
| 98 | // Emit value for DW_FORM_implicit_const. | |||
| 99 | if (AttrData.getForm() == dwarf::DW_FORM_implicit_const) | |||
| 100 | AP->emitSLEB128(AttrData.getValue()); | |||
| 101 | } | |||
| 102 | ||||
| 103 | // Mark end of abbreviation. | |||
| 104 | AP->emitULEB128(0, "EOM(1)"); | |||
| 105 | AP->emitULEB128(0, "EOM(2)"); | |||
| 106 | } | |||
| 107 | ||||
| 108 | LLVM_DUMP_METHOD__attribute__((noinline)) | |||
| 109 | void DIEAbbrev::print(raw_ostream &O) const { | |||
| 110 | O << "Abbreviation @" | |||
| 111 | << format("0x%lx", (long)(intptr_t)this) | |||
| 112 | << " " | |||
| 113 | << dwarf::TagString(Tag) | |||
| 114 | << " " | |||
| 115 | << dwarf::ChildrenString(Children) | |||
| 116 | << '\n'; | |||
| 117 | ||||
| 118 | for (unsigned i = 0, N = Data.size(); i < N; ++i) { | |||
| 119 | O << " " | |||
| 120 | << dwarf::AttributeString(Data[i].getAttribute()) | |||
| 121 | << " " | |||
| 122 | << dwarf::FormEncodingString(Data[i].getForm()); | |||
| 123 | ||||
| 124 | if (Data[i].getForm() == dwarf::DW_FORM_implicit_const) | |||
| 125 | O << " " << Data[i].getValue(); | |||
| 126 | ||||
| 127 | O << '\n'; | |||
| 128 | } | |||
| 129 | } | |||
| 130 | ||||
| 131 | #if !defined(NDEBUG1) || defined(LLVM_ENABLE_DUMP) | |||
| 132 | LLVM_DUMP_METHOD__attribute__((noinline)) void DIEAbbrev::dump() const { | |||
| 133 | print(dbgs()); | |||
| 134 | } | |||
| 135 | #endif | |||
| 136 | ||||
| 137 | //===----------------------------------------------------------------------===// | |||
| 138 | // DIEAbbrevSet Implementation | |||
| 139 | //===----------------------------------------------------------------------===// | |||
| 140 | ||||
| 141 | DIEAbbrevSet::~DIEAbbrevSet() { | |||
| 142 | for (DIEAbbrev *Abbrev : Abbreviations) | |||
| 143 | Abbrev->~DIEAbbrev(); | |||
| 144 | } | |||
| 145 | ||||
| 146 | DIEAbbrev &DIEAbbrevSet::uniqueAbbreviation(DIE &Die) { | |||
| 147 | ||||
| 148 | FoldingSetNodeID ID; | |||
| 149 | DIEAbbrev Abbrev = Die.generateAbbrev(); | |||
| 150 | Abbrev.Profile(ID); | |||
| 151 | ||||
| 152 | void *InsertPos; | |||
| 153 | if (DIEAbbrev *Existing = | |||
| 154 | AbbreviationsSet.FindNodeOrInsertPos(ID, InsertPos)) { | |||
| 155 | Die.setAbbrevNumber(Existing->getNumber()); | |||
| 156 | return *Existing; | |||
| 157 | } | |||
| 158 | ||||
| 159 | // Move the abbreviation to the heap and assign a number. | |||
| 160 | DIEAbbrev *New = new (Alloc) DIEAbbrev(std::move(Abbrev)); | |||
| 161 | Abbreviations.push_back(New); | |||
| 162 | New->setNumber(Abbreviations.size()); | |||
| 163 | Die.setAbbrevNumber(Abbreviations.size()); | |||
| 164 | ||||
| 165 | // Store it for lookup. | |||
| 166 | AbbreviationsSet.InsertNode(New, InsertPos); | |||
| 167 | return *New; | |||
| 168 | } | |||
| 169 | ||||
| 170 | void DIEAbbrevSet::Emit(const AsmPrinter *AP, MCSection *Section) const { | |||
| 171 | if (!Abbreviations.empty()) { | |||
| 172 | // Start the debug abbrev section. | |||
| 173 | AP->OutStreamer->SwitchSection(Section); | |||
| 174 | AP->emitDwarfAbbrevs(Abbreviations); | |||
| 175 | } | |||
| 176 | } | |||
| 177 | ||||
| 178 | //===----------------------------------------------------------------------===// | |||
| 179 | // DIE Implementation | |||
| 180 | //===----------------------------------------------------------------------===// | |||
| 181 | ||||
| 182 | DIE *DIE::getParent() const { | |||
| 183 | return Owner.dyn_cast<DIE*>(); | |||
| 184 | } | |||
| 185 | ||||
| 186 | DIEAbbrev DIE::generateAbbrev() const { | |||
| 187 | DIEAbbrev Abbrev(Tag, hasChildren()); | |||
| 188 | for (const DIEValue &V : values()) | |||
| 189 | if (V.getForm() == dwarf::DW_FORM_implicit_const) | |||
| 190 | Abbrev.AddImplicitConstAttribute(V.getAttribute(), | |||
| 191 | V.getDIEInteger().getValue()); | |||
| 192 | else | |||
| 193 | Abbrev.AddAttribute(V.getAttribute(), V.getForm()); | |||
| 194 | return Abbrev; | |||
| 195 | } | |||
| 196 | ||||
| 197 | uint64_t DIE::getDebugSectionOffset() const { | |||
| 198 | const DIEUnit *Unit = getUnit(); | |||
| 199 | assert(Unit && "DIE must be owned by a DIEUnit to get its absolute offset")((void)0); | |||
| 200 | return Unit->getDebugSectionOffset() + getOffset(); | |||
| 201 | } | |||
| 202 | ||||
| 203 | const DIE *DIE::getUnitDie() const { | |||
| 204 | const DIE *p = this; | |||
| 205 | while (p) { | |||
| 206 | if (p->getTag() == dwarf::DW_TAG_compile_unit || | |||
| 207 | p->getTag() == dwarf::DW_TAG_type_unit) | |||
| 208 | return p; | |||
| 209 | p = p->getParent(); | |||
| 210 | } | |||
| 211 | return nullptr; | |||
| 212 | } | |||
| 213 | ||||
| 214 | DIEUnit *DIE::getUnit() const { | |||
| 215 | const DIE *UnitDie = getUnitDie(); | |||
| 216 | if (UnitDie) | |||
| 217 | return UnitDie->Owner.dyn_cast<DIEUnit*>(); | |||
| 218 | return nullptr; | |||
| 219 | } | |||
| 220 | ||||
| 221 | DIEValue DIE::findAttribute(dwarf::Attribute Attribute) const { | |||
| 222 | // Iterate through all the attributes until we find the one we're | |||
| 223 | // looking for, if we can't find it return NULL. | |||
| 224 | for (const auto &V : values()) | |||
| 225 | if (V.getAttribute() == Attribute) | |||
| 226 | return V; | |||
| 227 | return DIEValue(); | |||
| 228 | } | |||
| 229 | ||||
| 230 | LLVM_DUMP_METHOD__attribute__((noinline)) | |||
| 231 | static void printValues(raw_ostream &O, const DIEValueList &Values, | |||
| 232 | StringRef Type, unsigned Size, unsigned IndentCount) { | |||
| 233 | O << Type << ": Size: " << Size << "\n"; | |||
| 234 | ||||
| 235 | unsigned I = 0; | |||
| 236 | const std::string Indent(IndentCount, ' '); | |||
| 237 | for (const auto &V : Values.values()) { | |||
| 238 | O << Indent; | |||
| 239 | O << "Blk[" << I++ << "]"; | |||
| 240 | O << " " << dwarf::FormEncodingString(V.getForm()) << " "; | |||
| 241 | V.print(O); | |||
| 242 | O << "\n"; | |||
| 243 | } | |||
| 244 | } | |||
| 245 | ||||
| 246 | LLVM_DUMP_METHOD__attribute__((noinline)) | |||
| 247 | void DIE::print(raw_ostream &O, unsigned IndentCount) const { | |||
| 248 | const std::string Indent(IndentCount, ' '); | |||
| 249 | O << Indent << "Die: " << format("0x%lx", (long)(intptr_t) this) | |||
| 250 | << ", Offset: " << Offset << ", Size: " << Size << "\n"; | |||
| 251 | ||||
| 252 | O << Indent << dwarf::TagString(getTag()) << " " | |||
| 253 | << dwarf::ChildrenString(hasChildren()) << "\n"; | |||
| 254 | ||||
| 255 | IndentCount += 2; | |||
| 256 | for (const auto &V : values()) { | |||
| 257 | O << Indent; | |||
| 258 | O << dwarf::AttributeString(V.getAttribute()); | |||
| 259 | O << " " << dwarf::FormEncodingString(V.getForm()) << " "; | |||
| 260 | V.print(O); | |||
| 261 | O << "\n"; | |||
| 262 | } | |||
| 263 | IndentCount -= 2; | |||
| 264 | ||||
| 265 | for (const auto &Child : children()) | |||
| 266 | Child.print(O, IndentCount + 4); | |||
| 267 | ||||
| 268 | O << "\n"; | |||
| 269 | } | |||
| 270 | ||||
| 271 | #if !defined(NDEBUG1) || defined(LLVM_ENABLE_DUMP) | |||
| 272 | LLVM_DUMP_METHOD__attribute__((noinline)) void DIE::dump() const { | |||
| 273 | print(dbgs()); | |||
| 274 | } | |||
| 275 | #endif | |||
| 276 | ||||
| 277 | unsigned DIE::computeOffsetsAndAbbrevs(const AsmPrinter *AP, | |||
| 278 | DIEAbbrevSet &AbbrevSet, | |||
| 279 | unsigned CUOffset) { | |||
| 280 | // Unique the abbreviation and fill in the abbreviation number so this DIE | |||
| 281 | // can be emitted. | |||
| 282 | const DIEAbbrev &Abbrev = AbbrevSet.uniqueAbbreviation(*this); | |||
| ||||
| 283 | ||||
| 284 | // Set compile/type unit relative offset of this DIE. | |||
| 285 | setOffset(CUOffset); | |||
| 286 | ||||
| 287 | // Add the byte size of the abbreviation code. | |||
| 288 | CUOffset += getULEB128Size(getAbbrevNumber()); | |||
| 289 | ||||
| 290 | // Add the byte size of all the DIE attribute values. | |||
| 291 | for (const auto &V : values()) | |||
| 292 | CUOffset += V.SizeOf(AP); | |||
| 293 | ||||
| 294 | // Let the children compute their offsets and abbreviation numbers. | |||
| 295 | if (hasChildren()) { | |||
| 296 | (void)Abbrev; | |||
| 297 | assert(Abbrev.hasChildren() && "Children flag not set")((void)0); | |||
| 298 | ||||
| 299 | for (auto &Child : children()) | |||
| 300 | CUOffset = Child.computeOffsetsAndAbbrevs(AP, AbbrevSet, CUOffset); | |||
| 301 | ||||
| 302 | // Each child chain is terminated with a zero byte, adjust the offset. | |||
| 303 | CUOffset += sizeof(int8_t); | |||
| 304 | } | |||
| 305 | ||||
| 306 | // Compute the byte size of this DIE and all of its children correctly. This | |||
| 307 | // is needed so that top level DIE can help the compile unit set its length | |||
| 308 | // correctly. | |||
| 309 | setSize(CUOffset - getOffset()); | |||
| 310 | return CUOffset; | |||
| 311 | } | |||
| 312 | ||||
| 313 | //===----------------------------------------------------------------------===// | |||
| 314 | // DIEUnit Implementation | |||
| 315 | //===----------------------------------------------------------------------===// | |||
| 316 | DIEUnit::DIEUnit(dwarf::Tag UnitTag) | |||
| 317 | : Die(UnitTag), Section(nullptr), Offset(0) { | |||
| 318 | Die.Owner = this; | |||
| 319 | assert((UnitTag == dwarf::DW_TAG_compile_unit ||((void)0) | |||
| 320 | UnitTag == dwarf::DW_TAG_skeleton_unit ||((void)0) | |||
| 321 | UnitTag == dwarf::DW_TAG_type_unit ||((void)0) | |||
| 322 | UnitTag == dwarf::DW_TAG_partial_unit) &&((void)0) | |||
| 323 | "expected a unit TAG")((void)0); | |||
| 324 | } | |||
| 325 | ||||
| 326 | void DIEValue::emitValue(const AsmPrinter *AP) const { | |||
| 327 | switch (Ty) { | |||
| 328 | case isNone: | |||
| 329 | llvm_unreachable("Expected valid DIEValue")__builtin_unreachable(); | |||
| 330 | #define HANDLE_DIEVALUE(T) \ | |||
| 331 | case is##T: \ | |||
| 332 | getDIE##T().emitValue(AP, Form); \ | |||
| 333 | break; | |||
| 334 | #include "llvm/CodeGen/DIEValue.def" | |||
| 335 | } | |||
| 336 | } | |||
| 337 | ||||
| 338 | unsigned DIEValue::SizeOf(const AsmPrinter *AP) const { | |||
| 339 | switch (Ty) { | |||
| 340 | case isNone: | |||
| 341 | llvm_unreachable("Expected valid DIEValue")__builtin_unreachable(); | |||
| 342 | #define HANDLE_DIEVALUE(T) \ | |||
| 343 | case is##T: \ | |||
| 344 | return getDIE##T().SizeOf(AP, Form); | |||
| 345 | #include "llvm/CodeGen/DIEValue.def" | |||
| 346 | } | |||
| 347 | llvm_unreachable("Unknown DIE kind")__builtin_unreachable(); | |||
| 348 | } | |||
| 349 | ||||
| 350 | LLVM_DUMP_METHOD__attribute__((noinline)) | |||
| 351 | void DIEValue::print(raw_ostream &O) const { | |||
| 352 | switch (Ty) { | |||
| 353 | case isNone: | |||
| 354 | llvm_unreachable("Expected valid DIEValue")__builtin_unreachable(); | |||
| 355 | #define HANDLE_DIEVALUE(T) \ | |||
| 356 | case is##T: \ | |||
| 357 | getDIE##T().print(O); \ | |||
| 358 | break; | |||
| 359 | #include "llvm/CodeGen/DIEValue.def" | |||
| 360 | } | |||
| 361 | } | |||
| 362 | ||||
| 363 | #if !defined(NDEBUG1) || defined(LLVM_ENABLE_DUMP) | |||
| 364 | LLVM_DUMP_METHOD__attribute__((noinline)) void DIEValue::dump() const { | |||
| 365 | print(dbgs()); | |||
| 366 | } | |||
| 367 | #endif | |||
| 368 | ||||
| 369 | //===----------------------------------------------------------------------===// | |||
| 370 | // DIEInteger Implementation | |||
| 371 | //===----------------------------------------------------------------------===// | |||
| 372 | ||||
| 373 | /// EmitValue - Emit integer of appropriate size. | |||
| 374 | /// | |||
| 375 | void DIEInteger::emitValue(const AsmPrinter *Asm, dwarf::Form Form) const { | |||
| 376 | switch (Form) { | |||
| 377 | case dwarf::DW_FORM_implicit_const: | |||
| 378 | case dwarf::DW_FORM_flag_present: | |||
| 379 | // Emit something to keep the lines and comments in sync. | |||
| 380 | // FIXME: Is there a better way to do this? | |||
| 381 | Asm->OutStreamer->AddBlankLine(); | |||
| 382 | return; | |||
| 383 | case dwarf::DW_FORM_flag: | |||
| 384 | case dwarf::DW_FORM_ref1: | |||
| 385 | case dwarf::DW_FORM_data1: | |||
| 386 | case dwarf::DW_FORM_strx1: | |||
| 387 | case dwarf::DW_FORM_addrx1: | |||
| 388 | case dwarf::DW_FORM_ref2: | |||
| 389 | case dwarf::DW_FORM_data2: | |||
| 390 | case dwarf::DW_FORM_strx2: | |||
| 391 | case dwarf::DW_FORM_addrx2: | |||
| 392 | case dwarf::DW_FORM_strx3: | |||
| 393 | case dwarf::DW_FORM_strp: | |||
| 394 | case dwarf::DW_FORM_ref4: | |||
| 395 | case dwarf::DW_FORM_data4: | |||
| 396 | case dwarf::DW_FORM_ref_sup4: | |||
| 397 | case dwarf::DW_FORM_strx4: | |||
| 398 | case dwarf::DW_FORM_addrx4: | |||
| 399 | case dwarf::DW_FORM_ref8: | |||
| 400 | case dwarf::DW_FORM_ref_sig8: | |||
| 401 | case dwarf::DW_FORM_data8: | |||
| 402 | case dwarf::DW_FORM_ref_sup8: | |||
| 403 | case dwarf::DW_FORM_GNU_ref_alt: | |||
| 404 | case dwarf::DW_FORM_GNU_strp_alt: | |||
| 405 | case dwarf::DW_FORM_line_strp: | |||
| 406 | case dwarf::DW_FORM_sec_offset: | |||
| 407 | case dwarf::DW_FORM_strp_sup: | |||
| 408 | case dwarf::DW_FORM_addr: | |||
| 409 | case dwarf::DW_FORM_ref_addr: | |||
| 410 | Asm->OutStreamer->emitIntValue(Integer, SizeOf(Asm, Form)); | |||
| 411 | return; | |||
| 412 | case dwarf::DW_FORM_GNU_str_index: | |||
| 413 | case dwarf::DW_FORM_GNU_addr_index: | |||
| 414 | case dwarf::DW_FORM_ref_udata: | |||
| 415 | case dwarf::DW_FORM_strx: | |||
| 416 | case dwarf::DW_FORM_addrx: | |||
| 417 | case dwarf::DW_FORM_rnglistx: | |||
| 418 | case dwarf::DW_FORM_udata: | |||
| 419 | Asm->emitULEB128(Integer); | |||
| 420 | return; | |||
| 421 | case dwarf::DW_FORM_sdata: | |||
| 422 | Asm->emitSLEB128(Integer); | |||
| 423 | return; | |||
| 424 | default: llvm_unreachable("DIE Value form not supported yet")__builtin_unreachable(); | |||
| 425 | } | |||
| 426 | } | |||
| 427 | ||||
| 428 | /// SizeOf - Determine size of integer value in bytes. | |||
| 429 | /// | |||
| 430 | unsigned DIEInteger::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { | |||
| 431 | assert(AP && "AsmPrinter is required to set FormParams")((void)0); | |||
| 432 | dwarf::FormParams Params = {AP->getDwarfVersion(), | |||
| 433 | uint8_t(AP->getPointerSize()), | |||
| 434 | AP->OutStreamer->getContext().getDwarfFormat()}; | |||
| 435 | ||||
| 436 | if (Optional<uint8_t> FixedSize = dwarf::getFixedFormByteSize(Form, Params)) | |||
| 437 | return *FixedSize; | |||
| 438 | ||||
| 439 | switch (Form) { | |||
| 440 | case dwarf::DW_FORM_GNU_str_index: | |||
| 441 | case dwarf::DW_FORM_GNU_addr_index: | |||
| 442 | case dwarf::DW_FORM_ref_udata: | |||
| 443 | case dwarf::DW_FORM_strx: | |||
| 444 | case dwarf::DW_FORM_addrx: | |||
| 445 | case dwarf::DW_FORM_rnglistx: | |||
| 446 | case dwarf::DW_FORM_udata: | |||
| 447 | return getULEB128Size(Integer); | |||
| 448 | case dwarf::DW_FORM_sdata: | |||
| 449 | return getSLEB128Size(Integer); | |||
| 450 | default: llvm_unreachable("DIE Value form not supported yet")__builtin_unreachable(); | |||
| 451 | } | |||
| 452 | } | |||
| 453 | ||||
| 454 | LLVM_DUMP_METHOD__attribute__((noinline)) | |||
| 455 | void DIEInteger::print(raw_ostream &O) const { | |||
| 456 | O << "Int: " << (int64_t)Integer << " 0x"; | |||
| 457 | O.write_hex(Integer); | |||
| 458 | } | |||
| 459 | ||||
| 460 | //===----------------------------------------------------------------------===// | |||
| 461 | // DIEExpr Implementation | |||
| 462 | //===----------------------------------------------------------------------===// | |||
| 463 | ||||
| 464 | /// EmitValue - Emit expression value. | |||
| 465 | /// | |||
| 466 | void DIEExpr::emitValue(const AsmPrinter *AP, dwarf::Form Form) const { | |||
| 467 | AP->emitDebugValue(Expr, SizeOf(AP, Form)); | |||
| 468 | } | |||
| 469 | ||||
| 470 | /// SizeOf - Determine size of expression value in bytes. | |||
| 471 | /// | |||
| 472 | unsigned DIEExpr::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { | |||
| 473 | switch (Form) { | |||
| 474 | case dwarf::DW_FORM_data4: | |||
| 475 | return 4; | |||
| 476 | case dwarf::DW_FORM_data8: | |||
| 477 | return 8; | |||
| 478 | case dwarf::DW_FORM_sec_offset: | |||
| 479 | return AP->getDwarfOffsetByteSize(); | |||
| 480 | default: | |||
| 481 | llvm_unreachable("DIE Value form not supported yet")__builtin_unreachable(); | |||
| 482 | } | |||
| 483 | } | |||
| 484 | ||||
| 485 | LLVM_DUMP_METHOD__attribute__((noinline)) | |||
| 486 | void DIEExpr::print(raw_ostream &O) const { O << "Expr: " << *Expr; } | |||
| 487 | ||||
| 488 | //===----------------------------------------------------------------------===// | |||
| 489 | // DIELabel Implementation | |||
| 490 | //===----------------------------------------------------------------------===// | |||
| 491 | ||||
| 492 | /// EmitValue - Emit label value. | |||
| 493 | /// | |||
| 494 | void DIELabel::emitValue(const AsmPrinter *AP, dwarf::Form Form) const { | |||
| 495 | bool IsSectionRelative = Form != dwarf::DW_FORM_addr; | |||
| 496 | AP->emitLabelReference(Label, SizeOf(AP, Form), IsSectionRelative); | |||
| 497 | } | |||
| 498 | ||||
| 499 | /// SizeOf - Determine size of label value in bytes. | |||
| 500 | /// | |||
| 501 | unsigned DIELabel::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { | |||
| 502 | switch (Form) { | |||
| 503 | case dwarf::DW_FORM_data4: | |||
| 504 | return 4; | |||
| 505 | case dwarf::DW_FORM_data8: | |||
| 506 | return 8; | |||
| 507 | case dwarf::DW_FORM_sec_offset: | |||
| 508 | case dwarf::DW_FORM_strp: | |||
| 509 | return AP->getDwarfOffsetByteSize(); | |||
| 510 | case dwarf::DW_FORM_addr: | |||
| 511 | return AP->MAI->getCodePointerSize(); | |||
| 512 | default: | |||
| 513 | llvm_unreachable("DIE Value form not supported yet")__builtin_unreachable(); | |||
| 514 | } | |||
| 515 | } | |||
| 516 | ||||
| 517 | LLVM_DUMP_METHOD__attribute__((noinline)) | |||
| 518 | void DIELabel::print(raw_ostream &O) const { O << "Lbl: " << Label->getName(); } | |||
| 519 | ||||
| 520 | //===----------------------------------------------------------------------===// | |||
| 521 | // DIEBaseTypeRef Implementation | |||
| 522 | //===----------------------------------------------------------------------===// | |||
| 523 | ||||
| 524 | void DIEBaseTypeRef::emitValue(const AsmPrinter *AP, dwarf::Form Form) const { | |||
| 525 | uint64_t Offset = CU->ExprRefedBaseTypes[Index].Die->getOffset(); | |||
| 526 | assert(Offset < (1ULL << (ULEB128PadSize * 7)) && "Offset wont fit")((void)0); | |||
| 527 | AP->emitULEB128(Offset, nullptr, ULEB128PadSize); | |||
| 528 | } | |||
| 529 | ||||
| 530 | unsigned DIEBaseTypeRef::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { | |||
| 531 | return ULEB128PadSize; | |||
| 532 | } | |||
| 533 | ||||
| 534 | LLVM_DUMP_METHOD__attribute__((noinline)) | |||
| 535 | void DIEBaseTypeRef::print(raw_ostream &O) const { O << "BaseTypeRef: " << Index; } | |||
| 536 | ||||
| 537 | //===----------------------------------------------------------------------===// | |||
| 538 | // DIEDelta Implementation | |||
| 539 | //===----------------------------------------------------------------------===// | |||
| 540 | ||||
| 541 | /// EmitValue - Emit delta value. | |||
| 542 | /// | |||
| 543 | void DIEDelta::emitValue(const AsmPrinter *AP, dwarf::Form Form) const { | |||
| 544 | AP->emitLabelDifference(LabelHi, LabelLo, SizeOf(AP, Form)); | |||
| 545 | } | |||
| 546 | ||||
| 547 | /// SizeOf - Determine size of delta value in bytes. | |||
| 548 | /// | |||
| 549 | unsigned DIEDelta::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { | |||
| 550 | switch (Form) { | |||
| 551 | case dwarf::DW_FORM_data4: | |||
| 552 | return 4; | |||
| 553 | case dwarf::DW_FORM_data8: | |||
| 554 | return 8; | |||
| 555 | case dwarf::DW_FORM_sec_offset: | |||
| 556 | return AP->getDwarfOffsetByteSize(); | |||
| 557 | default: | |||
| 558 | llvm_unreachable("DIE Value form not supported yet")__builtin_unreachable(); | |||
| 559 | } | |||
| 560 | } | |||
| 561 | ||||
| 562 | LLVM_DUMP_METHOD__attribute__((noinline)) | |||
| 563 | void DIEDelta::print(raw_ostream &O) const { | |||
| 564 | O << "Del: " << LabelHi->getName() << "-" << LabelLo->getName(); | |||
| 565 | } | |||
| 566 | ||||
| 567 | //===----------------------------------------------------------------------===// | |||
| 568 | // DIEString Implementation | |||
| 569 | //===----------------------------------------------------------------------===// | |||
| 570 | ||||
| 571 | /// EmitValue - Emit string value. | |||
| 572 | /// | |||
| 573 | void DIEString::emitValue(const AsmPrinter *AP, dwarf::Form Form) const { | |||
| 574 | // Index of string in symbol table. | |||
| 575 | switch (Form) { | |||
| 576 | case dwarf::DW_FORM_GNU_str_index: | |||
| 577 | case dwarf::DW_FORM_strx: | |||
| 578 | case dwarf::DW_FORM_strx1: | |||
| 579 | case dwarf::DW_FORM_strx2: | |||
| 580 | case dwarf::DW_FORM_strx3: | |||
| 581 | case dwarf::DW_FORM_strx4: | |||
| 582 | DIEInteger(S.getIndex()).emitValue(AP, Form); | |||
| 583 | return; | |||
| 584 | case dwarf::DW_FORM_strp: | |||
| 585 | if (AP->MAI->doesDwarfUseRelocationsAcrossSections()) | |||
| 586 | DIELabel(S.getSymbol()).emitValue(AP, Form); | |||
| 587 | else | |||
| 588 | DIEInteger(S.getOffset()).emitValue(AP, Form); | |||
| 589 | return; | |||
| 590 | default: | |||
| 591 | llvm_unreachable("Expected valid string form")__builtin_unreachable(); | |||
| 592 | } | |||
| 593 | } | |||
| 594 | ||||
| 595 | /// SizeOf - Determine size of delta value in bytes. | |||
| 596 | /// | |||
| 597 | unsigned DIEString::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { | |||
| 598 | // Index of string in symbol table. | |||
| 599 | switch (Form) { | |||
| 600 | case dwarf::DW_FORM_GNU_str_index: | |||
| 601 | case dwarf::DW_FORM_strx: | |||
| 602 | case dwarf::DW_FORM_strx1: | |||
| 603 | case dwarf::DW_FORM_strx2: | |||
| 604 | case dwarf::DW_FORM_strx3: | |||
| 605 | case dwarf::DW_FORM_strx4: | |||
| 606 | return DIEInteger(S.getIndex()).SizeOf(AP, Form); | |||
| 607 | case dwarf::DW_FORM_strp: | |||
| 608 | if (AP->MAI->doesDwarfUseRelocationsAcrossSections()) | |||
| 609 | return DIELabel(S.getSymbol()).SizeOf(AP, Form); | |||
| 610 | return DIEInteger(S.getOffset()).SizeOf(AP, Form); | |||
| 611 | default: | |||
| 612 | llvm_unreachable("Expected valid string form")__builtin_unreachable(); | |||
| 613 | } | |||
| 614 | } | |||
| 615 | ||||
| 616 | LLVM_DUMP_METHOD__attribute__((noinline)) | |||
| 617 | void DIEString::print(raw_ostream &O) const { | |||
| 618 | O << "String: " << S.getString(); | |||
| 619 | } | |||
| 620 | ||||
| 621 | //===----------------------------------------------------------------------===// | |||
| 622 | // DIEInlineString Implementation | |||
| 623 | //===----------------------------------------------------------------------===// | |||
| 624 | void DIEInlineString::emitValue(const AsmPrinter *AP, dwarf::Form Form) const { | |||
| 625 | if (Form == dwarf::DW_FORM_string) { | |||
| 626 | AP->OutStreamer->emitBytes(S); | |||
| 627 | AP->emitInt8(0); | |||
| 628 | return; | |||
| 629 | } | |||
| 630 | llvm_unreachable("Expected valid string form")__builtin_unreachable(); | |||
| 631 | } | |||
| 632 | ||||
| 633 | unsigned DIEInlineString::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { | |||
| 634 | // Emit string bytes + NULL byte. | |||
| 635 | return S.size() + 1; | |||
| 636 | } | |||
| 637 | ||||
| 638 | LLVM_DUMP_METHOD__attribute__((noinline)) | |||
| 639 | void DIEInlineString::print(raw_ostream &O) const { | |||
| 640 | O << "InlineString: " << S; | |||
| 641 | } | |||
| 642 | ||||
| 643 | //===----------------------------------------------------------------------===// | |||
| 644 | // DIEEntry Implementation | |||
| 645 | //===----------------------------------------------------------------------===// | |||
| 646 | ||||
| 647 | /// EmitValue - Emit debug information entry offset. | |||
| 648 | /// | |||
| 649 | void DIEEntry::emitValue(const AsmPrinter *AP, dwarf::Form Form) const { | |||
| 650 | ||||
| 651 | switch (Form) { | |||
| 652 | case dwarf::DW_FORM_ref1: | |||
| 653 | case dwarf::DW_FORM_ref2: | |||
| 654 | case dwarf::DW_FORM_ref4: | |||
| 655 | case dwarf::DW_FORM_ref8: | |||
| 656 | AP->OutStreamer->emitIntValue(Entry->getOffset(), SizeOf(AP, Form)); | |||
| 657 | return; | |||
| 658 | ||||
| 659 | case dwarf::DW_FORM_ref_udata: | |||
| 660 | AP->emitULEB128(Entry->getOffset()); | |||
| 661 | return; | |||
| 662 | ||||
| 663 | case dwarf::DW_FORM_ref_addr: { | |||
| 664 | // Get the absolute offset for this DIE within the debug info/types section. | |||
| 665 | uint64_t Addr = Entry->getDebugSectionOffset(); | |||
| 666 | if (const MCSymbol *SectionSym = | |||
| 667 | Entry->getUnit()->getCrossSectionRelativeBaseAddress()) { | |||
| 668 | AP->emitLabelPlusOffset(SectionSym, Addr, SizeOf(AP, Form), true); | |||
| 669 | return; | |||
| 670 | } | |||
| 671 | ||||
| 672 | AP->OutStreamer->emitIntValue(Addr, SizeOf(AP, Form)); | |||
| 673 | return; | |||
| 674 | } | |||
| 675 | default: | |||
| 676 | llvm_unreachable("Improper form for DIE reference")__builtin_unreachable(); | |||
| 677 | } | |||
| 678 | } | |||
| 679 | ||||
| 680 | unsigned DIEEntry::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { | |||
| 681 | switch (Form) { | |||
| 682 | case dwarf::DW_FORM_ref1: | |||
| 683 | return 1; | |||
| 684 | case dwarf::DW_FORM_ref2: | |||
| 685 | return 2; | |||
| 686 | case dwarf::DW_FORM_ref4: | |||
| 687 | return 4; | |||
| 688 | case dwarf::DW_FORM_ref8: | |||
| 689 | return 8; | |||
| 690 | case dwarf::DW_FORM_ref_udata: | |||
| 691 | return getULEB128Size(Entry->getOffset()); | |||
| 692 | case dwarf::DW_FORM_ref_addr: | |||
| 693 | if (AP->getDwarfVersion() == 2) | |||
| 694 | return AP->MAI->getCodePointerSize(); | |||
| 695 | switch (AP->OutStreamer->getContext().getDwarfFormat()) { | |||
| 696 | case dwarf::DWARF32: | |||
| 697 | return 4; | |||
| 698 | case dwarf::DWARF64: | |||
| 699 | return 8; | |||
| 700 | } | |||
| 701 | llvm_unreachable("Invalid DWARF format")__builtin_unreachable(); | |||
| 702 | ||||
| 703 | default: | |||
| 704 | llvm_unreachable("Improper form for DIE reference")__builtin_unreachable(); | |||
| 705 | } | |||
| 706 | } | |||
| 707 | ||||
| 708 | LLVM_DUMP_METHOD__attribute__((noinline)) | |||
| 709 | void DIEEntry::print(raw_ostream &O) const { | |||
| 710 | O << format("Die: 0x%lx", (long)(intptr_t)&Entry); | |||
| 711 | } | |||
| 712 | ||||
| 713 | //===----------------------------------------------------------------------===// | |||
| 714 | // DIELoc Implementation | |||
| 715 | //===----------------------------------------------------------------------===// | |||
| 716 | ||||
| 717 | /// ComputeSize - calculate the size of the location expression. | |||
| 718 | /// | |||
| 719 | unsigned DIELoc::ComputeSize(const AsmPrinter *AP) const { | |||
| 720 | if (!Size) { | |||
| 721 | for (const auto &V : values()) | |||
| 722 | Size += V.SizeOf(AP); | |||
| 723 | } | |||
| 724 | ||||
| 725 | return Size; | |||
| 726 | } | |||
| 727 | ||||
| 728 | /// EmitValue - Emit location data. | |||
| 729 | /// | |||
| 730 | void DIELoc::emitValue(const AsmPrinter *Asm, dwarf::Form Form) const { | |||
| 731 | switch (Form) { | |||
| 732 | default: llvm_unreachable("Improper form for block")__builtin_unreachable(); | |||
| 733 | case dwarf::DW_FORM_block1: Asm->emitInt8(Size); break; | |||
| 734 | case dwarf::DW_FORM_block2: Asm->emitInt16(Size); break; | |||
| 735 | case dwarf::DW_FORM_block4: Asm->emitInt32(Size); break; | |||
| 736 | case dwarf::DW_FORM_block: | |||
| 737 | case dwarf::DW_FORM_exprloc: | |||
| 738 | Asm->emitULEB128(Size); | |||
| 739 | break; | |||
| 740 | } | |||
| 741 | ||||
| 742 | for (const auto &V : values()) | |||
| 743 | V.emitValue(Asm); | |||
| 744 | } | |||
| 745 | ||||
| 746 | /// SizeOf - Determine size of location data in bytes. | |||
| 747 | /// | |||
| 748 | unsigned DIELoc::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { | |||
| 749 | switch (Form) { | |||
| 750 | case dwarf::DW_FORM_block1: return Size + sizeof(int8_t); | |||
| 751 | case dwarf::DW_FORM_block2: return Size + sizeof(int16_t); | |||
| 752 | case dwarf::DW_FORM_block4: return Size + sizeof(int32_t); | |||
| 753 | case dwarf::DW_FORM_block: | |||
| 754 | case dwarf::DW_FORM_exprloc: | |||
| 755 | return Size + getULEB128Size(Size); | |||
| 756 | default: llvm_unreachable("Improper form for block")__builtin_unreachable(); | |||
| 757 | } | |||
| 758 | } | |||
| 759 | ||||
| 760 | LLVM_DUMP_METHOD__attribute__((noinline)) | |||
| 761 | void DIELoc::print(raw_ostream &O) const { | |||
| 762 | printValues(O, *this, "ExprLoc", Size, 5); | |||
| 763 | } | |||
| 764 | ||||
| 765 | //===----------------------------------------------------------------------===// | |||
| 766 | // DIEBlock Implementation | |||
| 767 | //===----------------------------------------------------------------------===// | |||
| 768 | ||||
| 769 | /// ComputeSize - calculate the size of the block. | |||
| 770 | /// | |||
| 771 | unsigned DIEBlock::ComputeSize(const AsmPrinter *AP) const { | |||
| 772 | if (!Size) { | |||
| 773 | for (const auto &V : values()) | |||
| 774 | Size += V.SizeOf(AP); | |||
| 775 | } | |||
| 776 | ||||
| 777 | return Size; | |||
| 778 | } | |||
| 779 | ||||
| 780 | /// EmitValue - Emit block data. | |||
| 781 | /// | |||
| 782 | void DIEBlock::emitValue(const AsmPrinter *Asm, dwarf::Form Form) const { | |||
| 783 | switch (Form) { | |||
| 784 | default: llvm_unreachable("Improper form for block")__builtin_unreachable(); | |||
| 785 | case dwarf::DW_FORM_block1: Asm->emitInt8(Size); break; | |||
| 786 | case dwarf::DW_FORM_block2: Asm->emitInt16(Size); break; | |||
| 787 | case dwarf::DW_FORM_block4: Asm->emitInt32(Size); break; | |||
| 788 | case dwarf::DW_FORM_exprloc: | |||
| 789 | case dwarf::DW_FORM_block: | |||
| 790 | Asm->emitULEB128(Size); | |||
| 791 | break; | |||
| 792 | case dwarf::DW_FORM_string: break; | |||
| 793 | case dwarf::DW_FORM_data16: break; | |||
| 794 | } | |||
| 795 | ||||
| 796 | for (const auto &V : values()) | |||
| 797 | V.emitValue(Asm); | |||
| 798 | } | |||
| 799 | ||||
| 800 | /// SizeOf - Determine size of block data in bytes. | |||
| 801 | /// | |||
| 802 | unsigned DIEBlock::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { | |||
| 803 | switch (Form) { | |||
| 804 | case dwarf::DW_FORM_block1: return Size + sizeof(int8_t); | |||
| 805 | case dwarf::DW_FORM_block2: return Size + sizeof(int16_t); | |||
| 806 | case dwarf::DW_FORM_block4: return Size + sizeof(int32_t); | |||
| 807 | case dwarf::DW_FORM_exprloc: | |||
| 808 | case dwarf::DW_FORM_block: return Size + getULEB128Size(Size); | |||
| 809 | case dwarf::DW_FORM_data16: return 16; | |||
| 810 | default: llvm_unreachable("Improper form for block")__builtin_unreachable(); | |||
| 811 | } | |||
| 812 | } | |||
| 813 | ||||
| 814 | LLVM_DUMP_METHOD__attribute__((noinline)) | |||
| 815 | void DIEBlock::print(raw_ostream &O) const { | |||
| 816 | printValues(O, *this, "Blk", Size, 5); | |||
| 817 | } | |||
| 818 | ||||
| 819 | //===----------------------------------------------------------------------===// | |||
| 820 | // DIELocList Implementation | |||
| 821 | //===----------------------------------------------------------------------===// | |||
| 822 | ||||
| 823 | unsigned DIELocList::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { | |||
| 824 | switch (Form) { | |||
| 825 | case dwarf::DW_FORM_loclistx: | |||
| 826 | return getULEB128Size(Index); | |||
| 827 | case dwarf::DW_FORM_data4: | |||
| 828 | assert(!AP->isDwarf64() &&((void)0) | |||
| 829 | "DW_FORM_data4 is not suitable to emit a pointer to a location list "((void)0) | |||
| 830 | "in the 64-bit DWARF format")((void)0); | |||
| 831 | return 4; | |||
| 832 | case dwarf::DW_FORM_data8: | |||
| 833 | assert(AP->isDwarf64() &&((void)0) | |||
| 834 | "DW_FORM_data8 is not suitable to emit a pointer to a location list "((void)0) | |||
| 835 | "in the 32-bit DWARF format")((void)0); | |||
| 836 | return 8; | |||
| 837 | case dwarf::DW_FORM_sec_offset: | |||
| 838 | return AP->getDwarfOffsetByteSize(); | |||
| 839 | default: | |||
| 840 | llvm_unreachable("DIE Value form not supported yet")__builtin_unreachable(); | |||
| 841 | } | |||
| 842 | } | |||
| 843 | ||||
| 844 | /// EmitValue - Emit label value. | |||
| 845 | /// | |||
| 846 | void DIELocList::emitValue(const AsmPrinter *AP, dwarf::Form Form) const { | |||
| 847 | if (Form == dwarf::DW_FORM_loclistx) { | |||
| 848 | AP->emitULEB128(Index); | |||
| 849 | return; | |||
| 850 | } | |||
| 851 | DwarfDebug *DD = AP->getDwarfDebug(); | |||
| 852 | MCSymbol *Label = DD->getDebugLocs().getList(Index).Label; | |||
| 853 | AP->emitDwarfSymbolReference(Label, /*ForceOffset*/ DD->useSplitDwarf()); | |||
| 854 | } | |||
| 855 | ||||
| 856 | LLVM_DUMP_METHOD__attribute__((noinline)) | |||
| 857 | void DIELocList::print(raw_ostream &O) const { O << "LocList: " << Index; } | |||
| 858 | ||||
| 859 | //===----------------------------------------------------------------------===// | |||
| 860 | // DIEAddrOffset Implementation | |||
| 861 | //===----------------------------------------------------------------------===// | |||
| 862 | ||||
| 863 | unsigned DIEAddrOffset::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { | |||
| 864 | return Addr.SizeOf(AP, dwarf::DW_FORM_addrx) + | |||
| 865 | Offset.SizeOf(AP, dwarf::DW_FORM_data4); | |||
| 866 | } | |||
| 867 | ||||
| 868 | /// EmitValue - Emit label value. | |||
| 869 | /// | |||
| 870 | void DIEAddrOffset::emitValue(const AsmPrinter *AP, dwarf::Form Form) const { | |||
| 871 | Addr.emitValue(AP, dwarf::DW_FORM_addrx); | |||
| 872 | Offset.emitValue(AP, dwarf::DW_FORM_data4); | |||
| 873 | } | |||
| 874 | ||||
| 875 | LLVM_DUMP_METHOD__attribute__((noinline)) | |||
| 876 | void DIEAddrOffset::print(raw_ostream &O) const { | |||
| 877 | O << "AddrOffset: "; | |||
| 878 | Addr.print(O); | |||
| 879 | O << " + "; | |||
| 880 | Offset.print(O); | |||
| 881 | } |
| 1 | //===- Allocator.h - Simple memory allocation abstraction -------*- 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 | /// \file |
| 9 | /// |
| 10 | /// This file defines the BumpPtrAllocator interface. BumpPtrAllocator conforms |
| 11 | /// to the LLVM "Allocator" concept and is similar to MallocAllocator, but |
| 12 | /// objects cannot be deallocated. Their lifetime is tied to the lifetime of the |
| 13 | /// allocator. |
| 14 | /// |
| 15 | //===----------------------------------------------------------------------===// |
| 16 | |
| 17 | #ifndef LLVM_SUPPORT_ALLOCATOR_H |
| 18 | #define LLVM_SUPPORT_ALLOCATOR_H |
| 19 | |
| 20 | #include "llvm/ADT/Optional.h" |
| 21 | #include "llvm/ADT/SmallVector.h" |
| 22 | #include "llvm/Support/Alignment.h" |
| 23 | #include "llvm/Support/AllocatorBase.h" |
| 24 | #include "llvm/Support/Compiler.h" |
| 25 | #include "llvm/Support/ErrorHandling.h" |
| 26 | #include "llvm/Support/MathExtras.h" |
| 27 | #include "llvm/Support/MemAlloc.h" |
| 28 | #include <algorithm> |
| 29 | #include <cassert> |
| 30 | #include <cstddef> |
| 31 | #include <cstdint> |
| 32 | #include <cstdlib> |
| 33 | #include <iterator> |
| 34 | #include <type_traits> |
| 35 | #include <utility> |
| 36 | |
| 37 | namespace llvm { |
| 38 | |
| 39 | namespace detail { |
| 40 | |
| 41 | // We call out to an external function to actually print the message as the |
| 42 | // printing code uses Allocator.h in its implementation. |
| 43 | void printBumpPtrAllocatorStats(unsigned NumSlabs, size_t BytesAllocated, |
| 44 | size_t TotalMemory); |
| 45 | |
| 46 | } // end namespace detail |
| 47 | |
| 48 | /// Allocate memory in an ever growing pool, as if by bump-pointer. |
| 49 | /// |
| 50 | /// This isn't strictly a bump-pointer allocator as it uses backing slabs of |
| 51 | /// memory rather than relying on a boundless contiguous heap. However, it has |
| 52 | /// bump-pointer semantics in that it is a monotonically growing pool of memory |
| 53 | /// where every allocation is found by merely allocating the next N bytes in |
| 54 | /// the slab, or the next N bytes in the next slab. |
| 55 | /// |
| 56 | /// Note that this also has a threshold for forcing allocations above a certain |
| 57 | /// size into their own slab. |
| 58 | /// |
| 59 | /// The BumpPtrAllocatorImpl template defaults to using a MallocAllocator |
| 60 | /// object, which wraps malloc, to allocate memory, but it can be changed to |
| 61 | /// use a custom allocator. |
| 62 | /// |
| 63 | /// The GrowthDelay specifies after how many allocated slabs the allocator |
| 64 | /// increases the size of the slabs. |
| 65 | template <typename AllocatorT = MallocAllocator, size_t SlabSize = 4096, |
| 66 | size_t SizeThreshold = SlabSize, size_t GrowthDelay = 128> |
| 67 | class BumpPtrAllocatorImpl |
| 68 | : public AllocatorBase<BumpPtrAllocatorImpl<AllocatorT, SlabSize, |
| 69 | SizeThreshold, GrowthDelay>>, |
| 70 | private AllocatorT { |
| 71 | public: |
| 72 | static_assert(SizeThreshold <= SlabSize, |
| 73 | "The SizeThreshold must be at most the SlabSize to ensure " |
| 74 | "that objects larger than a slab go into their own memory " |
| 75 | "allocation."); |
| 76 | static_assert(GrowthDelay > 0, |
| 77 | "GrowthDelay must be at least 1 which already increases the" |
| 78 | "slab size after each allocated slab."); |
| 79 | |
| 80 | BumpPtrAllocatorImpl() = default; |
| 81 | |
| 82 | template <typename T> |
| 83 | BumpPtrAllocatorImpl(T &&Allocator) |
| 84 | : AllocatorT(std::forward<T &&>(Allocator)) {} |
| 85 | |
| 86 | // Manually implement a move constructor as we must clear the old allocator's |
| 87 | // slabs as a matter of correctness. |
| 88 | BumpPtrAllocatorImpl(BumpPtrAllocatorImpl &&Old) |
| 89 | : AllocatorT(static_cast<AllocatorT &&>(Old)), CurPtr(Old.CurPtr), |
| 90 | End(Old.End), Slabs(std::move(Old.Slabs)), |
| 91 | CustomSizedSlabs(std::move(Old.CustomSizedSlabs)), |
| 92 | BytesAllocated(Old.BytesAllocated), RedZoneSize(Old.RedZoneSize) { |
| 93 | Old.CurPtr = Old.End = nullptr; |
| 94 | Old.BytesAllocated = 0; |
| 95 | Old.Slabs.clear(); |
| 96 | Old.CustomSizedSlabs.clear(); |
| 97 | } |
| 98 | |
| 99 | ~BumpPtrAllocatorImpl() { |
| 100 | DeallocateSlabs(Slabs.begin(), Slabs.end()); |
| 101 | DeallocateCustomSizedSlabs(); |
| 102 | } |
| 103 | |
| 104 | BumpPtrAllocatorImpl &operator=(BumpPtrAllocatorImpl &&RHS) { |
| 105 | DeallocateSlabs(Slabs.begin(), Slabs.end()); |
| 106 | DeallocateCustomSizedSlabs(); |
| 107 | |
| 108 | CurPtr = RHS.CurPtr; |
| 109 | End = RHS.End; |
| 110 | BytesAllocated = RHS.BytesAllocated; |
| 111 | RedZoneSize = RHS.RedZoneSize; |
| 112 | Slabs = std::move(RHS.Slabs); |
| 113 | CustomSizedSlabs = std::move(RHS.CustomSizedSlabs); |
| 114 | AllocatorT::operator=(static_cast<AllocatorT &&>(RHS)); |
| 115 | |
| 116 | RHS.CurPtr = RHS.End = nullptr; |
| 117 | RHS.BytesAllocated = 0; |
| 118 | RHS.Slabs.clear(); |
| 119 | RHS.CustomSizedSlabs.clear(); |
| 120 | return *this; |
| 121 | } |
| 122 | |
| 123 | /// Deallocate all but the current slab and reset the current pointer |
| 124 | /// to the beginning of it, freeing all memory allocated so far. |
| 125 | void Reset() { |
| 126 | // Deallocate all but the first slab, and deallocate all custom-sized slabs. |
| 127 | DeallocateCustomSizedSlabs(); |
| 128 | CustomSizedSlabs.clear(); |
| 129 | |
| 130 | if (Slabs.empty()) |
| 131 | return; |
| 132 | |
| 133 | // Reset the state. |
| 134 | BytesAllocated = 0; |
| 135 | CurPtr = (char *)Slabs.front(); |
| 136 | End = CurPtr + SlabSize; |
| 137 | |
| 138 | __asan_poison_memory_region(*Slabs.begin(), computeSlabSize(0)); |
| 139 | DeallocateSlabs(std::next(Slabs.begin()), Slabs.end()); |
| 140 | Slabs.erase(std::next(Slabs.begin()), Slabs.end()); |
| 141 | } |
| 142 | |
| 143 | /// Allocate space at the specified alignment. |
| 144 | LLVM_ATTRIBUTE_RETURNS_NONNULL__attribute__((returns_nonnull)) LLVM_ATTRIBUTE_RETURNS_NOALIAS__attribute__((__malloc__)) void * |
| 145 | Allocate(size_t Size, Align Alignment) { |
| 146 | // Keep track of how many bytes we've allocated. |
| 147 | BytesAllocated += Size; |
| 148 | |
| 149 | size_t Adjustment = offsetToAlignedAddr(CurPtr, Alignment); |
| 150 | assert(Adjustment + Size >= Size && "Adjustment + Size must not overflow")((void)0); |
| 151 | |
| 152 | size_t SizeToAllocate = Size; |
| 153 | #if LLVM_ADDRESS_SANITIZER_BUILD0 |
| 154 | // Add trailing bytes as a "red zone" under ASan. |
| 155 | SizeToAllocate += RedZoneSize; |
| 156 | #endif |
| 157 | |
| 158 | // Check if we have enough space. |
| 159 | if (Adjustment + SizeToAllocate <= size_t(End - CurPtr)) { |
| 160 | char *AlignedPtr = CurPtr + Adjustment; |
| 161 | CurPtr = AlignedPtr + SizeToAllocate; |
| 162 | // Update the allocation point of this memory block in MemorySanitizer. |
| 163 | // Without this, MemorySanitizer messages for values originated from here |
| 164 | // will point to the allocation of the entire slab. |
| 165 | __msan_allocated_memory(AlignedPtr, Size); |
| 166 | // Similarly, tell ASan about this space. |
| 167 | __asan_unpoison_memory_region(AlignedPtr, Size); |
| 168 | return AlignedPtr; |
| 169 | } |
| 170 | |
| 171 | // If Size is really big, allocate a separate slab for it. |
| 172 | size_t PaddedSize = SizeToAllocate + Alignment.value() - 1; |
| 173 | if (PaddedSize > SizeThreshold) { |
| 174 | void *NewSlab = |
| 175 | AllocatorT::Allocate(PaddedSize, alignof(std::max_align_t)); |
| 176 | // We own the new slab and don't want anyone reading anyting other than |
| 177 | // pieces returned from this method. So poison the whole slab. |
| 178 | __asan_poison_memory_region(NewSlab, PaddedSize); |
| 179 | CustomSizedSlabs.push_back(std::make_pair(NewSlab, PaddedSize)); |
| 180 | |
| 181 | uintptr_t AlignedAddr = alignAddr(NewSlab, Alignment); |
| 182 | assert(AlignedAddr + Size <= (uintptr_t)NewSlab + PaddedSize)((void)0); |
| 183 | char *AlignedPtr = (char*)AlignedAddr; |
| 184 | __msan_allocated_memory(AlignedPtr, Size); |
| 185 | __asan_unpoison_memory_region(AlignedPtr, Size); |
| 186 | return AlignedPtr; |
| 187 | } |
| 188 | |
| 189 | // Otherwise, start a new slab and try again. |
| 190 | StartNewSlab(); |
| 191 | uintptr_t AlignedAddr = alignAddr(CurPtr, Alignment); |
| 192 | assert(AlignedAddr + SizeToAllocate <= (uintptr_t)End &&((void)0) |
| 193 | "Unable to allocate memory!")((void)0); |
| 194 | char *AlignedPtr = (char*)AlignedAddr; |
| 195 | CurPtr = AlignedPtr + SizeToAllocate; |
| 196 | __msan_allocated_memory(AlignedPtr, Size); |
| 197 | __asan_unpoison_memory_region(AlignedPtr, Size); |
| 198 | return AlignedPtr; |
| 199 | } |
| 200 | |
| 201 | inline LLVM_ATTRIBUTE_RETURNS_NONNULL__attribute__((returns_nonnull)) LLVM_ATTRIBUTE_RETURNS_NOALIAS__attribute__((__malloc__)) void * |
| 202 | Allocate(size_t Size, size_t Alignment) { |
| 203 | assert(Alignment > 0 && "0-byte alignment is not allowed. Use 1 instead.")((void)0); |
| 204 | return Allocate(Size, Align(Alignment)); |
| 205 | } |
| 206 | |
| 207 | // Pull in base class overloads. |
| 208 | using AllocatorBase<BumpPtrAllocatorImpl>::Allocate; |
| 209 | |
| 210 | // Bump pointer allocators are expected to never free their storage; and |
| 211 | // clients expect pointers to remain valid for non-dereferencing uses even |
| 212 | // after deallocation. |
| 213 | void Deallocate(const void *Ptr, size_t Size, size_t /*Alignment*/) { |
| 214 | __asan_poison_memory_region(Ptr, Size); |
| 215 | } |
| 216 | |
| 217 | // Pull in base class overloads. |
| 218 | using AllocatorBase<BumpPtrAllocatorImpl>::Deallocate; |
| 219 | |
| 220 | size_t GetNumSlabs() const { return Slabs.size() + CustomSizedSlabs.size(); } |
| 221 | |
| 222 | /// \return An index uniquely and reproducibly identifying |
| 223 | /// an input pointer \p Ptr in the given allocator. |
| 224 | /// The returned value is negative iff the object is inside a custom-size |
| 225 | /// slab. |
| 226 | /// Returns an empty optional if the pointer is not found in the allocator. |
| 227 | llvm::Optional<int64_t> identifyObject(const void *Ptr) { |
| 228 | const char *P = static_cast<const char *>(Ptr); |
| 229 | int64_t InSlabIdx = 0; |
| 230 | for (size_t Idx = 0, E = Slabs.size(); Idx < E; Idx++) { |
| 231 | const char *S = static_cast<const char *>(Slabs[Idx]); |
| 232 | if (P >= S && P < S + computeSlabSize(Idx)) |
| 233 | return InSlabIdx + static_cast<int64_t>(P - S); |
| 234 | InSlabIdx += static_cast<int64_t>(computeSlabSize(Idx)); |
| 235 | } |
| 236 | |
| 237 | // Use negative index to denote custom sized slabs. |
| 238 | int64_t InCustomSizedSlabIdx = -1; |
| 239 | for (size_t Idx = 0, E = CustomSizedSlabs.size(); Idx < E; Idx++) { |
| 240 | const char *S = static_cast<const char *>(CustomSizedSlabs[Idx].first); |
| 241 | size_t Size = CustomSizedSlabs[Idx].second; |
| 242 | if (P >= S && P < S + Size) |
| 243 | return InCustomSizedSlabIdx - static_cast<int64_t>(P - S); |
| 244 | InCustomSizedSlabIdx -= static_cast<int64_t>(Size); |
| 245 | } |
| 246 | return None; |
| 247 | } |
| 248 | |
| 249 | /// A wrapper around identifyObject that additionally asserts that |
| 250 | /// the object is indeed within the allocator. |
| 251 | /// \return An index uniquely and reproducibly identifying |
| 252 | /// an input pointer \p Ptr in the given allocator. |
| 253 | int64_t identifyKnownObject(const void *Ptr) { |
| 254 | Optional<int64_t> Out = identifyObject(Ptr); |
| 255 | assert(Out && "Wrong allocator used")((void)0); |
| 256 | return *Out; |
| 257 | } |
| 258 | |
| 259 | /// A wrapper around identifyKnownObject. Accepts type information |
| 260 | /// about the object and produces a smaller identifier by relying on |
| 261 | /// the alignment information. Note that sub-classes may have different |
| 262 | /// alignment, so the most base class should be passed as template parameter |
| 263 | /// in order to obtain correct results. For that reason automatic template |
| 264 | /// parameter deduction is disabled. |
| 265 | /// \return An index uniquely and reproducibly identifying |
| 266 | /// an input pointer \p Ptr in the given allocator. This identifier is |
| 267 | /// different from the ones produced by identifyObject and |
| 268 | /// identifyAlignedObject. |
| 269 | template <typename T> |
| 270 | int64_t identifyKnownAlignedObject(const void *Ptr) { |
| 271 | int64_t Out = identifyKnownObject(Ptr); |
| 272 | assert(Out % alignof(T) == 0 && "Wrong alignment information")((void)0); |
| 273 | return Out / alignof(T); |
| 274 | } |
| 275 | |
| 276 | size_t getTotalMemory() const { |
| 277 | size_t TotalMemory = 0; |
| 278 | for (auto I = Slabs.begin(), E = Slabs.end(); I != E; ++I) |
| 279 | TotalMemory += computeSlabSize(std::distance(Slabs.begin(), I)); |
| 280 | for (auto &PtrAndSize : CustomSizedSlabs) |
| 281 | TotalMemory += PtrAndSize.second; |
| 282 | return TotalMemory; |
| 283 | } |
| 284 | |
| 285 | size_t getBytesAllocated() const { return BytesAllocated; } |
| 286 | |
| 287 | void setRedZoneSize(size_t NewSize) { |
| 288 | RedZoneSize = NewSize; |
| 289 | } |
| 290 | |
| 291 | void PrintStats() const { |
| 292 | detail::printBumpPtrAllocatorStats(Slabs.size(), BytesAllocated, |
| 293 | getTotalMemory()); |
| 294 | } |
| 295 | |
| 296 | private: |
| 297 | /// The current pointer into the current slab. |
| 298 | /// |
| 299 | /// This points to the next free byte in the slab. |
| 300 | char *CurPtr = nullptr; |
| 301 | |
| 302 | /// The end of the current slab. |
| 303 | char *End = nullptr; |
| 304 | |
| 305 | /// The slabs allocated so far. |
| 306 | SmallVector<void *, 4> Slabs; |
| 307 | |
| 308 | /// Custom-sized slabs allocated for too-large allocation requests. |
| 309 | SmallVector<std::pair<void *, size_t>, 0> CustomSizedSlabs; |
| 310 | |
| 311 | /// How many bytes we've allocated. |
| 312 | /// |
| 313 | /// Used so that we can compute how much space was wasted. |
| 314 | size_t BytesAllocated = 0; |
| 315 | |
| 316 | /// The number of bytes to put between allocations when running under |
| 317 | /// a sanitizer. |
| 318 | size_t RedZoneSize = 1; |
| 319 | |
| 320 | static size_t computeSlabSize(unsigned SlabIdx) { |
| 321 | // Scale the actual allocated slab size based on the number of slabs |
| 322 | // allocated. Every GrowthDelay slabs allocated, we double |
| 323 | // the allocated size to reduce allocation frequency, but saturate at |
| 324 | // multiplying the slab size by 2^30. |
| 325 | return SlabSize * |
| 326 | ((size_t)1 << std::min<size_t>(30, SlabIdx / GrowthDelay)); |
| 327 | } |
| 328 | |
| 329 | /// Allocate a new slab and move the bump pointers over into the new |
| 330 | /// slab, modifying CurPtr and End. |
| 331 | void StartNewSlab() { |
| 332 | size_t AllocatedSlabSize = computeSlabSize(Slabs.size()); |
| 333 | |
| 334 | void *NewSlab = |
| 335 | AllocatorT::Allocate(AllocatedSlabSize, alignof(std::max_align_t)); |
| 336 | // We own the new slab and don't want anyone reading anything other than |
| 337 | // pieces returned from this method. So poison the whole slab. |
| 338 | __asan_poison_memory_region(NewSlab, AllocatedSlabSize); |
| 339 | |
| 340 | Slabs.push_back(NewSlab); |
| 341 | CurPtr = (char *)(NewSlab); |
| 342 | End = ((char *)NewSlab) + AllocatedSlabSize; |
| 343 | } |
| 344 | |
| 345 | /// Deallocate a sequence of slabs. |
| 346 | void DeallocateSlabs(SmallVectorImpl<void *>::iterator I, |
| 347 | SmallVectorImpl<void *>::iterator E) { |
| 348 | for (; I != E; ++I) { |
| 349 | size_t AllocatedSlabSize = |
| 350 | computeSlabSize(std::distance(Slabs.begin(), I)); |
| 351 | AllocatorT::Deallocate(*I, AllocatedSlabSize, alignof(std::max_align_t)); |
| 352 | } |
| 353 | } |
| 354 | |
| 355 | /// Deallocate all memory for custom sized slabs. |
| 356 | void DeallocateCustomSizedSlabs() { |
| 357 | for (auto &PtrAndSize : CustomSizedSlabs) { |
| 358 | void *Ptr = PtrAndSize.first; |
| 359 | size_t Size = PtrAndSize.second; |
| 360 | AllocatorT::Deallocate(Ptr, Size, alignof(std::max_align_t)); |
| 361 | } |
| 362 | } |
| 363 | |
| 364 | template <typename T> friend class SpecificBumpPtrAllocator; |
| 365 | }; |
| 366 | |
| 367 | /// The standard BumpPtrAllocator which just uses the default template |
| 368 | /// parameters. |
| 369 | typedef BumpPtrAllocatorImpl<> BumpPtrAllocator; |
| 370 | |
| 371 | /// A BumpPtrAllocator that allows only elements of a specific type to be |
| 372 | /// allocated. |
| 373 | /// |
| 374 | /// This allows calling the destructor in DestroyAll() and when the allocator is |
| 375 | /// destroyed. |
| 376 | template <typename T> class SpecificBumpPtrAllocator { |
| 377 | BumpPtrAllocator Allocator; |
| 378 | |
| 379 | public: |
| 380 | SpecificBumpPtrAllocator() { |
| 381 | // Because SpecificBumpPtrAllocator walks the memory to call destructors, |
| 382 | // it can't have red zones between allocations. |
| 383 | Allocator.setRedZoneSize(0); |
| 384 | } |
| 385 | SpecificBumpPtrAllocator(SpecificBumpPtrAllocator &&Old) |
| 386 | : Allocator(std::move(Old.Allocator)) {} |
| 387 | ~SpecificBumpPtrAllocator() { DestroyAll(); } |
| 388 | |
| 389 | SpecificBumpPtrAllocator &operator=(SpecificBumpPtrAllocator &&RHS) { |
| 390 | Allocator = std::move(RHS.Allocator); |
| 391 | return *this; |
| 392 | } |
| 393 | |
| 394 | /// Call the destructor of each allocated object and deallocate all but the |
| 395 | /// current slab and reset the current pointer to the beginning of it, freeing |
| 396 | /// all memory allocated so far. |
| 397 | void DestroyAll() { |
| 398 | auto DestroyElements = [](char *Begin, char *End) { |
| 399 | assert(Begin == (char *)alignAddr(Begin, Align::Of<T>()))((void)0); |
| 400 | for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T)) |
| 401 | reinterpret_cast<T *>(Ptr)->~T(); |
| 402 | }; |
| 403 | |
| 404 | for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E; |
| 405 | ++I) { |
| 406 | size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize( |
| 407 | std::distance(Allocator.Slabs.begin(), I)); |
| 408 | char *Begin = (char *)alignAddr(*I, Align::Of<T>()); |
| 409 | char *End = *I == Allocator.Slabs.back() ? Allocator.CurPtr |
| 410 | : (char *)*I + AllocatedSlabSize; |
| 411 | |
| 412 | DestroyElements(Begin, End); |
| 413 | } |
| 414 | |
| 415 | for (auto &PtrAndSize : Allocator.CustomSizedSlabs) { |
| 416 | void *Ptr = PtrAndSize.first; |
| 417 | size_t Size = PtrAndSize.second; |
| 418 | DestroyElements((char *)alignAddr(Ptr, Align::Of<T>()), |
| 419 | (char *)Ptr + Size); |
| 420 | } |
| 421 | |
| 422 | Allocator.Reset(); |
| 423 | } |
| 424 | |
| 425 | /// Allocate space for an array of objects without constructing them. |
| 426 | T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); } |
| 427 | }; |
| 428 | |
| 429 | } // end namespace llvm |
| 430 | |
| 431 | template <typename AllocatorT, size_t SlabSize, size_t SizeThreshold, |
| 432 | size_t GrowthDelay> |
| 433 | void * |
| 434 | operator new(size_t Size, |
| 435 | llvm::BumpPtrAllocatorImpl<AllocatorT, SlabSize, SizeThreshold, |
| 436 | GrowthDelay> &Allocator) { |
| 437 | return Allocator.Allocate(Size, std::min((size_t)llvm::NextPowerOf2(Size), |
| 438 | alignof(std::max_align_t))); |
| 439 | } |
| 440 | |
| 441 | template <typename AllocatorT, size_t SlabSize, size_t SizeThreshold, |
| 442 | size_t GrowthDelay> |
| 443 | void operator delete(void *, |
| 444 | llvm::BumpPtrAllocatorImpl<AllocatorT, SlabSize, |
| 445 | SizeThreshold, GrowthDelay> &) { |
| 446 | } |
| 447 | |
| 448 | #endif // LLVM_SUPPORT_ALLOCATOR_H |
| 1 | //===-- llvm/Support/Alignment.h - Useful alignment functions ---*- 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 | // This file contains types to represent alignments. | |||
| 10 | // They are instrumented to guarantee some invariants are preserved and prevent | |||
| 11 | // invalid manipulations. | |||
| 12 | // | |||
| 13 | // - Align represents an alignment in bytes, it is always set and always a valid | |||
| 14 | // power of two, its minimum value is 1 which means no alignment requirements. | |||
| 15 | // | |||
| 16 | // - MaybeAlign is an optional type, it may be undefined or set. When it's set | |||
| 17 | // you can get the underlying Align type by using the getValue() method. | |||
| 18 | // | |||
| 19 | //===----------------------------------------------------------------------===// | |||
| 20 | ||||
| 21 | #ifndef LLVM_SUPPORT_ALIGNMENT_H_ | |||
| 22 | #define LLVM_SUPPORT_ALIGNMENT_H_ | |||
| 23 | ||||
| 24 | #include "llvm/ADT/Optional.h" | |||
| 25 | #include "llvm/Support/MathExtras.h" | |||
| 26 | #include <cassert> | |||
| 27 | #ifndef NDEBUG1 | |||
| 28 | #include <string> | |||
| 29 | #endif // NDEBUG | |||
| 30 | ||||
| 31 | namespace llvm { | |||
| 32 | ||||
| 33 | #define ALIGN_CHECK_ISPOSITIVE(decl) \ | |||
| 34 | assert(decl > 0 && (#decl " should be defined"))((void)0) | |||
| 35 | ||||
| 36 | /// This struct is a compact representation of a valid (non-zero power of two) | |||
| 37 | /// alignment. | |||
| 38 | /// It is suitable for use as static global constants. | |||
| 39 | struct Align { | |||
| 40 | private: | |||
| 41 | uint8_t ShiftValue = 0; /// The log2 of the required alignment. | |||
| 42 | /// ShiftValue is less than 64 by construction. | |||
| 43 | ||||
| 44 | friend struct MaybeAlign; | |||
| 45 | friend unsigned Log2(Align); | |||
| 46 | friend bool operator==(Align Lhs, Align Rhs); | |||
| 47 | friend bool operator!=(Align Lhs, Align Rhs); | |||
| 48 | friend bool operator<=(Align Lhs, Align Rhs); | |||
| 49 | friend bool operator>=(Align Lhs, Align Rhs); | |||
| 50 | friend bool operator<(Align Lhs, Align Rhs); | |||
| 51 | friend bool operator>(Align Lhs, Align Rhs); | |||
| 52 | friend unsigned encode(struct MaybeAlign A); | |||
| 53 | friend struct MaybeAlign decodeMaybeAlign(unsigned Value); | |||
| 54 | ||||
| 55 | /// A trivial type to allow construction of constexpr Align. | |||
| 56 | /// This is currently needed to workaround a bug in GCC 5.3 which prevents | |||
| 57 | /// definition of constexpr assign operators. | |||
| 58 | /// https://stackoverflow.com/questions/46756288/explicitly-defaulted-function-cannot-be-declared-as-constexpr-because-the-implic | |||
| 59 | /// FIXME: Remove this, make all assign operators constexpr and introduce user | |||
| 60 | /// defined literals when we don't have to support GCC 5.3 anymore. | |||
| 61 | /// https://llvm.org/docs/GettingStarted.html#getting-a-modern-host-c-toolchain | |||
| 62 | struct LogValue { | |||
| 63 | uint8_t Log; | |||
| 64 | }; | |||
| 65 | ||||
| 66 | public: | |||
| 67 | /// Default is byte-aligned. | |||
| 68 | constexpr Align() = default; | |||
| 69 | /// Do not perform checks in case of copy/move construct/assign, because the | |||
| 70 | /// checks have been performed when building `Other`. | |||
| 71 | constexpr Align(const Align &Other) = default; | |||
| 72 | constexpr Align(Align &&Other) = default; | |||
| 73 | Align &operator=(const Align &Other) = default; | |||
| 74 | Align &operator=(Align &&Other) = default; | |||
| 75 | ||||
| 76 | explicit Align(uint64_t Value) { | |||
| 77 | assert(Value > 0 && "Value must not be 0")((void)0); | |||
| 78 | assert(llvm::isPowerOf2_64(Value) && "Alignment is not a power of 2")((void)0); | |||
| 79 | ShiftValue = Log2_64(Value); | |||
| 80 | assert(ShiftValue < 64 && "Broken invariant")((void)0); | |||
| 81 | } | |||
| 82 | ||||
| 83 | /// This is a hole in the type system and should not be abused. | |||
| 84 | /// Needed to interact with C for instance. | |||
| 85 | uint64_t value() const { return uint64_t(1) << ShiftValue; } | |||
| ||||
| 86 | ||||
| 87 | /// Allow constructions of constexpr Align. | |||
| 88 | template <size_t kValue> constexpr static LogValue Constant() { | |||
| 89 | return LogValue{static_cast<uint8_t>(CTLog2<kValue>())}; | |||
| 90 | } | |||
| 91 | ||||
| 92 | /// Allow constructions of constexpr Align from types. | |||
| 93 | /// Compile time equivalent to Align(alignof(T)). | |||
| 94 | template <typename T> constexpr static LogValue Of() { | |||
| 95 | return Constant<std::alignment_of<T>::value>(); | |||
| 96 | } | |||
| 97 | ||||
| 98 | /// Constexpr constructor from LogValue type. | |||
| 99 | constexpr Align(LogValue CA) : ShiftValue(CA.Log) {} | |||
| 100 | }; | |||
| 101 | ||||
| 102 | /// Treats the value 0 as a 1, so Align is always at least 1. | |||
| 103 | inline Align assumeAligned(uint64_t Value) { | |||
| 104 | return Value ? Align(Value) : Align(); | |||
| 105 | } | |||
| 106 | ||||
| 107 | /// This struct is a compact representation of a valid (power of two) or | |||
| 108 | /// undefined (0) alignment. | |||
| 109 | struct MaybeAlign : public llvm::Optional<Align> { | |||
| 110 | private: | |||
| 111 | using UP = llvm::Optional<Align>; | |||
| 112 | ||||
| 113 | public: | |||
| 114 | /// Default is undefined. | |||
| 115 | MaybeAlign() = default; | |||
| 116 | /// Do not perform checks in case of copy/move construct/assign, because the | |||
| 117 | /// checks have been performed when building `Other`. | |||
| 118 | MaybeAlign(const MaybeAlign &Other) = default; | |||
| 119 | MaybeAlign &operator=(const MaybeAlign &Other) = default; | |||
| 120 | MaybeAlign(MaybeAlign &&Other) = default; | |||
| 121 | MaybeAlign &operator=(MaybeAlign &&Other) = default; | |||
| 122 | ||||
| 123 | /// Use llvm::Optional<Align> constructor. | |||
| 124 | using UP::UP; | |||
| 125 | ||||
| 126 | explicit MaybeAlign(uint64_t Value) { | |||
| 127 | assert((Value == 0 || llvm::isPowerOf2_64(Value)) &&((void)0) | |||
| 128 | "Alignment is neither 0 nor a power of 2")((void)0); | |||
| 129 | if (Value) | |||
| 130 | emplace(Value); | |||
| 131 | } | |||
| 132 | ||||
| 133 | /// For convenience, returns a valid alignment or 1 if undefined. | |||
| 134 | Align valueOrOne() const { return hasValue() ? getValue() : Align(); } | |||
| 135 | }; | |||
| 136 | ||||
| 137 | /// Checks that SizeInBytes is a multiple of the alignment. | |||
| 138 | inline bool isAligned(Align Lhs, uint64_t SizeInBytes) { | |||
| 139 | return SizeInBytes % Lhs.value() == 0; | |||
| 140 | } | |||
| 141 | ||||
| 142 | /// Checks that Addr is a multiple of the alignment. | |||
| 143 | inline bool isAddrAligned(Align Lhs, const void *Addr) { | |||
| 144 | return isAligned(Lhs, reinterpret_cast<uintptr_t>(Addr)); | |||
| 145 | } | |||
| 146 | ||||
| 147 | /// Returns a multiple of A needed to store `Size` bytes. | |||
| 148 | inline uint64_t alignTo(uint64_t Size, Align A) { | |||
| 149 | const uint64_t Value = A.value(); | |||
| 150 | // The following line is equivalent to `(Size + Value - 1) / Value * Value`. | |||
| 151 | ||||
| 152 | // The division followed by a multiplication can be thought of as a right | |||
| 153 | // shift followed by a left shift which zeros out the extra bits produced in | |||
| 154 | // the bump; `~(Value - 1)` is a mask where all those bits being zeroed out | |||
| 155 | // are just zero. | |||
| 156 | ||||
| 157 | // Most compilers can generate this code but the pattern may be missed when | |||
| 158 | // multiple functions gets inlined. | |||
| 159 | return (Size + Value - 1) & ~(Value - 1U); | |||
| 160 | } | |||
| 161 | ||||
| 162 | /// If non-zero \p Skew is specified, the return value will be a minimal integer | |||
| 163 | /// that is greater than or equal to \p Size and equal to \p A * N + \p Skew for | |||
| 164 | /// some integer N. If \p Skew is larger than \p A, its value is adjusted to '\p | |||
| 165 | /// Skew mod \p A'. | |||
| 166 | /// | |||
| 167 | /// Examples: | |||
| 168 | /// \code | |||
| 169 | /// alignTo(5, Align(8), 7) = 7 | |||
| 170 | /// alignTo(17, Align(8), 1) = 17 | |||
| 171 | /// alignTo(~0LL, Align(8), 3) = 3 | |||
| 172 | /// \endcode | |||
| 173 | inline uint64_t alignTo(uint64_t Size, Align A, uint64_t Skew) { | |||
| 174 | const uint64_t Value = A.value(); | |||
| 175 | Skew %= Value; | |||
| 176 | return ((Size + Value - 1 - Skew) & ~(Value - 1U)) + Skew; | |||
| 177 | } | |||
| 178 | ||||
| 179 | /// Returns a multiple of A needed to store `Size` bytes. | |||
| 180 | /// Returns `Size` if current alignment is undefined. | |||
| 181 | inline uint64_t alignTo(uint64_t Size, MaybeAlign A) { | |||
| 182 | return A ? alignTo(Size, A.getValue()) : Size; | |||
| 183 | } | |||
| 184 | ||||
| 185 | /// Aligns `Addr` to `Alignment` bytes, rounding up. | |||
| 186 | inline uintptr_t alignAddr(const void *Addr, Align Alignment) { | |||
| 187 | uintptr_t ArithAddr = reinterpret_cast<uintptr_t>(Addr); | |||
| 188 | assert(static_cast<uintptr_t>(ArithAddr + Alignment.value() - 1) >=((void)0) | |||
| 189 | ArithAddr &&((void)0) | |||
| 190 | "Overflow")((void)0); | |||
| 191 | return alignTo(ArithAddr, Alignment); | |||
| 192 | } | |||
| 193 | ||||
| 194 | /// Returns the offset to the next integer (mod 2**64) that is greater than | |||
| 195 | /// or equal to \p Value and is a multiple of \p Align. | |||
| 196 | inline uint64_t offsetToAlignment(uint64_t Value, Align Alignment) { | |||
| 197 | return alignTo(Value, Alignment) - Value; | |||
| 198 | } | |||
| 199 | ||||
| 200 | /// Returns the necessary adjustment for aligning `Addr` to `Alignment` | |||
| 201 | /// bytes, rounding up. | |||
| 202 | inline uint64_t offsetToAlignedAddr(const void *Addr, Align Alignment) { | |||
| 203 | return offsetToAlignment(reinterpret_cast<uintptr_t>(Addr), Alignment); | |||
| 204 | } | |||
| 205 | ||||
| 206 | /// Returns the log2 of the alignment. | |||
| 207 | inline unsigned Log2(Align A) { return A.ShiftValue; } | |||
| 208 | ||||
| 209 | /// Returns the alignment that satisfies both alignments. | |||
| 210 | /// Same semantic as MinAlign. | |||
| 211 | inline Align commonAlignment(Align A, Align B) { return std::min(A, B); } | |||
| 212 | ||||
| 213 | /// Returns the alignment that satisfies both alignments. | |||
| 214 | /// Same semantic as MinAlign. | |||
| 215 | inline Align commonAlignment(Align A, uint64_t Offset) { | |||
| 216 | return Align(MinAlign(A.value(), Offset)); | |||
| 217 | } | |||
| 218 | ||||
| 219 | /// Returns the alignment that satisfies both alignments. | |||
| 220 | /// Same semantic as MinAlign. | |||
| 221 | inline MaybeAlign commonAlignment(MaybeAlign A, MaybeAlign B) { | |||
| 222 | return A && B ? commonAlignment(*A, *B) : A ? A : B; | |||
| 223 | } | |||
| 224 | ||||
| 225 | /// Returns the alignment that satisfies both alignments. | |||
| 226 | /// Same semantic as MinAlign. | |||
| 227 | inline MaybeAlign commonAlignment(MaybeAlign A, uint64_t Offset) { | |||
| 228 | return MaybeAlign(MinAlign((*A).value(), Offset)); | |||
| 229 | } | |||
| 230 | ||||
| 231 | /// Returns a representation of the alignment that encodes undefined as 0. | |||
| 232 | inline unsigned encode(MaybeAlign A) { return A ? A->ShiftValue + 1 : 0; } | |||
| 233 | ||||
| 234 | /// Dual operation of the encode function above. | |||
| 235 | inline MaybeAlign decodeMaybeAlign(unsigned Value) { | |||
| 236 | if (Value == 0) | |||
| 237 | return MaybeAlign(); | |||
| 238 | Align Out; | |||
| 239 | Out.ShiftValue = Value - 1; | |||
| 240 | return Out; | |||
| 241 | } | |||
| 242 | ||||
| 243 | /// Returns a representation of the alignment, the encoded value is positive by | |||
| 244 | /// definition. | |||
| 245 | inline unsigned encode(Align A) { return encode(MaybeAlign(A)); } | |||
| 246 | ||||
| 247 | /// Comparisons between Align and scalars. Rhs must be positive. | |||
| 248 | inline bool operator==(Align Lhs, uint64_t Rhs) { | |||
| 249 | ALIGN_CHECK_ISPOSITIVE(Rhs); | |||
| 250 | return Lhs.value() == Rhs; | |||
| 251 | } | |||
| 252 | inline bool operator!=(Align Lhs, uint64_t Rhs) { | |||
| 253 | ALIGN_CHECK_ISPOSITIVE(Rhs); | |||
| 254 | return Lhs.value() != Rhs; | |||
| 255 | } | |||
| 256 | inline bool operator<=(Align Lhs, uint64_t Rhs) { | |||
| 257 | ALIGN_CHECK_ISPOSITIVE(Rhs); | |||
| 258 | return Lhs.value() <= Rhs; | |||
| 259 | } | |||
| 260 | inline bool operator>=(Align Lhs, uint64_t Rhs) { | |||
| 261 | ALIGN_CHECK_ISPOSITIVE(Rhs); | |||
| 262 | return Lhs.value() >= Rhs; | |||
| 263 | } | |||
| 264 | inline bool operator<(Align Lhs, uint64_t Rhs) { | |||
| 265 | ALIGN_CHECK_ISPOSITIVE(Rhs); | |||
| 266 | return Lhs.value() < Rhs; | |||
| 267 | } | |||
| 268 | inline bool operator>(Align Lhs, uint64_t Rhs) { | |||
| 269 | ALIGN_CHECK_ISPOSITIVE(Rhs); | |||
| 270 | return Lhs.value() > Rhs; | |||
| 271 | } | |||
| 272 | ||||
| 273 | /// Comparisons between MaybeAlign and scalars. | |||
| 274 | inline bool operator==(MaybeAlign Lhs, uint64_t Rhs) { | |||
| 275 | return Lhs ? (*Lhs).value() == Rhs : Rhs == 0; | |||
| 276 | } | |||
| 277 | inline bool operator!=(MaybeAlign Lhs, uint64_t Rhs) { | |||
| 278 | return Lhs ? (*Lhs).value() != Rhs : Rhs != 0; | |||
| 279 | } | |||
| 280 | ||||
| 281 | /// Comparisons operators between Align. | |||
| 282 | inline bool operator==(Align Lhs, Align Rhs) { | |||
| 283 | return Lhs.ShiftValue == Rhs.ShiftValue; | |||
| 284 | } | |||
| 285 | inline bool operator!=(Align Lhs, Align Rhs) { | |||
| 286 | return Lhs.ShiftValue != Rhs.ShiftValue; | |||
| 287 | } | |||
| 288 | inline bool operator<=(Align Lhs, Align Rhs) { | |||
| 289 | return Lhs.ShiftValue <= Rhs.ShiftValue; | |||
| 290 | } | |||
| 291 | inline bool operator>=(Align Lhs, Align Rhs) { | |||
| 292 | return Lhs.ShiftValue >= Rhs.ShiftValue; | |||
| 293 | } | |||
| 294 | inline bool operator<(Align Lhs, Align Rhs) { | |||
| 295 | return Lhs.ShiftValue < Rhs.ShiftValue; | |||
| 296 | } | |||
| 297 | inline bool operator>(Align Lhs, Align Rhs) { | |||
| 298 | return Lhs.ShiftValue > Rhs.ShiftValue; | |||
| 299 | } | |||
| 300 | ||||
| 301 | // Don't allow relational comparisons with MaybeAlign. | |||
| 302 | bool operator<=(Align Lhs, MaybeAlign Rhs) = delete; | |||
| 303 | bool operator>=(Align Lhs, MaybeAlign Rhs) = delete; | |||
| 304 | bool operator<(Align Lhs, MaybeAlign Rhs) = delete; | |||
| 305 | bool operator>(Align Lhs, MaybeAlign Rhs) = delete; | |||
| 306 | ||||
| 307 | bool operator<=(MaybeAlign Lhs, Align Rhs) = delete; | |||
| 308 | bool operator>=(MaybeAlign Lhs, Align Rhs) = delete; | |||
| 309 | bool operator<(MaybeAlign Lhs, Align Rhs) = delete; | |||
| 310 | bool operator>(MaybeAlign Lhs, Align Rhs) = delete; | |||
| 311 | ||||
| 312 | bool operator<=(MaybeAlign Lhs, MaybeAlign Rhs) = delete; | |||
| 313 | bool operator>=(MaybeAlign Lhs, MaybeAlign Rhs) = delete; | |||
| 314 | bool operator<(MaybeAlign Lhs, MaybeAlign Rhs) = delete; | |||
| 315 | bool operator>(MaybeAlign Lhs, MaybeAlign Rhs) = delete; | |||
| 316 | ||||
| 317 | inline Align operator*(Align Lhs, uint64_t Rhs) { | |||
| 318 | assert(Rhs > 0 && "Rhs must be positive")((void)0); | |||
| 319 | return Align(Lhs.value() * Rhs); | |||
| 320 | } | |||
| 321 | ||||
| 322 | inline MaybeAlign operator*(MaybeAlign Lhs, uint64_t Rhs) { | |||
| 323 | assert(Rhs > 0 && "Rhs must be positive")((void)0); | |||
| 324 | return Lhs ? Lhs.getValue() * Rhs : MaybeAlign(); | |||
| 325 | } | |||
| 326 | ||||
| 327 | inline Align operator/(Align Lhs, uint64_t Divisor) { | |||
| 328 | assert(llvm::isPowerOf2_64(Divisor) &&((void)0) | |||
| 329 | "Divisor must be positive and a power of 2")((void)0); | |||
| 330 | assert(Lhs != 1 && "Can't halve byte alignment")((void)0); | |||
| 331 | return Align(Lhs.value() / Divisor); | |||
| 332 | } | |||
| 333 | ||||
| 334 | inline MaybeAlign operator/(MaybeAlign Lhs, uint64_t Divisor) { | |||
| 335 | assert(llvm::isPowerOf2_64(Divisor) &&((void)0) | |||
| 336 | "Divisor must be positive and a power of 2")((void)0); | |||
| 337 | return Lhs ? Lhs.getValue() / Divisor : MaybeAlign(); | |||
| 338 | } | |||
| 339 | ||||
| 340 | inline Align max(MaybeAlign Lhs, Align Rhs) { | |||
| 341 | return Lhs && *Lhs > Rhs ? *Lhs : Rhs; | |||
| 342 | } | |||
| 343 | ||||
| 344 | inline Align max(Align Lhs, MaybeAlign Rhs) { | |||
| 345 | return Rhs && *Rhs > Lhs ? *Rhs : Lhs; | |||
| 346 | } | |||
| 347 | ||||
| 348 | #ifndef NDEBUG1 | |||
| 349 | // For usage in LLVM_DEBUG macros. | |||
| 350 | inline std::string DebugStr(const Align &A) { | |||
| 351 | return std::to_string(A.value()); | |||
| 352 | } | |||
| 353 | // For usage in LLVM_DEBUG macros. | |||
| 354 | inline std::string DebugStr(const MaybeAlign &MA) { | |||
| 355 | if (MA) | |||
| 356 | return std::to_string(MA->value()); | |||
| 357 | return "None"; | |||
| 358 | } | |||
| 359 | #endif // NDEBUG | |||
| 360 | ||||
| 361 | #undef ALIGN_CHECK_ISPOSITIVE | |||
| 362 | ||||
| 363 | } // namespace llvm | |||
| 364 | ||||
| 365 | #endif // LLVM_SUPPORT_ALIGNMENT_H_ |