[lldb][NFC] Fix all formatting errors in .cpp file headers
Summary:
A *.cpp file header in LLDB (and in LLDB) should like this:
```
//===-- TestUtilities.cpp -------------------------------------------------===//
```
However in LLDB most of our source files have arbitrary changes to this format and
these changes are spreading through LLDB as folks usually just use the existing
source files as templates for their new files (most notably the unnecessary
editor language indicator `-*- C++ -*-` is spreading and in every review
someone is pointing out that this is wrong, resulting in people pointing out that this
is done in the same way in other files).
This patch removes most of these inconsistencies including the editor language indicators,
all the different missing/additional '-' characters, files that center the file name, missing
trailing `===//` (mostly caused by clang-format breaking the line).
Reviewers: aprantl, espindola, jfb, shafik, JDevlieghere
Reviewed By: JDevlieghere
Subscribers: dexonsmith, wuzish, emaste, sdardis, nemanjai, kbarton, MaskRay, atanasyan, arphaman, jfb, abidh, jsji, JDevlieghere, usaxena95, lldb-commits
Tags: #lldb
Differential Revision: https://reviews.llvm.org/D73258
2020-01-24 15:23:27 +08:00
|
|
|
//===-- SectionLoadHistory.cpp --------------------------------------------===//
|
2013-12-06 09:12:00 +08:00
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
2013-12-06 09:12:00 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "lldb/Target/SectionLoadHistory.h"
|
|
|
|
|
|
|
|
#include "lldb/Target/SectionLoadList.h"
|
2017-02-03 05:39:50 +08:00
|
|
|
#include "lldb/Utility/Stream.h"
|
2013-12-06 09:12:00 +08:00
|
|
|
|
|
|
|
using namespace lldb;
|
|
|
|
using namespace lldb_private;
|
|
|
|
|
|
|
|
bool SectionLoadHistory::IsEmpty() const {
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2013-12-06 09:12:00 +08:00
|
|
|
return m_stop_id_to_section_load_list.empty();
|
|
|
|
}
|
|
|
|
|
|
|
|
void SectionLoadHistory::Clear() {
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2013-12-06 09:12:00 +08:00
|
|
|
m_stop_id_to_section_load_list.clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t SectionLoadHistory::GetLastStopID() const {
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2013-12-06 09:12:00 +08:00
|
|
|
if (m_stop_id_to_section_load_list.empty())
|
|
|
|
return 0;
|
|
|
|
else
|
|
|
|
return m_stop_id_to_section_load_list.rbegin()->first;
|
|
|
|
}
|
|
|
|
|
|
|
|
SectionLoadList *
|
|
|
|
SectionLoadHistory::GetSectionLoadListForStopID(uint32_t stop_id,
|
|
|
|
bool read_only) {
|
2014-05-15 01:25:00 +08:00
|
|
|
if (!m_stop_id_to_section_load_list.empty()) {
|
2013-12-06 09:12:00 +08:00
|
|
|
if (read_only) {
|
|
|
|
// The section load list is for reading data only so we don't need to
|
2018-05-01 00:49:04 +08:00
|
|
|
// create a new SectionLoadList for the current stop ID, just return the
|
|
|
|
// section load list for the stop ID that is equal to or less than the
|
|
|
|
// current stop ID
|
2013-12-06 09:12:00 +08:00
|
|
|
if (stop_id == eStopIDNow) {
|
2018-05-01 00:49:04 +08:00
|
|
|
// If we are asking for the latest and greatest value, it is always at
|
|
|
|
// the end of our list because that will be the highest stop ID.
|
2013-12-06 09:12:00 +08:00
|
|
|
StopIDToSectionLoadList::reverse_iterator rpos =
|
|
|
|
m_stop_id_to_section_load_list.rbegin();
|
|
|
|
return rpos->second.get();
|
|
|
|
} else {
|
|
|
|
StopIDToSectionLoadList::iterator pos =
|
|
|
|
m_stop_id_to_section_load_list.lower_bound(stop_id);
|
|
|
|
if (pos != m_stop_id_to_section_load_list.end() &&
|
|
|
|
pos->first == stop_id)
|
|
|
|
return pos->second.get();
|
|
|
|
else if (pos != m_stop_id_to_section_load_list.begin()) {
|
|
|
|
--pos;
|
|
|
|
return pos->second.get();
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
} else {
|
2013-12-06 09:12:00 +08:00
|
|
|
// You can only use "eStopIDNow" when reading from the section load
|
|
|
|
// history
|
|
|
|
assert(stop_id != eStopIDNow);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-12-06 09:12:00 +08:00
|
|
|
// We are updating the section load list (not read only), so if the stop
|
2018-05-01 00:49:04 +08:00
|
|
|
// ID passed in isn't the same as the last stop ID in our collection,
|
|
|
|
// then create a new node using the current stop ID
|
2013-12-06 09:12:00 +08:00
|
|
|
StopIDToSectionLoadList::iterator pos =
|
|
|
|
m_stop_id_to_section_load_list.lower_bound(stop_id);
|
|
|
|
if (pos != m_stop_id_to_section_load_list.end() &&
|
|
|
|
pos->first == stop_id) {
|
|
|
|
// We already have an entry for this value
|
|
|
|
return pos->second.get();
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2013-12-06 09:12:00 +08:00
|
|
|
// We must make a new section load list that is based on the last valid
|
|
|
|
// section load list, so here we copy the last section load list and add
|
|
|
|
// a new node for the current stop ID.
|
|
|
|
StopIDToSectionLoadList::reverse_iterator rpos =
|
|
|
|
m_stop_id_to_section_load_list.rbegin();
|
|
|
|
SectionLoadListSP section_load_list_sp(
|
2019-02-12 11:47:39 +08:00
|
|
|
new SectionLoadList(*rpos->second));
|
2013-12-06 09:12:00 +08:00
|
|
|
m_stop_id_to_section_load_list[stop_id] = section_load_list_sp;
|
|
|
|
return section_load_list_sp.get();
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2014-05-15 01:25:00 +08:00
|
|
|
SectionLoadListSP section_load_list_sp(new SectionLoadList());
|
|
|
|
if (stop_id == eStopIDNow)
|
|
|
|
stop_id = 0;
|
|
|
|
m_stop_id_to_section_load_list[stop_id] = section_load_list_sp;
|
|
|
|
return section_load_list_sp.get();
|
2013-12-06 09:12:00 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
SectionLoadList &SectionLoadHistory::GetCurrentSectionLoadList() {
|
|
|
|
const bool read_only = true;
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2013-12-06 09:12:00 +08:00
|
|
|
SectionLoadList *section_load_list =
|
|
|
|
GetSectionLoadListForStopID(eStopIDNow, read_only);
|
[lldb] NFC modernize codebase with modernize-use-nullptr
Summary:
NFC = [[ https://llvm.org/docs/Lexicon.html#nfc | Non functional change ]]
This commit is the result of modernizing the LLDB codebase by using
`nullptr` instread of `0` or `NULL`. See
https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
for more information.
This is the command I ran and I to fix and format the code base:
```
run-clang-tidy.py \
-header-filter='.*' \
-checks='-*,modernize-use-nullptr' \
-fix ~/dev/llvm-project/lldb/.* \
-format \
-style LLVM \
-p ~/llvm-builds/debug-ninja-gcc
```
NOTE: There were also changes to `llvm/utils/unittest` but I did not
include them because I felt that maybe this library shall be updated in
isolation somehow.
NOTE: I know this is a rather large commit but it is a nobrainer in most
parts.
Reviewers: martong, espindola, shafik, #lldb, JDevlieghere
Reviewed By: JDevlieghere
Subscribers: arsenm, jvesely, nhaehnle, hiraditya, JDevlieghere, teemperor, rnkovacs, emaste, kubamracek, nemanjai, ki.stfu, javed.absar, arichardson, kbarton, jrtc27, MaskRay, atanasyan, dexonsmith, arphaman, jfb, jsji, jdoerfert, lldb-commits, llvm-commits
Tags: #lldb, #llvm
Differential Revision: https://reviews.llvm.org/D61847
llvm-svn: 361484
2019-05-23 19:14:47 +08:00
|
|
|
assert(section_load_list != nullptr);
|
2013-12-06 09:12:00 +08:00
|
|
|
return *section_load_list;
|
|
|
|
}
|
|
|
|
|
|
|
|
addr_t
|
|
|
|
SectionLoadHistory::GetSectionLoadAddress(uint32_t stop_id,
|
|
|
|
const lldb::SectionSP §ion_sp) {
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2013-12-06 09:12:00 +08:00
|
|
|
const bool read_only = true;
|
|
|
|
SectionLoadList *section_load_list =
|
|
|
|
GetSectionLoadListForStopID(stop_id, read_only);
|
|
|
|
return section_load_list->GetSectionLoadAddress(section_sp);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SectionLoadHistory::ResolveLoadAddress(uint32_t stop_id, addr_t load_addr,
|
|
|
|
Address &so_addr) {
|
|
|
|
// First find the top level section that this load address exists in
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2013-12-06 09:12:00 +08:00
|
|
|
const bool read_only = true;
|
|
|
|
SectionLoadList *section_load_list =
|
|
|
|
GetSectionLoadListForStopID(stop_id, read_only);
|
|
|
|
return section_load_list->ResolveLoadAddress(load_addr, so_addr);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SectionLoadHistory::SetSectionLoadAddress(
|
|
|
|
uint32_t stop_id, const lldb::SectionSP §ion_sp, addr_t load_addr,
|
|
|
|
bool warn_multiple) {
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2013-12-06 09:12:00 +08:00
|
|
|
const bool read_only = false;
|
|
|
|
SectionLoadList *section_load_list =
|
|
|
|
GetSectionLoadListForStopID(stop_id, read_only);
|
|
|
|
return section_load_list->SetSectionLoadAddress(section_sp, load_addr,
|
|
|
|
warn_multiple);
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t
|
|
|
|
SectionLoadHistory::SetSectionUnloaded(uint32_t stop_id,
|
|
|
|
const lldb::SectionSP §ion_sp) {
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2013-12-06 09:12:00 +08:00
|
|
|
const bool read_only = false;
|
|
|
|
SectionLoadList *section_load_list =
|
|
|
|
GetSectionLoadListForStopID(stop_id, read_only);
|
|
|
|
return section_load_list->SetSectionUnloaded(section_sp);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SectionLoadHistory::SetSectionUnloaded(uint32_t stop_id,
|
|
|
|
const lldb::SectionSP §ion_sp,
|
|
|
|
addr_t load_addr) {
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2013-12-06 09:12:00 +08:00
|
|
|
const bool read_only = false;
|
|
|
|
SectionLoadList *section_load_list =
|
|
|
|
GetSectionLoadListForStopID(stop_id, read_only);
|
|
|
|
return section_load_list->SetSectionUnloaded(section_sp, load_addr);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SectionLoadHistory::Dump(Stream &s, Target *target) {
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2013-12-06 09:12:00 +08:00
|
|
|
StopIDToSectionLoadList::iterator pos,
|
|
|
|
end = m_stop_id_to_section_load_list.end();
|
|
|
|
for (pos = m_stop_id_to_section_load_list.begin(); pos != end; ++pos) {
|
|
|
|
s.Printf("StopID = %u:\n", pos->first);
|
|
|
|
pos->second->Dump(s, target);
|
|
|
|
s.EOL();
|
|
|
|
}
|
|
|
|
}
|