Make node types `struct` instead of `class`
This emphasises that the node types contain no hidden or mutable
state.
PiperOrigin-RevId: 456082057
Change-Id: Ia2ed03d99feac08f97759a8065b92d83d6806dca
diff --git a/stg.cc b/stg.cc
index 42f13d9..1981536 100644
--- a/stg.cc
+++ b/stg.cc
@@ -315,7 +315,7 @@
Name PointerReference::MakeDescription(const Graph& graph,
NameCache& names) const {
std::string sign;
- switch (kind_) {
+ switch (kind) {
case PointerReference::Kind::POINTER:
sign = "*";
break;
@@ -326,31 +326,31 @@
sign = "&&";
break;
}
- return GetDescription(graph, names, pointee_type_id_)
+ return GetDescription(graph, names, pointee_type_id)
.Add(Side::LEFT, Precedence::POINTER, sign);
}
Name Typedef::MakeDescription(const Graph&, NameCache&) const {
- return Name{name_};
+ return Name{name};
}
Name Qualified::MakeDescription(const Graph& graph, NameCache& names) const {
Qualifiers qualifiers;
- qualifiers.insert(qualifier_);
- Id under = qualified_type_id_;
+ qualifiers.insert(qualifier);
+ Id under = qualified_type_id;
while (const auto maybe = graph.Get(under).ResolveQualifier(qualifiers))
under = *maybe;
return GetDescription(graph, names, under).Qualify(qualifiers);
}
Name Integer::MakeDescription(const Graph&, NameCache&) const {
- return Name{name_};
+ return Name{name};
}
Name Array::MakeDescription(const Graph& graph, NameCache& names) const {
std::ostringstream os;
- os << '[' << number_of_elements_ << ']';
- return GetDescription(graph, names, element_type_id_)
+ os << '[' << number_of_elements << ']';
+ return GetDescription(graph, names, element_type_id)
.Add(Side::RIGHT, Precedence::ARRAY_FUNCTION, os.str());
}
@@ -359,23 +359,23 @@
}
Name Member::MakeDescription(const Graph& graph, NameCache& names) const {
- auto description = GetDescription(graph, names, type_id_);
- if (!name_.empty())
- description = description.Add(Side::LEFT, Precedence::ATOMIC, name_);
- if (bitsize_)
+ auto description = GetDescription(graph, names, type_id);
+ if (!name.empty())
+ description = description.Add(Side::LEFT, Precedence::ATOMIC, name);
+ if (bitsize)
description = description.Add(
- Side::RIGHT, Precedence::ATOMIC, " : " + std::to_string(bitsize_));
+ Side::RIGHT, Precedence::ATOMIC, " : " + std::to_string(bitsize));
return description;
}
Name StructUnion::MakeDescription(const Graph& graph, NameCache& names) const {
std::ostringstream os;
- os << kind_ << ' ';
- if (!name_.empty()) {
- os << name_;
- } else if (definition_) {
+ os << kind << ' ';
+ if (!name.empty()) {
+ os << name;
+ } else if (definition) {
os << "{ ";
- for (const auto& member : definition_->members)
+ for (const auto& member : definition->members)
os << GetDescription(graph, names, member) << "; ";
os << '}';
}
@@ -385,11 +385,11 @@
Name Enumeration::MakeDescription(const Graph&, NameCache&) const {
std::ostringstream os;
os << "enum ";
- if (!name_.empty()) {
- os << name_;
- } else if (definition_) {
+ if (!name.empty()) {
+ os << name;
+ } else if (definition) {
os << "{ ";
- for (const auto& e : definition_->enumerators)
+ for (const auto& e : definition->enumerators)
os << e.first << " = " << e.second << ", ";
os << '}';
}
@@ -400,7 +400,7 @@
std::ostringstream os;
os << '(';
bool sep = false;
- for (const auto& p : parameters_) {
+ for (const auto& p : parameters) {
if (sep)
os << ", ";
else
@@ -409,14 +409,14 @@
os << GetDescription(graph, names, p.type_id);
}
os << ')';
- return GetDescription(graph, names, return_type_id_)
+ return GetDescription(graph, names, return_type_id)
.Add(Side::RIGHT, Precedence::ARRAY_FUNCTION, os.str());
}
Name ElfSymbol::MakeDescription(const Graph&, NameCache&) const {
- if (!full_name_ || *full_name_ == symbol_name_)
- return Name{symbol_name_};
- return Name{*full_name_ + " {" + symbol_name_ + "}"};
+ if (!full_name || *full_name == symbol_name)
+ return Name{symbol_name};
+ return Name{*full_name + " {" + symbol_name + "}"};
}
Name Symbols::MakeDescription(const Graph&, NameCache&) const {
@@ -441,12 +441,11 @@
const auto& o = other.as<PointerReference>();
Result result;
- if (kind_ != o.kind_)
+ if (kind != o.kind)
return result.MarkIncomparable();
- const auto ref_diff =
- Compare(state, pointee_type_id_, o.pointee_type_id_);
+ const auto ref_diff = Compare(state, pointee_type_id, o.pointee_type_id);
const auto text =
- kind_ == PointerReference::Kind::POINTER ? "pointed-to" : "referred-to";
+ kind == PointerReference::Kind::POINTER ? "pointed-to" : "referred-to";
result.MaybeAddEdgeDiff(text, ref_diff);
return result;
}
@@ -465,10 +464,10 @@
const auto& o = other.as<Integer>();
Result result;
- result.MaybeAddNodeDiff("encoding", encoding_, o.encoding_);
- result.MaybeAddNodeDiff("bit size", bitsize_, o.bitsize_);
- if (bitsize_ != bytesize_ * 8 && o.bitsize_ != o.bytesize_ * 8)
- result.MaybeAddNodeDiff("byte size", bytesize_, o.bytesize_);
+ result.MaybeAddNodeDiff("encoding", encoding, o.encoding);
+ result.MaybeAddNodeDiff("bit size", bitsize, o.bitsize);
+ if (bitsize != bytesize * 8 && o.bitsize != o.bytesize * 8)
+ result.MaybeAddNodeDiff("byte size", bytesize, o.bytesize);
return result;
}
@@ -477,9 +476,9 @@
Result result;
result.MaybeAddNodeDiff("number of elements",
- number_of_elements_, o.number_of_elements_);
+ number_of_elements, o.number_of_elements);
const auto element_type_diff =
- Compare(state, element_type_id_, o.element_type_id_);
+ Compare(state, element_type_id, o.element_type_id);
result.MaybeAddEdgeDiff("element", element_type_diff);
return result;
}
@@ -571,9 +570,9 @@
const auto& o = other.as<BaseClass>();
Result result;
- result.MaybeAddNodeDiff("inheritance", inheritance_, o.inheritance_);
- result.MaybeAddNodeDiff("offset", offset_, o.offset_);
- const auto sub_diff = Compare(state, type_id_, o.type_id_);
+ result.MaybeAddNodeDiff("inheritance", inheritance, o.inheritance);
+ result.MaybeAddNodeDiff("offset", offset, o.offset);
+ const auto sub_diff = Compare(state, type_id, o.type_id);
result.MaybeAddEdgeDiff("", sub_diff);
return result;
}
@@ -582,9 +581,9 @@
const auto& o = other.as<Member>();
Result result;
- result.MaybeAddNodeDiff("offset", offset_, o.offset_);
- result.MaybeAddNodeDiff("size", bitsize_, o.bitsize_);
- const auto sub_diff = Compare(state, type_id_, o.type_id_);
+ result.MaybeAddNodeDiff("offset", offset, o.offset);
+ result.MaybeAddNodeDiff("size", bitsize, o.bitsize);
+ const auto sub_diff = Compare(state, type_id, o.type_id);
result.MaybeAddEdgeDiff("", sub_diff);
return result;
}
@@ -596,12 +595,12 @@
// Compare two anonymous types recursively, not holding diffs.
// Compare two identically named types recursively, holding diffs.
// Everything else treated as distinct. No recursion.
- if (kind_ != o.kind_ || name_ != o.name_)
+ if (kind != o.kind || name != o.name)
return result.MarkIncomparable();
- result.diff_.holds_changes = !name_.empty();
+ result.diff_.holds_changes = !name.empty();
- const auto& definition1 = definition_;
- const auto& definition2 = o.definition_;
+ const auto& definition1 = definition;
+ const auto& definition2 = o.definition;
if (!CompareDefined(definition1.has_value(), definition2.has_value(), result))
return result;
@@ -621,12 +620,12 @@
// Compare two anonymous types recursively, not holding diffs.
// Compare two identically named types recursively, holding diffs.
// Everything else treated as distinct. No recursion.
- if (name_ != o.name_)
+ if (name != o.name)
return result.MarkIncomparable();
- result.diff_.holds_changes = !name_.empty();
+ result.diff_.holds_changes = !name.empty();
- const auto& definition1 = definition_;
- const auto& definition2 = o.definition_;
+ const auto& definition1 = definition;
+ const auto& definition2 = o.definition;
if (!CompareDefined(definition1.has_value(), definition2.has_value(), result))
return result;
result.MaybeAddNodeDiff(
@@ -672,11 +671,11 @@
Result result;
const auto return_type_diff
- = Compare(state, return_type_id_, o.return_type_id_);
+ = Compare(state, return_type_id, o.return_type_id);
result.MaybeAddEdgeDiff("return", return_type_diff);
- const auto& parameters1 = parameters_;
- const auto& parameters2 = o.parameters_;
+ const auto& parameters1 = parameters;
+ const auto& parameters2 = o.parameters;
size_t min = std::min(parameters1.size(), parameters2.size());
for (size_t i = 0; i < min; ++i) {
const auto& p1 = parameters1.at(i);
@@ -705,7 +704,7 @@
bool added = parameters1.size() < parameters2.size();
const auto& which = added ? o : *this;
- const auto& parameters = which.parameters_;
+ const auto& parameters = which.parameters;
for (size_t i = min; i < parameters.size(); ++i) {
const auto& parameter = parameters.at(i);
std::ostringstream os;
@@ -774,25 +773,25 @@
// Symbol namespaces - not yet supported by symtab_reader
Result result;
- result.MaybeAddNodeDiff("name", symbol_name_, o.symbol_name_);
+ result.MaybeAddNodeDiff("name", symbol_name, o.symbol_name);
- result.MaybeAddNodeDiff("version", version_, o.version_);
+ result.MaybeAddNodeDiff("version", version, o.version);
result.MaybeAddNodeDiff(
- "default version", is_default_version_, o.is_default_version_);
+ "default version", is_default_version, o.is_default_version);
- result.MaybeAddNodeDiff("defined", is_defined_, o.is_defined_);
- result.MaybeAddNodeDiff("symbol type", symbol_type_, o.symbol_type_);
- result.MaybeAddNodeDiff("binding", binding_, o.binding_);
- result.MaybeAddNodeDiff("visibility", visibility_, o.visibility_);
- result.MaybeAddNodeDiff("CRC", crc_, o.crc_);
+ result.MaybeAddNodeDiff("defined", is_defined, o.is_defined);
+ result.MaybeAddNodeDiff("symbol type", symbol_type, o.symbol_type);
+ result.MaybeAddNodeDiff("binding", binding, o.binding);
+ result.MaybeAddNodeDiff("visibility", visibility, o.visibility);
+ result.MaybeAddNodeDiff("CRC", crc, o.crc);
- if (type_id_ && o.type_id_) {
- const auto type_diff = Compare(state, *type_id_, *o.type_id_);
+ if (type_id && o.type_id) {
+ const auto type_diff = Compare(state, *type_id, *o.type_id);
result.MaybeAddEdgeDiff("", type_diff);
- } else if (type_id_) {
- result.AddEdgeDiff("", Removed(state, *type_id_));
- } else if (o.type_id_) {
- result.AddEdgeDiff("", Added(state, *o.type_id_));
+ } else if (type_id) {
+ result.AddEdgeDiff("", Removed(state, *type_id));
+ } else if (o.type_id) {
+ result.AddEdgeDiff("", Added(state, *o.type_id));
} else {
// both types missing, we have nothing to say
}
@@ -811,8 +810,8 @@
std::vector<Id> added;
std::vector<std::pair<Id, Id>> in_both;
- const auto& symbols1 = symbols_;
- const auto& symbols2 = o.symbols_;
+ const auto& symbols1 = symbols;
+ const auto& symbols2 = o.symbols;
auto it1 = symbols1.begin();
auto it2 = symbols2.begin();
const auto end1 = symbols1.end();
@@ -861,8 +860,8 @@
}
std::optional<Id> Qualified::ResolveQualifier(Qualifiers& qualifiers) const {
- qualifiers.insert(qualifier_);
- return {qualified_type_id_};
+ qualifiers.insert(qualifier);
+ return {qualified_type_id};
}
std::optional<Id> Node::ResolveTypedef(std::vector<std::string>&) const {
@@ -871,27 +870,27 @@
std::optional<Id> Typedef::ResolveTypedef(
std::vector<std::string>& typedefs) const {
- typedefs.push_back(name_);
- return {referred_type_id_};
+ typedefs.push_back(name);
+ return {referred_type_id};
}
std::string Node::MatchingKey(const Graph&) const { return {}; }
std::string BaseClass::MatchingKey(const Graph& graph) const {
- return graph.Get(type_id_).MatchingKey(graph);
+ return graph.Get(type_id).MatchingKey(graph);
}
std::string Member::MatchingKey(const Graph& graph) const {
- if (!name_.empty())
- return name_;
- return graph.Get(type_id_).MatchingKey(graph);
+ if (!name.empty())
+ return name;
+ return graph.Get(type_id).MatchingKey(graph);
}
std::string StructUnion::MatchingKey(const Graph& graph) const {
- if (!name_.empty())
- return name_;
- if (definition_) {
- const auto& members = definition_->members;
+ if (!name.empty())
+ return name;
+ if (definition) {
+ const auto& members = definition->members;
for (const auto& member : members) {
const auto recursive = graph.Get(member).MatchingKey(graph);
if (!recursive.empty())
@@ -903,8 +902,8 @@
std::vector<std::pair<std::string, size_t>> Enumeration::GetEnumNames() const {
std::vector<std::pair<std::string, size_t>> names;
- if (definition_) {
- const auto& enums = definition_->enumerators;
+ if (definition) {
+ const auto& enums = definition->enumerators;
const auto size = enums.size();
names.reserve(size);
for (size_t ix = 0; ix < size; ++ix) {
diff --git a/stg.h b/stg.h
index d246715..e5be03f 100644
--- a/stg.h
+++ b/stg.h
@@ -41,7 +41,7 @@
namespace stg {
-class Node;
+struct Node;
template <typename Kind, typename... Args>
std::unique_ptr<Node> Make(Args&&... args) {
@@ -237,8 +237,7 @@
SCC<Comparison, HashComparison> scc;
};
-class Node {
- public:
+struct Node {
virtual ~Node() = default;
// as<Target>() provides a method to delegate downcasting to the base class,
@@ -270,68 +269,57 @@
std::pair<bool, std::optional<Comparison>> Compare(
State& state, Id node1, const Id node2);
-class Void : public Node {
- public:
+struct Void : Node {
Name MakeDescription(const Graph& graph, NameCache& names) const final;
Result Equals(State& state, const Node& other) const final;
};
-class Variadic : public Node {
- public:
+struct Variadic : Node {
Name MakeDescription(const Graph& graph, NameCache& names) const final;
Result Equals(State& state, const Node& other) const final;
};
-class PointerReference : public Node {
- public:
+struct PointerReference : Node {
enum class Kind {
POINTER,
LVALUE_REFERENCE,
RVALUE_REFERENCE,
};
PointerReference(Kind kind, Id pointee_type_id)
- : kind_(kind), pointee_type_id_(pointee_type_id) {}
+ : kind(kind), pointee_type_id(pointee_type_id) {}
Name MakeDescription(const Graph& graph, NameCache& names) const final;
Result Equals(State& state, const Node& other) const final;
- private:
- const Kind kind_;
- const Id pointee_type_id_;
+ const Kind kind;
+ const Id pointee_type_id;
};
std::ostream& operator<<(std::ostream& os, PointerReference::Kind kind);
-class Typedef : public Node {
- public:
+struct Typedef : Node {
Typedef(const std::string& name, Id referred_type_id)
- : name_(name),
- referred_type_id_(referred_type_id) {}
+ : name(name), referred_type_id(referred_type_id) {}
Name MakeDescription(const Graph& graph, NameCache& names) const final;
Result Equals(State& state, const Node& other) const final;
std::optional<Id> ResolveTypedef(
std::vector<std::string>& typedefs) const final;
- private:
- const std::string name_;
- const Id referred_type_id_;
+ const std::string name;
+ const Id referred_type_id;
};
-class Qualified : public Node {
- public:
+struct Qualified : Node {
Qualified(Qualifier qualifier, Id qualified_type_id)
- : qualifier_(qualifier),
- qualified_type_id_(qualified_type_id) {}
+ : qualifier(qualifier), qualified_type_id(qualified_type_id) {}
Name MakeDescription(const Graph& graph, NameCache& names) const final;
Result Equals(State& state, const Node& other) const final;
std::optional<Id> ResolveQualifier(Qualifiers& qualifiers) const final;
- private:
- const Qualifier qualifier_;
- const Id qualified_type_id_;
+ const Qualifier qualifier;
+ const Id qualified_type_id;
};
-class Integer : public Node {
- public:
+struct Integer : Node {
enum class Encoding {
BOOLEAN,
SIGNED_INTEGER,
@@ -342,143 +330,114 @@
};
Integer(const std::string& name, Encoding encoding, uint32_t bitsize,
uint32_t bytesize)
- : name_(name),
- encoding_(encoding),
- bitsize_(bitsize),
- bytesize_(bytesize) {}
+ : name(name), encoding(encoding), bitsize(bitsize), bytesize(bytesize) {}
+
Name MakeDescription(const Graph& graph, NameCache& names) const final;
Result Equals(State& state, const Node& other) const final;
- private:
- const std::string name_;
- const Encoding encoding_;
- // bitsize_ gives the semantics of the field. bytesize_ gives the
- // storage size, and is equal to bitsize_ / 8 rounded up.
- const uint32_t bitsize_;
- const uint32_t bytesize_;
+ const std::string name;
+ const Encoding encoding;
+ // bitsize gives the semantics of the field. bytesize gives the
+ // storage size, and is equal to bitsize / 8 rounded up.
+ const uint32_t bitsize;
+ const uint32_t bytesize;
};
-class Array : public Node {
- public:
- Array(uint64_t number_of_elements,
- Id element_type_id)
- : number_of_elements_(number_of_elements),
- element_type_id_(element_type_id) {}
+struct Array : Node {
+ Array(uint64_t number_of_elements, Id element_type_id)
+ : number_of_elements(number_of_elements),
+ element_type_id(element_type_id) {}
Name MakeDescription(const Graph& graph, NameCache& names) const final;
Result Equals(State& state, const Node& other) const final;
std::optional<Id> ResolveQualifier(Qualifiers& qualifiers) const final;
- private:
- const uint64_t number_of_elements_;
- const Id element_type_id_;
+ const uint64_t number_of_elements;
+ const Id element_type_id;
};
-class BaseClass : public Node {
- public:
+struct BaseClass : Node {
enum class Inheritance { NON_VIRTUAL, VIRTUAL };
BaseClass(Id type_id, uint64_t offset, Inheritance inheritance)
- : type_id_(type_id), offset_(offset), inheritance_(inheritance) {}
+ : type_id(type_id), offset(offset), inheritance(inheritance) {}
std::string GetKindDescription() const final;
Name MakeDescription(const Graph& graph, NameCache& names) const final;
Result Equals(State& state, const Node& other) const final;
std::string MatchingKey(const Graph& graph) const final;
- private:
- const Id type_id_;
- const uint64_t offset_;
- const Inheritance inheritance_;
+ const Id type_id;
+ const uint64_t offset;
+ const Inheritance inheritance;
};
std::ostream& operator<<(std::ostream& os, BaseClass::Inheritance inheritance);
-class Member : public Node {
- public:
+struct Member : Node {
Member(const std::string& name, Id type_id, uint64_t offset, uint64_t bitsize)
- : name_(name),
- type_id_(type_id),
- offset_(offset),
- bitsize_(bitsize) {}
+ : name(name), type_id(type_id), offset(offset), bitsize(bitsize) {}
std::string GetKindDescription() const final;
Name MakeDescription(const Graph& graph, NameCache& names) const final;
Result Equals(State& state, const Node& other) const final;
std::string MatchingKey(const Graph& graph) const final;
- private:
- const std::string name_;
- const Id type_id_;
- const uint64_t offset_;
- const uint64_t bitsize_;
+ const std::string name;
+ const Id type_id;
+ const uint64_t offset;
+ const uint64_t bitsize;
};
-class StructUnion : public Node {
- public:
+struct StructUnion : Node {
enum class Kind { CLASS, STRUCT, UNION };
struct Definition {
const uint64_t bytesize;
const std::vector<Id> base_classes;
const std::vector<Id> members;
};
- StructUnion(Kind kind, const std::string& name)
- : kind_(kind),
- name_(name) {}
- StructUnion(Kind kind, const std::string& name,
- uint64_t bytesize,
+ StructUnion(Kind kind, const std::string& name) : kind(kind), name(name) {}
+ StructUnion(Kind kind, const std::string& name, uint64_t bytesize,
const std::vector<Id>& base_classes,
const std::vector<Id>& members)
- : kind_(kind),
- name_(name),
- definition_({bytesize, base_classes, members}) {}
+ : kind(kind), name(name), definition({bytesize, base_classes, members}) {}
Name MakeDescription(const Graph& graph, NameCache& names) const final;
Result Equals(State& state, const Node& other) const final;
std::string MatchingKey(const Graph& graph) const final;
- private:
- const Kind kind_;
- const std::string name_;
- const std::optional<Definition> definition_;
+ const Kind kind;
+ const std::string name;
+ const std::optional<Definition> definition;
};
std::ostream& operator<<(std::ostream& os, StructUnion::Kind kind);
-class Enumeration : public Node {
- public:
+struct Enumeration : Node {
using Enumerators = std::vector<std::pair<std::string, int64_t>>;
struct Definition {
const uint32_t bytesize;
const Enumerators enumerators;
};
- Enumeration(const std::string& name)
- : name_(name) {}
+ Enumeration(const std::string& name) : name(name) {}
Enumeration(const std::string& name, uint32_t bytesize,
const Enumerators& enumerators)
- : name_(name),
- definition_({bytesize, enumerators}) {}
+ : name(name), definition({bytesize, enumerators}) {}
Name MakeDescription(const Graph& graph, NameCache& names) const final;
Result Equals(State& state, const Node& other) const final;
- private:
std::vector<std::pair<std::string, size_t>> GetEnumNames() const;
- const std::string name_;
- const std::optional<Definition> definition_;
+ const std::string name;
+ const std::optional<Definition> definition;
};
-class Function : public Node {
- public:
- Function(Id return_type_id,
- const std::vector<Parameter>& parameters)
- : return_type_id_(return_type_id),
- parameters_(parameters) {}
+struct Function : Node {
+ Function(Id return_type_id, const std::vector<Parameter>& parameters)
+ : return_type_id(return_type_id), parameters(parameters) {}
Name MakeDescription(const Graph& graph, NameCache& names) const final;
Result Equals(State& state, const Node& other) const final;
std::optional<Id> ResolveQualifier(Qualifiers& qualifiers) const final;
- private:
- const Id return_type_id_;
- const std::vector<Parameter> parameters_;
+ const Id return_type_id;
+ const std::vector<Parameter> parameters;
};
-class ElfSymbol : public Node {
- public:
+struct ElfSymbol : Node {
enum class SymbolType { OBJECT, FUNCTION, COMMON, TLS };
enum class Binding { GLOBAL, LOCAL, WEAK, GNU_UNIQUE };
enum class Visibility { DEFAULT, PROTECTED, HIDDEN, INTERNAL };
@@ -492,47 +451,43 @@
std::optional<CRC> crc,
std::optional<Id> type_id,
const std::optional<std::string>& full_name)
- : symbol_name_(symbol_name),
- version_(version),
- is_default_version_(is_default_version),
- is_defined_(is_defined),
- symbol_type_(symbol_type),
- binding_(binding),
- visibility_(visibility),
- crc_(crc),
- type_id_(type_id),
- full_name_(full_name) {}
+ : symbol_name(symbol_name),
+ version(version),
+ is_default_version(is_default_version),
+ is_defined(is_defined),
+ symbol_type(symbol_type),
+ binding(binding),
+ visibility(visibility),
+ crc(crc),
+ type_id(type_id),
+ full_name(full_name) {}
std::string GetKindDescription() const final;
Name MakeDescription(const Graph& graph, NameCache& names) const final;
Result Equals(State& state, const Node& other) const final;
- private:
- const std::string symbol_name_;
- const std::string version_;
- const bool is_default_version_;
- const bool is_defined_;
- const SymbolType symbol_type_;
- const Binding binding_;
- const Visibility visibility_;
- const std::optional<CRC> crc_;
- const std::optional<Id> type_id_;
- const std::optional<std::string> full_name_;
+ const std::string symbol_name;
+ const std::string version;
+ const bool is_default_version;
+ const bool is_defined;
+ const SymbolType symbol_type;
+ const Binding binding;
+ const Visibility visibility;
+ const std::optional<CRC> crc;
+ const std::optional<Id> type_id;
+ const std::optional<std::string> full_name;
};
std::ostream& operator<<(std::ostream& os, ElfSymbol::SymbolType);
std::ostream& operator<<(std::ostream& os, ElfSymbol::Binding);
std::ostream& operator<<(std::ostream& os, ElfSymbol::Visibility);
-class Symbols : public Node {
- public:
- Symbols(const std::map<std::string, Id>& symbols)
- : symbols_(symbols) {}
+struct Symbols : Node {
+ Symbols(const std::map<std::string, Id>& symbols) : symbols(symbols) {}
std::string GetKindDescription() const final;
Name MakeDescription(const Graph& graph, NameCache& names) const final;
Result Equals(State& state, const Node& other) const final;
- private:
- const std::map<std::string, Id> symbols_;
+ const std::map<std::string, Id> symbols;
};
std::ostream& operator<<(std::ostream& os, Integer::Encoding encoding);
