JakeHillion/object-introspection
1
0
Fork 0
mirror of https://github.com/JakeHillion/object-introspection.git synced 2024-11-13 22:06:55 +00:00
Code Issues Packages Projects Releases Wiki Activity
315a5cde6c
object-introspection/oi/OICodeGen.cpp
Jake Hillion 6e1635ce1e remove oil v1 leftovers
2023-10-30 18:18:13 +00:00

3727 lines
112 KiB
C++
Raw Blame History

/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "oi/OICodeGen.h"
#include <folly/SharedMutex.h>
#include <glog/logging.h>
#include <boost/algorithm/string.hpp>
#include <boost/algorithm/string/join.hpp>
#include <boost/algorithm/string/regex.hpp>
#include <boost/algorithm/string/replace.hpp>
#include <boost/format.hpp>
#include <filesystem>
#include <fstream>
#include <iomanip>
#include <map>
#include <set>
#include <sstream>
#include <unordered_map>
#include <unordered_set>
#include "oi/DrgnUtils.h"
#include "oi/FuncGen.h"
#include "oi/OIParser.h"
#include "oi/PaddingHunter.h"
#include "oi/SymbolService.h"
namespace fs = std::filesystem;
namespace oi::detail {
static size_t g_level = 0;
#undef VLOG
#define VLOG(verboselevel) \
LOG_IF(INFO, VLOG_IS_ON(verboselevel)) << std::string(2 * g_level, ' ')
std::unique_ptr<OICodeGen> OICodeGen::buildFromConfig(const Config& c,
SymbolService& s) {
auto cg = std::unique_ptr<OICodeGen>(new OICodeGen(c, s));
for (const auto& path : c.containerConfigPaths) {
if (!cg->registerContainer(path)) {
LOG(ERROR) << "failed to register container: " << path;
return nullptr;
}
}
return cg;
}
OICodeGen::OICodeGen(const Config& c, SymbolService& s)
: config{c}, symbols{s} {
membersToStub = config.membersToStub;
for (const auto& type : typesToStub) {
membersToStub.emplace_back(type, "*");
}
// `knownTypes` has been made obsolete by the introduction of using the
// `OIInternal` namespace. Instead of deleting all of the related code
// however, for now we just define the `knownTypes` list to be empty, as this
// will make it easier to selectively revert our changes if it turns out that
// there are issues with the new approach.
knownTypes = {"IPAddress", "uintptr_t"};
sizeMap["SharedMutex"] = sizeof(folly::SharedMutex);
}
bool OICodeGen::registerContainer(const fs::path& path) {
VLOG(1) << "registering container, path: " << path;
auto info = ContainerInfo::loadFromFile(path);
if (!info) {
return false;
}
VLOG(1) << "registered container, type: " << info->typeName;
containerInfoList.emplace_back(std::move(info));
return true;
}
bool OICodeGen::isKnownType(const std::string& type) {
std::string matched;
return isKnownType(type, matched);
}
bool OICodeGen::isKnownType(const std::string& type, std::string& matched) {
if (auto it = std::ranges::find(knownTypes, type); it != knownTypes.end()) {
matched = *it;
return true;
}
if (type.rfind("allocator<", 0) == 0 ||
type.rfind("new_allocator<", 0) == 0) {
matched = type;
return true;
}
if (auto opt = isTypeToStub(type)) {
matched = opt.value();
return true;
}
return false;
}
std::optional<const std::string_view> OICodeGen::fullyQualifiedName(
drgn_type* type) {
if (auto entry = fullyQualifiedNames.find(type);
entry != fullyQualifiedNames.end()) {
return entry->second.contents;
}
char* name = nullptr;
size_t length = 0;
auto* err = drgn_type_fully_qualified_name(type, &name, &length);
if (err != nullptr || name == nullptr) {
return std::nullopt;
}
auto typeNamePair =
fullyQualifiedNames.emplace(type, DrgnString{name, length}).first;
return typeNamePair->second.contents;
}
std::optional<std::reference_wrapper<const ContainerInfo>>
OICodeGen::getContainerInfo(drgn_type* type) {
auto name = fullyQualifiedName(type);
if (!name.has_value()) {
return std::nullopt;
}
std::string nameStr = std::string(*name);
for (auto it = containerInfoList.rbegin(); it != containerInfoList.rend();
++it) {
const ContainerInfo& info = **it;
if (std::regex_search(nameStr, info.matcher)) {
return info;
}
}
return std::nullopt;
}
bool OICodeGen::isContainer(drgn_type* type) {
return getContainerInfo(type).has_value();
}
std::string OICodeGen::preProcessUniquePtr(drgn_type* type, std::string name) {
std::string typeName;
std::string deleterName;
size_t end = name.rfind('>') - 1;
size_t pos = end;
size_t begin = 0;
bool found = false;
int unmatchedTemplate = 0;
while (pos > 0) {
if (name[pos] == '>') {
unmatchedTemplate++;
}
if (name[pos] == '<') {
unmatchedTemplate--;
}
if (unmatchedTemplate == 0 && name[pos] == ',') {
begin = pos + 2;
deleterName = name.substr(begin, end - begin + 1);
size_t offset = std::string("unique_ptr<").size();
typeName = name.substr(offset, pos - offset);
found = true;
break;
}
pos--;
}
VLOG(2) << "Deleter name: " << deleterName << " typeName: " << typeName;
if (deleterName.find("default_delete") == std::string::npos && found) {
size_t typeSize = drgn_type_size(type);
constexpr size_t defaultDeleterSize = sizeof(std::unique_ptr<double>);
constexpr size_t cFunctionDeleterSize =
sizeof(std::unique_ptr<double, void (*)(double*)>);
constexpr size_t stdFunctionDeleterSize =
sizeof(std::unique_ptr<double, std::function<void(double*)>>);
if (typeSize == defaultDeleterSize) {
name.replace(begin, end - begin + 1, "default_delete<" + typeName + ">");
} else if (typeSize == cFunctionDeleterSize) {
name.replace(begin, end - begin + 1, "void(*)(" + typeName + "*)");
} else if (typeSize == stdFunctionDeleterSize) {
name.replace(begin, end - begin + 1,
"std::function<void (" + typeName + "*)>");
} else {
LOG(ERROR) << "Unhandled case, unique_ptr size: " << typeSize;
}
}
return name;
}
void OICodeGen::prependQualifiers(enum drgn_qualifiers qualifiers,
std::string& sb) {
// const qualifier is the only one we're interested in
if ((qualifiers & DRGN_QUALIFIER_CONST) != 0) {
sb += "const ";
}
}
void OICodeGen::removeTemplateParamAtIndex(std::vector<std::string>& params,
const size_t index) {
if (index < params.size()) {
params.erase(params.begin() + index);
}
}
std::string OICodeGen::stripFullyQualifiedName(
const std::string& fullyQualifiedName) {
std::vector<std::string> lines;
boost::iter_split(lines, fullyQualifiedName, boost::first_finder("::"));
return lines[lines.size() - 1];
}
std::string OICodeGen::stripFullyQualifiedNameWithSeparators(
const std::string& fullyQualifiedName) {
std::vector<std::string> stack;
std::string sep = " ,<>()";
std::string tmp;
constexpr std::string_view cond = "conditional_t";
constexpr std::string_view stdCond = "std::conditional_t";
static int cond_t_val = 0;
if ((fullyQualifiedName.starts_with(cond)) ||
(fullyQualifiedName.starts_with(stdCond))) {
return "conditional_t_" + std::to_string(cond_t_val++);
}
for (auto& c : fullyQualifiedName) {
if (sep.find(c) == std::string::npos) {
stack.push_back(std::string(1, c));
} else {
tmp = "";
while (!stack.empty() &&
sep.find(stack[stack.size() - 1]) == std::string::npos) {
tmp = stack[stack.size() - 1] + tmp;
stack.pop_back();
}
tmp = stripFullyQualifiedName(tmp);
stack.push_back(tmp);
if (c == '>' || c == ')') {
std::string findStr = (c == '>') ? "<" : "(";
tmp = "";
while (!stack.empty() && stack[stack.size() - 1] != findStr) {
tmp = stack[stack.size() - 1] + tmp;
stack.pop_back();
}
if (stack.empty())
return "";
// Pop the '<' or '('
stack.pop_back();
if (c == '>') {
stack.push_back("<" + tmp + ">");
} else {
stack.push_back("(" + tmp + ")");
}
} else {
stack.push_back(std::string(1, c));
}
}
}
tmp = "";
for (auto& e : stack) {
tmp += e;
}
return tmp;
}
// Replace a specific template parameter with a generic DummySizedOperator
void OICodeGen::replaceTemplateOperator(
TemplateParamList& template_params,
std::vector<std::string>& template_params_strings,
size_t index) {
if (index >= template_params.size()) {
// Should this happen?
return;
}
size_t comparatorSz = 1;
drgn_type* cmpType = template_params[index].first.type;
if (isDrgnSizeComplete(cmpType)) {
comparatorSz = drgn_type_size(cmpType);
} else {
// Don't think there is anyway to accurately get data from the container
}
// Alignment is input to alignas. alignas(0) is supposed to be ignored.
// So we can safely specify that if we can't query the alignment requirement.
size_t alignment = 0;
if (drgn_type_has_members(cmpType) && drgn_type_num_members(cmpType) == 0) {
comparatorSz = 0;
} else {
auto alignmentOpt = getAlignmentRequirements(cmpType);
if (!alignmentOpt.has_value()) {
// Not sure when/if this would happen. Just log for now.
LOG(ERROR) << "Failed to get alignment for " << cmpType;
} else {
alignment = *alignmentOpt / CHAR_BIT;
}
}
template_params_strings[index] = "DummySizedOperator<" +
std::to_string(comparatorSz) + "," +
std::to_string(alignment) + ">";
}
void OICodeGen::replaceTemplateParameters(
drgn_type* type,
TemplateParamList& template_params,
std::vector<std::string>& template_params_strings,
const std::string& nameWithoutTemplate) {
auto optContainerInfo = getContainerInfo(type);
if (!optContainerInfo.has_value()) {
LOG(ERROR) << "Unknown container type: " << nameWithoutTemplate;
return;
}
const ContainerInfo& containerInfo = *optContainerInfo;
// Some containers will need special handling
if (nameWithoutTemplate == "bimap<") {
// TODO: The end parameters seem to be wild cards to pass in things like
// allocator or passing complex relationships between the keys.
removeTemplateParamAtIndex(template_params_strings, 4);
removeTemplateParamAtIndex(template_params_strings, 3);
removeTemplateParamAtIndex(template_params_strings, 2);
} else {
for (auto const& index : containerInfo.replaceTemplateParamIndex) {
replaceTemplateOperator(template_params, template_params_strings, index);
}
if (containerInfo.allocatorIndex) {
removeTemplateParamAtIndex(template_params_strings,
*containerInfo.allocatorIndex);
}
}
}
bool OICodeGen::buildName(drgn_type* type,
std::string& text,
std::string& outName) {
int ptrDepth = 0;
drgn_type* ut = type;
while (drgn_type_kind(ut) == DRGN_TYPE_POINTER) {
ut = drgn_type_type(ut).type;
ptrDepth++;
}
size_t pos = text.find('<');
if (pos == std::string::npos) {
outName = text;
return false;
}
std::string nameWithoutTemplate = text.substr(0, pos + 1);
std::string tmpName;
if (!buildNameInt(ut, nameWithoutTemplate, tmpName)) {
return false;
}
outName = tmpName + std::string(ptrDepth, '*');
return true;
}
bool OICodeGen::buildNameInt(drgn_type* type,
std::string& nameWithoutTemplate,
std::string& outName) {
// Calling buildName only makes sense if a type is a container and has
// template parameters. For a generic template class, we just flatten the
// name into anything reasonable (e.g. Foo<int> becomes Foo_int_).
if (!isContainer(type) || !drgn_type_has_template_parameters(type)) {
return false;
}
size_t numTemplateParams = drgn_type_num_template_parameters(type);
if (numTemplateParams == 0) {
return false;
}
TemplateParamList templateParams;
if (!getTemplateParams(type, numTemplateParams, templateParams)) {
LOG(ERROR) << "Failed to get template params";
return false;
}
if (templateParams.size() == 0) {
LOG(ERROR) << "Template parameters missing";
}
std::vector<std::string> templateParamsStrings;
for (size_t i = 0; i < templateParams.size(); ++i) {
auto& [p, value] = templateParams[i];
enum drgn_qualifiers qualifiers = p.qualifiers;
prependQualifiers(qualifiers, outName);
std::string templateParamName;
if (!value.empty()) {
if (drgn_type_kind(p.type) == DRGN_TYPE_ENUM) {
/*
* We must reference scoped enums by fully-qualified name to keep the
* C++ compiler happy.
*
* i.e. we want to end up with:
* isset_bitset<1,
* apache::thrift::detail::IssetBitsetOption::Unpacked>
*
* If we instead just used the enum's value, we'd instead have:
* isset_bitset<1, 0>
* However, this implicit conversion from an integer is not valid for
* C++ scoped enums.
*
* Unscoped enums (C-style enums) do not need this special treatment as
* they are implicitly convertible to their integral values.
* Conveniently for us, drgn returns them to us as DRGN_TYPE_INT so they
* are not processed here.
*/
// TODO Better handling of this enumVal?
// We converted from a numeric value into a string earlier and now back
// into a numeric value here.
// Does this indexing work correctly for signed-integer-valued enums?
//
// This code only applies to containers with an enum template parameter,
// of which we only currently have one, so I think these problems don't
// matter for now.
auto enumVal = std::stoull(value);
drgn_type_enumerator* enumerators = drgn_type_enumerators(p.type);
templateParamName = *fullyQualifiedName(p.type);
templateParamName += "::";
templateParamName += enumerators[enumVal].name;
} else {
// We can just directly use the value for other literals
templateParamName = value;
}
} else if (auto it = typeToNameMap.find(p.type);
it != typeToNameMap.end()) {
// Use the type's allocated name if it exists
templateParamName = it->second;
} else if (drgn_type_has_tag(p.type)) {
const char* templateParamNameChr = drgn_type_tag(p.type);
if (templateParamNameChr != nullptr) {
templateParamName = std::string(templateParamNameChr);
} else {
return false;
}
} else if (drgn_type_has_name(p.type)) {
const char* templateParamNameChr = drgn_type_name(p.type);
if (templateParamNameChr != nullptr) {
templateParamName = std::string(templateParamNameChr);
} else {
return false;
}
} else if (drgn_type_kind(p.type) == DRGN_TYPE_FUNCTION) {
char* defStr = nullptr;
if (drgn_format_type_name(p, &defStr)) {
LOG(ERROR) << "Failed to get formatted string for " << p.type;
templateParamName = std::string("");
} else {
templateParamName = defStr;
free(defStr);
}
} else if (drgn_type_kind(p.type) == DRGN_TYPE_POINTER) {
char* defStr = nullptr;
if (drgn_format_type_name(p, &defStr)) {
LOG(ERROR) << "Failed to get formatted string for " << p.type;
templateParamName = std::string("");
} else {
drgn_qualified_type underlyingType = drgn_type_type(p.type);
templateParamName = defStr;
free(defStr);
if (drgn_type_kind(underlyingType.type) == DRGN_TYPE_FUNCTION) {
size_t index = templateParamName.find(" ");
if (index != std::string::npos) {
templateParamName = stripFullyQualifiedNameWithSeparators(
templateParamName.substr(0, index + 1)) +
"(*)" +
stripFullyQualifiedNameWithSeparators(
templateParamName.substr(index + 1));
}
}
}
} else if (drgn_type_kind(p.type) == DRGN_TYPE_VOID) {
templateParamName = std::string("void");
} else if (drgn_type_kind(p.type) == DRGN_TYPE_ARRAY) {
size_t elems = 1;
drgn_type* arrayElementType = nullptr;
drgn_utils::getDrgnArrayElementType(p.type, &arrayElementType, elems);
if (drgn_type_has_name(arrayElementType)) {
templateParamName = drgn_type_name(arrayElementType);
} else {
LOG(ERROR) << "Failed4 to get typename ";
return false;
}
} else {
LOG(ERROR) << "Failed3 to get typename ";
return false;
}
// templateParamName = templateTransformType(templateParamName);
templateParamName =
stripFullyQualifiedNameWithSeparators(templateParamName);
std::string recursiveParam;
if (p.type != nullptr &&
buildName(p.type, templateParamName, recursiveParam)) {
templateParamName = recursiveParam;
}
templateParamsStrings.push_back(templateParamName);
}
replaceTemplateParameters(type, templateParams, templateParamsStrings,
nameWithoutTemplate);
outName = nameWithoutTemplate;
for (size_t i = 0; i < templateParamsStrings.size(); ++i) {
auto& [p, value] = templateParams[i];
enum drgn_qualifiers qualifiers = p.qualifiers;
prependQualifiers(qualifiers, outName);
outName += templateParamsStrings[i];
if (i != templateParamsStrings.size() - 1) {
outName += ", ";
} else {
outName += " >";
}
}
return true;
}
bool OICodeGen::getTemplateParams(
drgn_type* type,
size_t numTemplateParams,
std::vector<std::pair<drgn_qualified_type, std::string>>& v) {
drgn_type_template_parameter* tParams = drgn_type_template_parameters(type);
for (size_t i = 0; i < numTemplateParams; ++i) {
const drgn_object* obj = nullptr;
if (auto* err = drgn_template_parameter_object(&tParams[i], &obj);
err != nullptr) {
LOG(ERROR) << "Error when looking up template parameter " << err->code
<< " " << err->message;
drgn_error_destroy(err);
return false;
}
std::string value;
drgn_qualified_type t{};
if (obj == nullptr) {
if (auto* err = drgn_template_parameter_type(&tParams[i], &t);
err != nullptr) {
LOG(ERROR) << "Error when looking up template parameter " << err->code
<< " " << err->message;
drgn_error_destroy(err);
return false;
}
} else {
t.type = obj->type;
t.qualifiers = obj->qualifiers;
if (obj->encoding == DRGN_OBJECT_ENCODING_BUFFER) {
uint64_t size = drgn_object_size(obj);
char* buf = nullptr;
if (size <= sizeof(obj->value.ibuf)) {
buf = (char*)&(obj->value.ibuf);
} else {
buf = obj->value.bufp;
}
if (buf != nullptr) {
value = std::string(buf);
}
} else if (obj->encoding == DRGN_OBJECT_ENCODING_SIGNED) {
value = std::to_string(obj->value.svalue);
} else if (obj->encoding == DRGN_OBJECT_ENCODING_UNSIGNED) {
value = std::to_string(obj->value.uvalue);
} else if (obj->encoding == DRGN_OBJECT_ENCODING_FLOAT) {
value = std::to_string(obj->value.fvalue);
} else {
LOG(ERROR) << "Unsupported OBJ encoding for getting template parameter";
return false;
}
}
v.push_back({t, value});
}
return true;
}
std::string OICodeGen::transformTypeName(drgn_type* type, std::string& text) {
std::string tmp = stripFullyQualifiedNameWithSeparators(text);
boost::regex re{"<typename\\s(\\w+)>"};
std::string fmt{"<typename ::\\1>"};
std::string output = boost::regex_replace(tmp, re, fmt);
std::string buildNameOutput;
if (!buildName(type, text, buildNameOutput)) {
buildNameOutput = output;
}
if (buildNameOutput.starts_with("unique_ptr")) {
buildNameOutput = preProcessUniquePtr(type, buildNameOutput);
}
return buildNameOutput;
}
bool OICodeGen::getContainerTemplateParams(drgn_type* type, bool& ifStub) {
if (containerTypeMapDrgn.find(type) != containerTypeMapDrgn.end()) {
return true;
}
std::string typeName;
if (drgn_type_has_tag(type)) {
typeName = drgn_type_tag(type);
} else if (drgn_type_has_name(type)) {
typeName = drgn_type_name(type);
} else {
LOG(ERROR) << "Failed1 to get typename: kind " << drgnKindStr(type);
return false;
}
typeName = transformTypeName(type, typeName);
auto optContainerInfo = getContainerInfo(type);
if (!optContainerInfo.has_value()) {
LOG(ERROR) << "Unknown container type: " << typeName;
return false;
}
const ContainerInfo& containerInfo = *optContainerInfo;
std::vector<size_t> paramIdxs;
if (containerInfo.underlyingContainerIndex.has_value()) {
if (containerInfo.numTemplateParams.has_value()) {
LOG(ERROR) << "Container adapters should not enumerate their template "
"parameters";
return false;
}
paramIdxs.push_back(*containerInfo.underlyingContainerIndex);
} else {
auto numTemplateParams = containerInfo.numTemplateParams;
if (!numTemplateParams.has_value()) {
if (!drgn_type_has_template_parameters(type)) {
LOG(ERROR) << "Failed to find template params";
return false;
}
numTemplateParams = drgn_type_num_template_parameters(type);
VLOG(1) << "Num template params for " << typeName << " "
<< *numTemplateParams;
}
for (size_t i = 0; i < *numTemplateParams; ++i) {
paramIdxs.push_back(i);
}
}
return enumerateTemplateParamIdxs(type, containerInfo, paramIdxs, ifStub);
}
bool OICodeGen::enumerateTemplateParamIdxs(drgn_type* type,
const ContainerInfo& containerInfo,
const std::vector<size_t>& paramIdxs,
bool& ifStub) {
if (paramIdxs.empty()) {
// Containers such as IOBuf and IOBufQueue don't have template params, but
// still should be added to containerTypeMap
containerTypeMapDrgn.emplace(
type,
std::pair(std::ref(containerInfo), std::vector<drgn_qualified_type>()));
return true;
}
auto maxParamIdx = *std::max_element(paramIdxs.begin(), paramIdxs.end());
if (!drgn_type_has_template_parameters(type) ||
drgn_type_num_template_parameters(type) <= maxParamIdx) {
LOG(ERROR) << "Failed to find template params";
return false;
}
drgn_type_template_parameter* tParams = drgn_type_template_parameters(type);
for (auto i : paramIdxs) {
drgn_qualified_type t{};
if (auto* err = drgn_template_parameter_type(&tParams[i], &t);
err != nullptr) {
LOG(ERROR) << "Error when looking up template parameter " << err->code
<< " " << err->message;
return false;
}
if (drgn_type_kind(t.type) != DRGN_TYPE_VOID &&
!isDrgnSizeComplete(t.type)) {
ifStub = true;
return true;
}
}
for (auto i : paramIdxs) {
drgn_qualified_type t{};
if (auto* err = drgn_template_parameter_type(&tParams[i], &t);
err != nullptr) {
LOG(ERROR) << "Error when looking up template parameter " << err->code
<< " " << err->message;
drgn_error_destroy(err);
return false;
}
// TODO: This is painful, there seems to be a bug in drgn (or maybe it is
// intentional). Consider a case :-
// typedef struct {int a;} A;
// unique_ptr<A> ptr;
//
// If you query template parameter type of unique_ptr<A>, it skips typdefs
// and directly seems to return underlying type i.e. an unnamed struct.
// Unfortunately, we might need special handling for this.
if (!OICodeGen::enumerateTypesRecurse(t.type)) {
return false;
}
}
// Do not add `shared_ptr<void>`, `unique_ptr<void>`, or `weak_ptr<void>`
// to `containerTypeMapDrgn`.
if (containerInfo.ctype == SHRD_PTR_TYPE ||
containerInfo.ctype == UNIQ_PTR_TYPE ||
containerInfo.ctype == WEAK_PTR_TYPE) {
drgn_qualified_type t{};
// We checked that this succeeded in the previous loop
drgn_template_parameter_type(&tParams[0], &t);
if (drgn_type_kind(t.type) == DRGN_TYPE_VOID) {
return true;
}
}
auto& templateTypes =
containerTypeMapDrgn
.emplace(type, std::pair(std::ref(containerInfo),
std::vector<drgn_qualified_type>()))
.first->second.second;
for (auto i : paramIdxs) {
drgn_qualified_type t{};
drgn_error* err = drgn_template_parameter_type(&tParams[i], &t);
if (err) {
LOG(ERROR) << "Error when looking up template parameter " << err->code
<< " " << err->message;
return false;
}
// TODO: Any reason this can't be done in the prior loop. Then
// this loop can be deleted
templateTypes.push_back(t);
}
return true;
}
void OICodeGen::addPaddingForBaseClass(drgn_type* type,
std::vector<std::string>& def) {
if (drgn_type_num_members(type) < 1) {
return;
}
drgn_type_member* members = drgn_type_members(type);
VLOG(2) << "Base member offset is " << members[0].bit_offset / CHAR_BIT;
uint64_t byteOffset = members[0].bit_offset / CHAR_BIT;
if (byteOffset > 0) {
std::string memName =
std::string("__") + "parentClass[" + std::to_string(byteOffset) + "]";
std::string tname = "uint8_t";
def.push_back(tname);
def.push_back(memName);
def.push_back(";");
}
}
std::string_view OICodeGen::drgnKindStr(drgn_type* type) {
switch (drgn_type_kind(type)) {
case DRGN_TYPE_VOID:
return "DRGN_TYPE_VOID";
case DRGN_TYPE_INT:
return "DRGN_TYPE_INT";
case DRGN_TYPE_BOOL:
return "DRGN_TYPE_BOOL";
case DRGN_TYPE_FLOAT:
return "DRGN_TYPE_FLOAT";
case DRGN_TYPE_STRUCT:
return "DRGN_TYPE_STRUCT";
case DRGN_TYPE_UNION:
return "DRGN_TYPE_UNION";
case DRGN_TYPE_CLASS:
return "DRGN_TYPE_CLASS";
case DRGN_TYPE_ENUM:
return "DRGN_TYPE_ENUM";
case DRGN_TYPE_TYPEDEF:
return "DRGN_TYPE_TYPEDEF";
case DRGN_TYPE_POINTER:
return "DRGN_TYPE_POINTER";
case DRGN_TYPE_ARRAY:
return "DRGN_TYPE_ARRAY";
case DRGN_TYPE_FUNCTION:
return "DRGN_TYPE_FUNCTION";
}
return "";
}
std::string OICodeGen::getAnonName(drgn_type* type, const char* template_) {
std::string typeName;
if (drgn_type_tag(type) != nullptr) {
typeName = drgn_type_tag(type);
} else {
// Unnamed struct/union
if (auto it = unnamedUnion.find(type); it != std::end(unnamedUnion)) {
typeName = it->second;
} else {
typeName = template_ + std::to_string(unnamedUnion.size());
unnamedUnion.emplace(type, typeName);
// Leak a copy of the typeName to ensure its lifetime is greater than the
// drgn_type
char* typeNameCstr = new char[typeName.size() + 1];
std::copy(std::begin(typeName), std::end(typeName), typeNameCstr);
typeNameCstr[typeName.size()] = '\0';
type->_private.tag = typeNameCstr;
// We might need a second copy of the string to avoid double-free
type->_private.oi_name = typeNameCstr;
}
}
return transformTypeName(type, typeName);
}
bool OICodeGen::getMemberDefinition(drgn_type* type) {
// Do a [] lookup to ensure `type` has a entry in classMembersMap
// If it has no entry, the lookup will default construct on for us
classMembersMap[type];
structDefType.push_back(type);
std::string outName;
getDrgnTypeNameInt(type, outName);
VLOG(1) << "Adding members to class " << outName << " " << type;
// If the type is a union, don't expand the members
if (drgn_type_kind(type) == DRGN_TYPE_UNION) {
return true;
}
drgn_type_member* members = drgn_type_members(type);
for (size_t i = 0; i < drgn_type_num_members(type); ++i) {
auto& member = members[i];
auto memberName = member.name ? std::string(member.name)
: "__anon_member_" + std::to_string(i);
drgn_qualified_type t{};
uint64_t bitFieldSize = 0;
if (auto* err = drgn_member_type(&member, &t, &bitFieldSize);
err != nullptr) {
LOG(ERROR) << "Error when looking up member type '" << memberName
<< "': (" << err->code << ") " << err->message;
drgn_error_destroy(err);
continue;
}
if (drgn_type_kind(t.type) == DRGN_TYPE_FUNCTION) {
continue;
}
std::string tname;
getDrgnTypeNameInt(t.type, tname);
isKnownType(tname, tname);
bool isStubbed = isMemberToStub(outName, memberName).has_value();
VLOG(2) << "Adding member; type: " << tname << " " << type
<< " name: " << memberName << " offset(bits): " << member.bit_offset
<< " offset(bytes): " << (float)member.bit_offset / (float)CHAR_BIT
<< " isStubbed: " << (isStubbed ? "true" : "false");
classMembersMap[type].push_back(DrgnClassMemberInfo{
t.type, memberName, member.bit_offset, bitFieldSize, isStubbed});
}
return true;
}
std::string OICodeGen::typeToTransformedName(drgn_type* type) {
auto typeName = drgn_utils::typeToName(type);
typeName = transformTypeName(type, typeName);
return typeName;
}
bool OICodeGen::recordChildren(drgn_type* type) {
drgn_type_template_parameter* parents = drgn_type_parents(type);
for (size_t i = 0; i < drgn_type_num_parents(type); i++) {
drgn_qualified_type t{};
if (auto* err = drgn_template_parameter_type(&parents[i], &t);
err != nullptr) {
LOG(ERROR) << "Error when looking up parent class for type " << type
<< " err " << err->code << " " << err->message;
drgn_error_destroy(err);
continue;
}
drgn_type* parent = drgn_utils::underlyingType(t.type);
if (!isDrgnSizeComplete(parent)) {
VLOG(1) << "Incomplete size for parent class (" << drgn_type_tag(parent)
<< ") of " << drgn_type_tag(type);
continue;
}
const char* parentName = drgn_type_tag(parent);
if (parentName == nullptr) {
VLOG(1) << "No name for parent class (" << parent << ") of "
<< drgn_type_tag(type);
continue;
}
/*
* drgn pointers are not stable, so use string representation for reverse
* mapping for now. We need to find a better way of creating this
* childClasses map - ideally drgn would do this for us.
*/
childClasses[parentName].push_back(type);
VLOG(1) << drgn_type_tag(type) << "(" << type << ") is a child of "
<< drgn_type_tag(parent) << "(" << parent << ")";
}
return true;
}
/*
* Build a mapping of Class -> Children
*
* drgn only gives us the mapping Class -> Parents, so we must iterate over all
* types in the program to build the reverse mapping.
*/
bool OICodeGen::enumerateChildClasses() {
if (!feature(Feature::PolymorphicInheritance)) {
return true;
}
if ((setenv("DRGN_ENABLE_TYPE_ITERATOR", "1", 1)) < 0) {
LOG(ERROR)
<< "Could not set DRGN_ENABLE_TYPE_ITERATOR environment variable";
return false;
}
drgn_type_iterator* typesIterator;
auto* prog = symbols.getDrgnProgram();
drgn_error* err = drgn_type_iterator_create(prog, &typesIterator);
if (err) {
LOG(ERROR) << "Error initialising drgn_type_iterator: " << err->code << ", "
<< err->message;
drgn_error_destroy(err);
return false;
}
while (true) {
drgn_qualified_type* t;
err = drgn_type_iterator_next(typesIterator, &t);
if (err) {
LOG(ERROR) << "Error from drgn_type_iterator_next: " << err->code << ", "
<< err->message;
drgn_error_destroy(err);
continue;
}
if (!t) {
break;
}
auto kind = drgn_type_kind(t->type);
if (kind != DRGN_TYPE_CLASS && kind != DRGN_TYPE_STRUCT) {
continue;
}
if (!recordChildren(t->type)) {
return false;
}
}
drgn_type_iterator_destroy(typesIterator);
return true;
}
// The top level function which enumerates the rootType object. This function
// fills out : -
// 1. struct/class definitions
// 2. function forward declarations
// 3. function definitions
//
// They are appended to the jit code in that order (1), (2), (3)
bool OICodeGen::populateDefsAndDecls() {
if (!enumerateChildClasses()) {
return false;
}
if (drgn_type_has_type(rootType.type) &&
drgn_type_kind(rootType.type) == DRGN_TYPE_FUNCTION) {
rootType = drgn_type_type(rootType.type);
}
auto* type = rootType.type;
rootTypeToIntrospect = rootType;
drgn_qualified_type qtype{};
if (drgn_type_kind(type) == DRGN_TYPE_POINTER) {
qtype = drgn_type_type(type);
type = qtype.type;
rootTypeToIntrospect = qtype;
}
auto typeName = typeToTransformedName(type);
if (typeName.empty()) {
return false;
}
if (typeName == "void") {
LOG(ERROR) << "Argument to be introspected cannot be of type void";
return false;
}
rootTypeStr = typeName;
VLOG(1) << "Root type to introspect : " << rootTypeStr;
return enumerateTypesRecurse(rootType.type);
}
std::optional<uint64_t> OICodeGen::getDrgnTypeSize(drgn_type* type) {
uint64_t sz = 0;
if (auto* err = drgn_type_sizeof(type, &sz); err != nullptr) {
LOG(ERROR) << "dgn_type_sizeof(" << type << "): " << err->code << " "
<< err->message;
drgn_error_destroy(err);
auto typeName = getNameForType(type);
if (!typeName.has_value()) {
return std::nullopt;
}
for (auto& e : sizeMap) {
if (typeName->starts_with(e.first)) {
VLOG(1) << "Looked up " << *typeName << " in sizeMap";
return e.second;
}
}
LOG(ERROR) << "Failed to get size for " << *typeName << " " << type;
return std::nullopt;
}
return sz;
}
bool OICodeGen::isDrgnSizeComplete(drgn_type* type) {
uint64_t sz = 0;
if (auto* err = drgn_type_sizeof(type, &sz); err != nullptr) {
drgn_error_destroy(err);
} else {
return true;
}
if (drgn_type_kind(type) != DRGN_TYPE_ENUM) {
std::string name;
getDrgnTypeNameInt(type, name);
for (auto& kv : sizeMap) {
if (name.starts_with(kv.first)) {
return true;
}
}
VLOG(1) << "Failed to lookup size " << type << " " << name;
}
return false;
}
bool OICodeGen::enumerateClassParents(drgn_type* type,
const std::string& typeName) {
if (drgn_type_num_parents(type) == 0) {
// Be careful to early exit here to avoid accidentally initialising
// parentClasses when there are no parents.
return true;
}
drgn_type_template_parameter* parents = drgn_type_parents(type);
for (size_t i = 0; i < drgn_type_num_parents(type); ++i) {
drgn_qualified_type t{};
if (auto* err = drgn_template_parameter_type(&parents[i], &t);
err != nullptr) {
LOG(ERROR) << "Error when looking up parent class for type " << type
<< " err " << err->code << " " << err->message;
drgn_error_destroy(err);
return false;
}
VLOG(2) << "Lookup parent for " << typeName << " " << type;
if (!isDrgnSizeComplete(t.type)) {
VLOG(2) << "Parent of " << typeName << " " << type << " is " << t.type
<< " which is incomplete";
return false;
}
if (!OICodeGen::enumerateTypesRecurse(t.type)) {
return false;
}
parentClasses[type].push_back({t.type, parents[i].bit_offset});
}
std::sort(parentClasses[type].begin(), parentClasses[type].end());
return true;
}
bool OICodeGen::enumerateClassMembers(drgn_type* type,
const std::string& typeName,
bool& isStubbed) {
drgn_type_member* members = drgn_type_members(type);
for (size_t i = 0; i < drgn_type_num_members(type); ++i) {
drgn_qualified_type t{};
auto* err = drgn_member_type(&members[i], &t, nullptr);
if (err != nullptr || !isDrgnSizeComplete(t.type)) {
if (err != nullptr) {
LOG(ERROR) << "Error when looking up member type " << err->code << " "
<< err->message << " " << typeName << " " << members[i].name;
}
VLOG(1) << "Type " << typeName
<< " has an incomplete member; stubbing...";
knownDummyTypeList.insert(type);
isStubbed = true;
return true;
}
std::string memberName;
if (members[i].name != nullptr) {
memberName.assign(members[i].name);
}
if (VLOG_IS_ON(2)) {
std::string outName;
getDrgnTypeNameInt(t.type, outName);
VLOG(2) << "Processing member; type: " << outName << " " << t.type
<< " name: " << memberName;
}
if (!OICodeGen::enumerateTypesRecurse(t.type)) {
return false;
}
}
return true;
}
bool OICodeGen::enumerateClassTemplateParams(drgn_type* type,
const std::string& typeName,
bool& isStubbed) {
bool ifStub = false;
if (!getContainerTemplateParams(type, ifStub)) {
LOG(ERROR) << "Failed to get container template params";
return false;
}
if (ifStub) {
VLOG(1) << "Type " << typeName
<< " has an incomplete size member in template params; stubbing...";
knownDummyTypeList.insert(type);
isStubbed = true;
return true;
}
auto containerInfo = getContainerInfo(type);
assert(containerInfo.has_value());
containerTypesFuncDef.insert(*containerInfo);
return true;
}
bool OICodeGen::ifGenerateMemberDefinition(const std::string& typeName) {
return !isKnownType(typeName);
}
bool OICodeGen::generateMemberDefinition(drgn_type* type,
std::string& typeName) {
if (!getMemberDefinition(type)) {
return false;
}
/* Unnamed type */
if (typeName.empty()) {
if (auto it = unnamedUnion.find(type); it != unnamedUnion.end()) {
typeName = it->second;
} else {
LOG(ERROR) << "Failed to find type in unnamedUnion";
return false;
}
uint64_t sz = 0;
if (auto* err = drgn_type_sizeof(type, &sz); err != nullptr) {
LOG(ERROR) << "Failed to get size: " << err->code << " " << err->message;
drgn_error_destroy(err);
return false;
}
}
return true;
}
std::optional<std::pair<std::string_view, std::string_view>>
OICodeGen::isMemberToStub(const std::string& typeName,
const std::string& member) {
auto it = std::ranges::find_if(membersToStub, [&](auto& s) {
return typeName.starts_with(s.first) && s.second == member;
});
if (it == std::end(membersToStub)) {
return std::nullopt;
}
return *it;
}
std::optional<std::string_view> OICodeGen::isTypeToStub(
const std::string& typeName) {
if (auto opt = isMemberToStub(typeName, "*")) {
return std::ref(opt.value().first);
}
return std::nullopt;
}
bool OICodeGen::isTypeToStub(drgn_type* type, const std::string& typeName) {
if (isTypeToStub(typeName)) {
VLOG(1) << "Found type to stub ";
knownDummyTypeList.insert(type);
return true;
}
return false;
}
bool OICodeGen::isEmptyClassOrFunctionType(drgn_type* type,
const std::string& typeName) {
return (!isKnownType(typeName) && drgn_type_has_members(type) &&
drgn_type_num_members(type) == 0);
}
/*
* Returns true if the provided type represents a dynamic class.
*
* From the Itanium C++ ABI, a dynamic class is defined as:
* A class requiring a virtual table pointer (because it or its bases have
* one or more virtual member functions or virtual base classes).
*/
bool OICodeGen::isDynamic(drgn_type* type) const {
if (!feature(Feature::PolymorphicInheritance) ||
!drgn_type_has_virtuality(type)) {
return false;
}
if (drgn_type_virtuality(type) != 0 /*DW_VIRTUALITY_none*/) {
// Virtual class - not fully supported by OI yet
return true;
}
drgn_type_member_function* functions = drgn_type_functions(type);
for (size_t i = 0; i < drgn_type_num_functions(type); i++) {
drgn_qualified_type t{};
if (auto* err = drgn_member_function_type(&functions[i], &t)) {
LOG(ERROR) << "Error when looking up member function for type " << type
<< " err " << err->code << " " << err->message;
drgn_error_destroy(err);
continue;
}
if (drgn_type_virtuality(t.type) != 0 /*DW_VIRTUALITY_none*/) {
// Virtual function
return true;
}
}
return false;
}
bool OICodeGen::enumerateClassType(drgn_type* type) {
std::string typeName = getStructName(type);
VLOG(2) << "Class name : " << typeName << " " << type;
if (isTypeToStub(type, typeName)) {
return true;
}
if (isKnownType(typeName)) {
funcDefTypeList.insert(type);
return true;
}
if (!isContainer(type)) {
if (!enumerateClassParents(type, typeName)) {
knownDummyTypeList.insert(type);
return true;
}
bool isStubbed = false;
VLOG(2) << "Processing members for class/union : " << typeName << " "
<< type;
if (!enumerateClassMembers(type, typeName, isStubbed)) {
return false;
}
if (isStubbed) {
return true;
}
}
if (isContainer(type)) {
bool isStubbed = false;
VLOG(1) << "Processing template params container: " << typeName << " "
<< type;
if (!enumerateClassTemplateParams(type, typeName, isStubbed)) {
return false;
}
if (isStubbed) {
return true;
}
} else if (ifGenerateMemberDefinition(typeName)) {
if (isDynamic(type)) {
const auto& children = childClasses[drgn_type_tag(type)];
for (const auto& child : children) {
enumerateTypesRecurse(child);
}
}
if (!generateMemberDefinition(type, typeName)) {
return false;
}
} else if (isEmptyClassOrFunctionType(type, typeName)) {
knownDummyTypeList.insert(type);
VLOG(2) << "Empty class/function type " << type << " name " << typeName;
return true;
}
funcDefTypeList.insert(type);
return true;
}
bool OICodeGen::enumerateTypeDefType(drgn_type* type) {
std::string typeName;
if (drgn_type_has_name(type)) {
typeName = drgn_type_name(type);
}
typeName = transformTypeName(type, typeName);
VLOG(2) << "Transformed typename: " << typeName << " " << type;
if (isTypeToStub(type, typeName)) {
return true;
}
if (isKnownType(typeName)) {
funcDefTypeList.insert(type);
return true;
}
auto qtype = drgn_type_type(type);
bool ret = enumerateTypesRecurse(qtype.type);
std::string tname;
if (drgn_type_has_tag(qtype.type)) {
if (drgn_type_tag(qtype.type) != nullptr) {
tname = drgn_type_tag(qtype.type);
} else {
if (drgn_type_kind(qtype.type) == DRGN_TYPE_UNION) {
tname = getUnionName(qtype.type);
} else {
tname = getStructName(qtype.type);
}
typeName = tname;
funcDefTypeList.insert(type);
}
} else if (drgn_type_has_name(qtype.type)) {
tname = drgn_type_name(qtype.type);
} else {
uint64_t sz = 0;
if (auto* err = drgn_type_sizeof(type, &sz); err != nullptr) {
LOG(ERROR) << "Failed to get size: " << err->code << " " << err->message
<< " " << typeName;
drgn_error_destroy(err);
return false;
}
if (sz == sizeof(uintptr_t)) {
// This is a typedef'ed pointer
tname = "uintptr_t";
} else {
LOG(ERROR) << "Failed to get typename: kind " << drgnKindStr(type);
return false;
}
}
typedefMap[typeName] = transformTypeName(qtype.type, tname);
typedefTypes[type] = qtype.type;
return ret;
}
bool OICodeGen::enumerateEnumType(drgn_type* type) {
std::string typeName;
if (drgn_type_tag(type) != nullptr) {
typeName.assign(drgn_type_tag(type));
} else {
typeName = "UNNAMED";
}
if (isKnownType(typeName)) {
return true;
}
std::string enumUnderlyingTypeStr;
if (!getEnumUnderlyingTypeStr(type, enumUnderlyingTypeStr)) {
return false;
}
VLOG(2) << "Converting enum " << enumUnderlyingTypeStr << " " << type
<< " tag: " << typeName;
enumTypes.push_back(type);
funcDefTypeList.insert(type);
return true;
}
static drgn_type* getPtrUnderlyingType(drgn_type* type) {
drgn_type* underlyingType = type;
while (drgn_type_kind(underlyingType) == DRGN_TYPE_POINTER ||
drgn_type_kind(underlyingType) == DRGN_TYPE_TYPEDEF) {
underlyingType = drgn_type_type(underlyingType).type;
}
return underlyingType;
}
bool OICodeGen::enumeratePointerType(drgn_type* type) {
// Not handling pointers right now. Pointer members in classes are going to be
// tricky. If we enumerate objects from pointers there are many questions :-
// 1. How to handle uninitialized pointers
// 2. How to handle nullptr pointers
// 3. How to handle cyclical references with pointers
// Very common for two structs/classes to have pointers to each other
// We will need to save previously encountered pointer values
// 4. Smart pointers might make it easier to detect (1)/(2)
bool ret = true;
drgn_qualified_type qtype = drgn_type_type(type);
funcDefTypeList.insert(type);
// If type is a function pointer, directly store the underlying type in
// pointerToTypeMap, so that TreeBuilder can easily replace function
// pointers with uintptr_t
drgn_type* utype = getPtrUnderlyingType(type);
if (drgn_type_kind(utype) == DRGN_TYPE_FUNCTION) {
VLOG(2) << "Type " << type << " is a function pointer to " << utype;
utype->_private.oi_name = nullptr;
pointerToTypeMap.emplace(type, utype);
return ret;
}
pointerToTypeMap.emplace(type, qtype.type);
drgn_type* underlyingType = drgn_utils::underlyingType(qtype.type);
bool isComplete = isDrgnSizeComplete(underlyingType);
if (drgn_type_kind(underlyingType) == DRGN_TYPE_FUNCTION || isComplete) {
ret = enumerateTypesRecurse(qtype.type);
} else if (!isComplete && drgn_type_kind(underlyingType) != DRGN_TYPE_VOID) {
// If the underlying type is not complete create a stub for the pointer type
knownDummyTypeList.insert(type);
}
return ret;
}
bool OICodeGen::enumeratePrimitiveType(drgn_type* type) {
std::string typeName;
if (!drgn_type_has_name(type)) {
LOG(ERROR) << "Expected type to have a name: " << type;
return false;
}
typeName = drgn_type_name(type);
typeName = transformTypeName(type, typeName);
funcDefTypeList.insert(type);
return true;
}
bool OICodeGen::enumerateArrayType(drgn_type* type) {
uint64_t ret = 0;
if (auto* err = drgn_type_sizeof(type, &ret); err != nullptr) {
LOG(ERROR) << "Error when looking up size from drgn " << err->code << " "
<< err->message << " " << std::endl;
drgn_error_destroy(err);
return false;
}
auto qtype = drgn_type_type(type);
auto rval = enumerateTypesRecurse(qtype.type);
VLOG(1) << "Array type sizeof " << rval << " len " << drgn_type_length(type);
return true;
}
bool OICodeGen::enumerateTypesRecurse(drgn_type* type) {
auto kind = drgn_type_kind(type);
if (kind == DRGN_TYPE_VOID || kind == DRGN_TYPE_FUNCTION) {
VLOG(1) << "Ignore type " << drgnKindStr(type);
return true;
}
// We don't want to generate functions for the same type twice
if (processedTypes.find(type) != processedTypes.end()) {
VLOG(2) << "Already encountered " << type;
return true;
}
std::string outName;
getDrgnTypeNameInt(type, outName);
drgn_qualified_type qtype = {type, {}};
char* defStr = nullptr;
std::string typeDefStr;
if (drgn_format_type(qtype, &defStr) != nullptr) {
LOG(ERROR) << "Failed to get formatted string for " << type;
typeDefStr.assign("unknown");
} else {
typeDefStr.assign(defStr);
free(defStr);
}
VLOG(1) << "START processing type: " << outName << " " << type << " "
<< drgnKindStr(type) << " {";
g_level += 1;
processedTypes.insert(type);
bool ret = true;
switch (kind) {
case DRGN_TYPE_CLASS:
case DRGN_TYPE_STRUCT:
case DRGN_TYPE_UNION:
ret = enumerateClassType(type);
break;
case DRGN_TYPE_ENUM:
ret = enumerateEnumType(type);
break;
case DRGN_TYPE_TYPEDEF:
ret = enumerateTypeDefType(type);
break;
case DRGN_TYPE_POINTER:
ret = enumeratePointerType(type);
break;
case DRGN_TYPE_ARRAY:
enumerateArrayType(type);
break;
case DRGN_TYPE_INT:
case DRGN_TYPE_BOOL:
case DRGN_TYPE_FLOAT:
ret = enumeratePrimitiveType(type);
break;
default:
LOG(ERROR) << "Unknown drgn type " << type;
return false;
}
g_level -= 1;
VLOG(1) << "END processing type: " << outName << " " << type << " "
<< drgnKindStr(type) << " ret:" << ret << " }";
return ret;
}
std::optional<std::string> OICodeGen::getNameForType(drgn_type* type) {
if (auto search = typeToNameMap.find(type); search != typeToNameMap.end()) {
return search->second;
}
LOG(ERROR) << "Failed to find " << type;
return std::nullopt;
}
void OICodeGen::getFuncDefClassMembers(
std::string& code,
drgn_type* type,
std::unordered_map<std::string, int>& memberNames,
bool skipPadding) {
if (drgn_type_kind(type) == DRGN_TYPE_TYPEDEF) {
// Handle case where parent is a typedef
getFuncDefClassMembers(code, drgn_utils::underlyingType(type), memberNames);
return;
}
if (parentClasses.find(type) != parentClasses.end()) {
for (auto& p : parentClasses[type]) {
// paddingIndexMap[type] already cover the parents' paddings,
// so skip the parents' padding generation to avoid double counting
getFuncDefClassMembers(code, p.type, memberNames, true);
}
}
if (classMembersMap.find(type) == classMembersMap.end()) {
return;
}
if (!skipPadding) {
auto paddingIt = paddingIndexMap.find(type);
if (paddingIt != paddingIndexMap.end()) {
const auto& paddingRange = paddingIt->second;
for (auto i = paddingRange.first; i < paddingRange.second; ++i) {
code += "SAVE_SIZE(sizeof(t.__padding_" + std::to_string(i) + "));\n";
}
}
}
const auto& members = classMembersMap[type];
bool captureThriftIsset = thriftIssetStructTypes.contains(type);
if (captureThriftIsset) {
assert(members[members.size() - 1].member_name == "__isset");
auto name = *fullyQualifiedName(type);
code += "using thrift_data = apache::thrift::TStructDataStorage<";
code += name;
code += ">;\n";
}
for (std::size_t i = 0; i < members.size(); ++i) {
if (captureThriftIsset && i < members.size() - 1) {
// Capture Thrift's isset value for each field, except __isset itself,
// which we assume comes last
assert(members[i].member_name != "__isset");
std::string issetIdxStr =
"thrift_data::isset_indexes[" + std::to_string(i) + "]";
code += "{\n";
code += " if (&thrift_data::isset_indexes != nullptr &&\n";
code += " " + issetIdxStr + " != -1) {\n";
code += " SAVE_DATA(t.__isset.get(" + issetIdxStr + "));\n";
code += " } else {\n";
code += " SAVE_DATA(-1);\n";
code += " }\n";
code += "}\n";
}
const auto& member = members[i];
std::string memberName = member.member_name;
std::replace(memberName.begin(), memberName.end(), '.', '_');
deduplicateMemberName(memberNames, memberName);
if (memberName.empty()) {
continue;
}
/*
* Check if the member is a bit field (bitFieldSize > 0).
* If it is a bit field, we can't get its address with operator&.
* If it is *NOT* a bit field, then we can print its address.
*/
if (member.bit_field_size > 0) {
code += "JLOG(\"" + memberName + " (bit_field)\\n\");\n";
} else {
code += "JLOG(\"" + memberName + " @\");\n";
code += "JLOGPTR(&t." + memberName + ");\n";
}
code += "getSizeType(t." + memberName + ", returnArg);\n";
}
}
void OICodeGen::enumerateDescendants(drgn_type* type, drgn_type* baseType) {
auto it = childClasses.find(drgn_type_tag(type));
if (it == childClasses.end()) {
return;
}
// TODO this list may end up containing duplicates
const auto& children = it->second;
descendantClasses[baseType].insert(descendantClasses[baseType].end(),
children.begin(), children.end());
for (const auto& child : children) {
enumerateDescendants(child, baseType);
}
}
void OICodeGen::getFuncDefinitionStr(std::string& code,
drgn_type* type,
const std::string& typeName) {
if (classMembersMap.find(type) == classMembersMap.end()) {
return;
}
std::string funcName = "getSizeType";
if (isDynamic(type)) {
funcName = "getSizeTypeConcrete";
}
code +=
"void " + funcName + "(const " + typeName + "& t, size_t& returnArg) {\n";
std::unordered_map<std::string, int> memberNames;
getFuncDefClassMembers(code, type, memberNames);
code += "}\n";
if (isDynamic(type)) {
enumerateDescendants(type, type);
auto it = descendantClasses.find(type);
if (it == descendantClasses.end()) {
return;
}
const auto& descendants = it->second;
std::vector<std::pair<std::string, SymbolInfo>> concreteClasses;
concreteClasses.reserve(descendants.size());
for (const auto& child : descendants) {
auto fqChildName = *fullyQualifiedName(child);
// We must split this assignment and append because the C++ standard lacks
// an operator for concatenating std::string and std::string_view...
std::string childVtableName = "vtable for ";
childVtableName += fqChildName;
auto optVtableSym = symbols.locateSymbol(childVtableName, true);
if (!optVtableSym) {
LOG(ERROR) << "Failed to find vtable address for '" << childVtableName;
LOG(ERROR) << "Falling back to non dynamic mode";
concreteClasses.clear();
break;
}
auto vtableSym = *optVtableSym;
auto oiChildName = *getNameForType(child);
concreteClasses.push_back({oiChildName, vtableSym});
}
for (const auto& child : concreteClasses) {
const auto& className = child.first;
code += "void getSizeTypeConcrete(const " + className +
"& t, size_t& returnArg);\n";
}
code += std::string("void getSizeType(const ") + typeName +
std::string("& t, size_t& returnArg) {\n");
// The Itanium C++ ABI defines that the vptr must appear at the zero-offset
// position in any class in which they are present.
code += " auto *vptr = *reinterpret_cast<uintptr_t * const *>(&t);\n";
code += " uintptr_t topOffset = *(vptr - 2);\n";
code += " uintptr_t vptrVal = reinterpret_cast<uintptr_t>(vptr);\n";
for (size_t i = 0; i < concreteClasses.size(); i++) {
// The vptr will point to *somewhere* in the vtable of this object's
// concrete class. The exact offset into the vtable can vary based on a
// number of factors, so we compare the vptr against the vtable range for
// each possible class to determine the concrete type.
//
// This works for C++ compilers which follow the GNU v3 ABI, i.e. GCC and
// Clang. Other compilers may differ.
const auto& [className, vtableSym] = concreteClasses[i];
uintptr_t vtableMinAddr = vtableSym.addr;
uintptr_t vtableMaxAddr = vtableSym.addr + vtableSym.size;
code += " if (vptrVal >= 0x" +
(boost::format("%x") % vtableMinAddr).str() + " && vptrVal < 0x" +
(boost::format("%x") % vtableMaxAddr).str() + ") {\n";
code += " SAVE_DATA(" + std::to_string(i) + ");\n";
code +=
" uintptr_t baseAddress = reinterpret_cast<uintptr_t>(&t) + "
"topOffset;\n";
code += " getSizeTypeConcrete(*reinterpret_cast<const " + className +
"*>(baseAddress), returnArg);\n";
code += " return;\n";
code += " }\n";
}
code += " SAVE_DATA(-1);\n";
code += " getSizeTypeConcrete(t, returnArg);\n";
code += "}\n";
}
}
std::string OICodeGen::templateTransformType(const std::string& typeName) {
std::string s;
s.reserve(typeName.size());
for (const auto& c : typeName) {
if (c == '<' || c == '>' || c == ',' || c == ' ' || c == ':' || c == '(' ||
c == ')' || c == '&' || c == '*' || c == '-' || c == '\'' || c == '[' ||
c == ']') {
s += '_';
} else {
s += c;
}
}
return s;
}
std::string OICodeGen::structNameTransformType(const std::string& typeName) {
std::string s;
bool prevColon = false;
s.reserve(typeName.size());
for (const auto& c : typeName) {
if (c == ':') {
if (prevColon) {
prevColon = false;
} else {
prevColon = true;
}
} else {
if (prevColon) {
s[s.size() - 1] = '_';
}
prevColon = false;
}
std::string valid_characters = " &*<>[](){},;:\n";
if (std::isalnum(c) || valid_characters.find(c) != std::string::npos) {
s += c;
} else {
s += '_';
}
}
return s;
}
void OICodeGen::memberTransformName(
std::map<std::string, std::string>& templateTransformMap,
std::string& typeName) {
std::vector<std::string> sortedTypes;
for (auto& e : templateTransformMap) {
sortedTypes.push_back(e.first);
}
std::sort(sortedTypes.begin(), sortedTypes.end(),
[](const std::string& first, const std::string& second) {
return first.size() > second.size();
});
for (auto& e : sortedTypes) {
std::string search = e;
std::string replace = templateTransformMap[e];
boost::replace_all(typeName, search, replace);
}
}
OICodeGen::SortedTypeDefMap OICodeGen::getSortedTypeDefMap(
const std::map<drgn_type*, drgn_type*>& typedefTypeMap) {
auto typeMap = typedefTypeMap;
SortedTypeDefMap typedefVec;
while (!typeMap.empty()) {
for (auto it = typeMap.cbegin(); it != typeMap.cend();) {
if (typeMap.find(it->second) == typeMap.end()) {
typedefVec.push_back(std::make_pair(it->first, it->second));
it = typeMap.erase(it);
} else {
++it;
}
}
}
return typedefVec;
}
bool OICodeGen::getEnumUnderlyingTypeStr(drgn_type* e,
std::string& enumUnderlyingTypeStr) {
std::string name;
if (drgn_type_tag(e) != nullptr) {
name.assign(drgn_type_tag(e));
} else {
VLOG(2) << "Enum tag lookup failed";
}
uint64_t sz = 0;
if (auto* err = drgn_type_sizeof(e, &sz); err != nullptr) {
LOG(ERROR) << "Error when looking up size from drgn " << err->code << " "
<< err->message << " ";
drgn_error_destroy(err);
return false;
}
VLOG(2) << "Enum " << name << " size " << sz;
switch (sz) {
case 8:
enumUnderlyingTypeStr = "uint64_t";
break;
case 4:
enumUnderlyingTypeStr = "uint32_t";
break;
case 2:
enumUnderlyingTypeStr = "uint16_t";
break;
case 1:
enumUnderlyingTypeStr = "uint8_t";
break;
default:
LOG(ERROR) << "Error invalid enum size " << name << " " << sz;
return false;
}
return true;
}
bool OICodeGen::getDrgnTypeNameInt(drgn_type* type, std::string& outName) {
std::string name;
if (drgn_type_kind(type) == DRGN_TYPE_ENUM) {
if (!getEnumUnderlyingTypeStr(type, name)) {
return false;
}
} else if (drgn_type_has_tag(type)) {
if (drgn_type_tag(type) != nullptr) {
name.assign(drgn_type_tag(type));
} else {
if (drgn_type_kind(type) == DRGN_TYPE_UNION) {
name = getUnionName(type);
} else {
name = getStructName(type);
}
}
} else if (drgn_type_has_name(type)) {
name.assign(drgn_type_name(type));
} else if (drgn_type_kind(type) == DRGN_TYPE_POINTER) {
drgn_type* underlyingType = getPtrUnderlyingType(type);
if (feature(Feature::ChaseRawPointers) &&
drgn_type_kind(underlyingType) != DRGN_TYPE_FUNCTION) {
// For pointers, figure out name for the underlying type then add
// appropriate number of '*'
{
int ptrDepth = 0;
drgn_type* ut = type;
while (drgn_type_kind(ut) == DRGN_TYPE_POINTER) {
ut = drgn_type_type(ut).type;
ptrDepth++;
}
std::string tmpName;
if (!getDrgnTypeNameInt(ut, tmpName)) {
LOG(ERROR) << "Failed to get name for type " << type;
return false;
}
outName = tmpName + std::string(ptrDepth, '*');
return true;
}
} else {
name.assign("uintptr_t");
}
} else if (drgn_type_kind(type) == DRGN_TYPE_VOID) {
name.assign("void");
} else {
VLOG(2) << "Failed to get tag/name for type " << type;
return false;
}
name = transformTypeName(type, name);
name = structNameTransformType(name);
outName = name;
return true;
}
bool OICodeGen::getDrgnTypeName(drgn_type* type, std::string& outName) {
return getDrgnTypeNameInt(type, outName);
}
void OICodeGen::addTypeToName(drgn_type* type, std::string name) {
VLOG(2) << "Trying to assign name to type: " << name << " " << type;
if (typeToNameMap.find(type) != typeToNameMap.end()) {
VLOG(2) << "Name already assigned to type: " << name << " " << type;
return;
}
name = structNameTransformType(name);
if (nameToTypeMap.find(name) != nameToTypeMap.end()) {
VLOG(1) << "Name conflict : " << type << " " << name << " "
<< drgnKindStr(type) << " conflict with " << nameToTypeMap[name]
<< " " << drgnKindStr(nameToTypeMap[name]);
if (std::ranges::find(structDefType, type) != structDefType.end() ||
std::ranges::find(enumTypes, type) != enumTypes.end() ||
typedefTypes.find(type) != typedefTypes.end() ||
knownDummyTypeList.find(type) != knownDummyTypeList.end()) {
int tIndex = 0;
// Name clashes with another type. Attach an ID at the end and make sure
// that name isn't already present for some other drgn type.
//
while (nameToTypeMap.find(name + "__" + std::to_string(tIndex)) !=
nameToTypeMap.end()) {
tIndex++;
}
if (name != "uint8_t" && name != "uint32_t" && name != "uintptr_t") {
name = name + "__" + std::to_string(tIndex);
} else {
VLOG(1) << "Not renaming " << name;
}
}
}
VLOG(1) << "Assigned name to type: " << name << " " << type;
typeToNameMap[type] = name;
nameToTypeMap[name] = type;
}
void OICodeGen::getClassMembersIncludingParent(
drgn_type* type, std::vector<DrgnClassMemberInfo>& out) {
if (drgn_type_kind(type) == DRGN_TYPE_TYPEDEF) {
// Handle case where parent is a typedef
getClassMembersIncludingParent(drgn_utils::underlyingType(type), out);
return;
}
if (parentClasses.find(type) != parentClasses.end()) {
for (auto& parent : parentClasses[type]) {
getClassMembersIncludingParent(parent.type, out);
}
}
for (auto& mem : classMembersMap[type]) {
out.push_back(mem);
}
}
std::map<drgn_type*, std::vector<DrgnClassMemberInfo>>&
OICodeGen::getClassMembersMap() {
for (auto& e : classMembersMap) {
std::vector<DrgnClassMemberInfo> v;
getClassMembersIncludingParent(e.first, v);
classMembersMapCopy[e.first] = v;
}
for (auto& e : classMembersMapCopy) {
VLOG(1) << "ClassCopy " << e.first << std::endl;
for (auto& m : e.second) {
VLOG(1) << " " << m.type << " " << m.member_name << std::endl;
}
}
return classMembersMapCopy;
}
// 1. First iterate through structs which we have to define (i.e. structDefType
// and knownDummyTypeList) and apply templateTransformType.
// 2. After that, go through typedefList and while assigning name to type, make
// sure it is transformed (i.e. memberTransformName)
// 3. Do the same for funcDefTypeList
void OICodeGen::printAllTypes() {
VLOG(2) << "Printing all types";
VLOG(2) << "Classes";
for (auto& e : classMembersMap) {
VLOG(2) << "Class " << e.first;
auto& members = e.second;
for (auto& m : members) {
VLOG(2) << " " << m.member_name << " " << m.type;
}
}
VLOG(2) << "Struct defs ";
for (auto& e : structDefType) {
VLOG(2) << "Defined struct " << e;
}
VLOG(2) << "FuncDef structs ";
for (auto& e : funcDefTypeList) {
VLOG(2) << "FuncDef struct " << e;
}
VLOG(2) << "Dummy structs ";
for (const auto& e : knownDummyTypeList) {
VLOG(2) << "Dummy struct " << e;
}
}
void OICodeGen::printAllTypeNames() {
VLOG(2) << "Printing all type names ";
VLOG(2) << "Classes";
for (auto& e : classMembersMap) {
auto typeName = getNameForType(e.first);
if (!typeName.has_value()) {
continue;
}
VLOG(2) << "Class " << *typeName << " " << e.first;
auto& members = e.second;
for (auto& m : members) {
VLOG(2) << " " << m.member_name << " " << m.type;
}
}
for (auto& kv : unnamedUnion) {
VLOG(2) << "Unnamed union/struct " << kv.first << " " << kv.second;
}
VLOG(2) << "Structs defs ";
for (auto& e : structDefType) {
auto typeName = getNameForType(e);
if (!typeName.has_value()) {
continue;
}
VLOG(2) << "Defined struct " << *typeName << " " << e;
}
VLOG(2) << "\nFuncDef structs ";
for (auto& e : funcDefTypeList) {
auto typeName = getNameForType(e);
if (!typeName.has_value()) {
continue;
}
VLOG(2) << "FuncDef struct " << *typeName << " " << e;
}
VLOG(2) << "\nDummy structs ";
for (auto& e : knownDummyTypeList) {
auto typeName = getNameForType(e);
if (!typeName.has_value()) {
continue;
}
VLOG(2) << "Dummy struct " << *typeName << " " << e;
}
}
bool OICodeGen::generateStructDef(drgn_type* e, std::string& code) {
if (classMembersMap.find(e) == classMembersMap.end()) {
LOG(ERROR) << "Failed to find in classMembersMap " << e;
return false;
}
auto kind = drgn_type_kind(e);
if (kind != DRGN_TYPE_STRUCT && kind != DRGN_TYPE_CLASS &&
kind != DRGN_TYPE_UNION) {
LOG(ERROR) << "Failed to read type";
return false;
}
std::string generatedMembers;
PaddingInfo paddingInfo{};
bool violatesAlignmentRequirement = false;
auto tmpStr = getNameForType(e);
if (!tmpStr.has_value()) {
return false;
}
auto sz = getDrgnTypeSize(e);
if (!sz.has_value()) {
return false;
}
VLOG(1) << "Generate members for " << *tmpStr << " " << e << " {";
// paddingIndexMap saves the range of padding indexes used for the current
// struct We save the current pad_index as the start of the range...
auto startingPadIndex = pad_index;
uint64_t offsetBits = 0;
std::unordered_map<std::string, int> memberNames;
if (!generateStructMembers(e, memberNames, generatedMembers, offsetBits,
paddingInfo, violatesAlignmentRequirement, 0)) {
return false;
}
// After the members have been generated, we save the updated pad_index as the
// end of the range
if (startingPadIndex != pad_index) {
[[maybe_unused]] auto [_, paddingInserted] =
paddingIndexMap.emplace(e, std::make_pair(startingPadIndex, pad_index));
assert(paddingInserted);
}
uint64_t offsetBytes = offsetBits / CHAR_BIT;
if (drgn_type_kind(e) != DRGN_TYPE_UNION && *sz != offsetBytes) {
VLOG(1) << "size mismatch " << e << " when generating drgn: " << *sz << " "
<< offsetBytes << " " << *tmpStr;
// Special case when class is empty
if (!(offsetBytes == 0 && *sz == 1)) {
}
} else {
VLOG(2) << "Size matches " << *tmpStr << " " << e << " sz " << *sz
<< " offsetBytes " << offsetBytes;
}
std::string structDefinition;
if (paddingInfo.paddingSize != 0 && feature(Feature::GenPaddingStats)) {
structDefinition.append("/* offset | size */ ");
}
if (kind == DRGN_TYPE_STRUCT || kind == DRGN_TYPE_CLASS) {
structDefinition.append("struct");
} else if (kind == DRGN_TYPE_UNION) {
structDefinition.append("union");
auto alignment = getAlignmentRequirements(e);
if (!alignment.has_value()) {
return false;
}
structDefinition.append(" alignas(" +
std::to_string(*alignment / CHAR_BIT) + ")");
}
if (feature(Feature::PackStructs) &&
(kind == DRGN_TYPE_STRUCT || kind == DRGN_TYPE_CLASS) &&
violatesAlignmentRequirement && paddingInfo.paddingSize == 0) {
structDefinition.append(" __attribute__((__packed__))");
}
structDefinition.append(" ");
structDefinition.append(*tmpStr);
structDefinition.append(" {\n");
if (kind == DRGN_TYPE_UNION) {
// Pad out unions
structDefinition.append("char union_padding[" + std::to_string(*sz) +
"];\n");
} else {
structDefinition.append(generatedMembers);
}
VLOG(1) << "}";
structDefinition.append("};\n");
if (feature(Feature::GenPaddingStats)) {
auto paddedStructFound = paddedStructs.find(*tmpStr);
if (paddedStructFound == paddedStructs.end()) {
if (paddingInfo.paddingSize || paddingInfo.isSetSize) {
paddingInfo.structSize = offsetBytes;
paddingInfo.paddingSize /= CHAR_BIT;
paddingInfo.definition = structDefinition;
paddingInfo.computeSaving();
if (paddingInfo.savingSize > 0) {
paddedStructs.insert({*tmpStr, paddingInfo});
}
}
}
}
code.append(structDefinition);
// In FuncGen add static_assert for sizes from this array
if (drgn_type_kind(e) != DRGN_TYPE_UNION) {
topoSortedStructTypes.push_back(e);
}
return true;
}
bool OICodeGen::isNumMemberGreaterThanZero(drgn_type* type) {
if (drgn_type_num_members(type) > 0) {
return true;
}
if (parentClasses.find(type) != parentClasses.end()) {
for (auto& p : parentClasses[type]) {
auto* underlyingType = drgn_utils::underlyingType(p.type);
if (isNumMemberGreaterThanZero(underlyingType)) {
return true;
}
}
}
return false;
}
bool OICodeGen::addPadding(uint64_t padding_bits, std::string& code) {
if (padding_bits == 0) {
return false;
}
VLOG(1) << "Add padding bits " << padding_bits;
if (padding_bits % CHAR_BIT != 0) {
VLOG(1) << "WARNING: Padding not aligned to a byte";
}
if ((padding_bits / CHAR_BIT) > 0) {
std::ostringstream info;
bool isByteMultiple = padding_bits % CHAR_BIT == 0;
if (isByteMultiple) {
info << "/* XXX" << std::setw(3) << std::right << padding_bits / CHAR_BIT
<< "-byte hole */ ";
} else {
info << "/* XXX" << std::setw(3) << std::right << padding_bits
<< "-bit hole */ ";
}
code.append(info.str());
code.append("char __padding_" + std::to_string(pad_index++) + "[" +
std::to_string(padding_bits / CHAR_BIT) + "];\n");
}
return true;
}
static inline void addSizeComment(bool genPaddingStats,
std::string& code,
size_t offset,
size_t sizeInBits) {
if (!genPaddingStats) {
return;
}
bool isByteMultiple = sizeInBits % CHAR_BIT == 0;
size_t sizeInBytes = (sizeInBits + CHAR_BIT - 1) / CHAR_BIT;
std::ostringstream info;
if (isByteMultiple) {
info << "/* " << std::setw(10) << std::left << offset / CHAR_BIT << "| "
<< std::setw(5) << std::right << sizeInBytes << " */ ";
} else {
info << "/* " << std::setw(4) << std::left << offset / CHAR_BIT
<< ": 0 | " << std::setw(5) << std::right << sizeInBytes << " */ ";
}
code.append(info.str());
}
void OICodeGen::deduplicateMemberName(
std::unordered_map<std::string, int>& memberNames,
std::string& memberName) {
if (!memberName.empty()) {
auto srchRes = memberNames.find(memberName);
if (srchRes == memberNames.end()) {
memberNames[memberName] = 1;
} else {
auto newCurrentIndex = srchRes->second + 1;
srchRes->second = newCurrentIndex;
memberName += std::to_string(newCurrentIndex);
}
}
}
std::optional<uint64_t> OICodeGen::generateMember(
const DrgnClassMemberInfo& m,
std::unordered_map<std::string, int>& memberNames,
uint64_t currOffsetBits,
std::string& code,
bool isInUnion) {
// Generate unique name for member
std::string memberName = m.member_name;
deduplicateMemberName(memberNames, memberName);
std::replace(memberName.begin(), memberName.end(), '.', '_');
auto* memberType = m.type;
auto szBytes = getDrgnTypeSize(memberType);
if (!szBytes.has_value()) {
return std::nullopt;
}
if (m.isStubbed) {
code.append("char ");
code.append(memberName);
code.append("[");
code.append(std::to_string(szBytes.value()));
code.append("]; // Member stubbed per config's membersToStub\n");
return currOffsetBits + 8 * szBytes.value();
}
if (drgn_type_kind(memberType) == DRGN_TYPE_ARRAY) {
// TODO: No idea how to handle flexible array member or zero length array
size_t elems = 1;
drgn_type* arrayElementType = nullptr;
drgn_utils::getDrgnArrayElementType(memberType, &arrayElementType, elems);
auto tmpStr = getNameForType(arrayElementType);
if (!tmpStr.has_value()) {
return std::nullopt;
}
if (elems == 0 || isInUnion) {
std::string memName = memberName + "[" + std::to_string(elems) + "]";
code.append(*tmpStr);
code.append(" ");
code.append(memName);
code.append(";");
code.append("\n");
if (isInUnion) {
currOffsetBits = 0;
VLOG(1) << "Member size: " << *szBytes * CHAR_BIT;
}
} else {
code.append("std::array<");
code.append(*tmpStr);
code.append(", ");
code.append(std::to_string(elems));
code.append("> ");
code.append(memberName);
code.append(";\n");
currOffsetBits = currOffsetBits + (*szBytes * CHAR_BIT);
}
} else {
auto tmpStr = getNameForType(memberType);
uint64_t memberSize = 0;
if (!tmpStr.has_value()) {
return std::nullopt;
}
if (m.bit_field_size > 0) {
memberSize = m.bit_field_size;
} else {
auto drgnTypeSize = getDrgnTypeSize(memberType);
if (!drgnTypeSize.has_value()) {
return false;
}
memberSize = *drgnTypeSize * CHAR_BIT;
}
if (isInUnion) {
currOffsetBits = 0;
VLOG(1) << "Member size: " << memberSize;
} else {
addSizeComment(feature(Feature::GenPaddingStats), code, currOffsetBits,
memberSize);
currOffsetBits = currOffsetBits + memberSize;
}
code.append(*tmpStr);
code.append(" ");
code.append(memberName);
if (m.bit_field_size > 0) {
code.append(":" + std::to_string(m.bit_field_size));
}
code.append(";\n");
}
return currOffsetBits;
}
bool OICodeGen::generateParent(
drgn_type* p,
std::unordered_map<std::string, int>& memberNames,
uint64_t& currOffsetBits,
std::string& code,
size_t offsetToNextMember) {
// Parent class could be a typedef
PaddingInfo paddingInfo{};
bool violatesAlignmentRequirement = false;
auto* underlyingType = drgn_utils::underlyingType(p);
uint64_t offsetBits = 0;
if (!generateStructMembers(underlyingType, memberNames, code, offsetBits,
paddingInfo, violatesAlignmentRequirement,
offsetToNextMember)) {
return false;
}
// *Sigh* account for base class optimization
auto typeSize = getDrgnTypeSize(underlyingType);
if (!typeSize.has_value()) {
return false;
}
if (*typeSize > 1 || isNumMemberGreaterThanZero(underlyingType)) {
currOffsetBits += offsetBits;
} else {
VLOG(1) << "Zero members " << p << " skipping parent class "
<< underlyingType;
}
return true;
}
/*Helper function that returns the alignment constraints in bits*/
std::optional<uint64_t> OICodeGen::getAlignmentRequirements(drgn_type* e) {
const uint64_t minimumAlignmentBits = CHAR_BIT;
uint64_t alignmentRequirement = CHAR_BIT;
std::string outName;
std::optional<uint64_t> typeSize;
switch (drgn_type_kind(e)) {
case DRGN_TYPE_VOID:
case DRGN_TYPE_FUNCTION:
LOG(ERROR) << "Alignment req unhandled " << getDrgnTypeName(e, outName);
return std::nullopt;
case DRGN_TYPE_INT:
case DRGN_TYPE_BOOL:
case DRGN_TYPE_FLOAT:
case DRGN_TYPE_ENUM:
typeSize = getDrgnTypeSize(e);
if (!typeSize.has_value()) {
return std::nullopt;
}
return *typeSize * CHAR_BIT;
case DRGN_TYPE_STRUCT:
case DRGN_TYPE_CLASS:
case DRGN_TYPE_UNION:
if (isContainer(e)) {
alignmentRequirement = 64;
} else {
auto numMembers = drgn_type_num_members(e);
auto* members = drgn_type_members(e);
for (size_t i = 0; i < numMembers; ++i) {
drgn_qualified_type memberType{};
if (drgn_member_type(&members[i], &memberType, nullptr) != nullptr) {
continue;
}
size_t currentMemberAlignmentRequirement =
getAlignmentRequirements(memberType.type)
.value_or(minimumAlignmentBits);
alignmentRequirement =
std::max(alignmentRequirement, currentMemberAlignmentRequirement);
}
for (size_t parentIndex = 0; parentIndex < parentClasses[e].size();
++parentIndex) {
size_t parentAlignment =
getAlignmentRequirements(parentClasses[e][parentIndex].type)
.value_or(minimumAlignmentBits);
alignmentRequirement =
std::max(alignmentRequirement, parentAlignment);
}
}
return alignmentRequirement;
case DRGN_TYPE_POINTER:
return 64;
case DRGN_TYPE_TYPEDEF:
case DRGN_TYPE_ARRAY:
auto* underlyingType = drgn_type_type(e).type;
return getAlignmentRequirements(underlyingType);
}
return minimumAlignmentBits;
}
bool OICodeGen::generateStructMembers(
drgn_type* e,
std::unordered_map<std::string, int>& memberNames,
std::string& code,
uint64_t& out_offset_bits,
PaddingInfo& paddingInfo,
bool& violatesAlignmentRequirement,
size_t offsetToNextMemberInSubclass) {
if (classMembersMap.find(e) == classMembersMap.end()) {
VLOG(1) << "Failed to find type in classMembersMap: " << e;
}
size_t parentIndex = 0;
size_t memberIndex = 0;
auto& members = classMembersMap[e];
uint64_t currOffsetBits = 0;
uint64_t alignmentRequirement = 8;
bool hasParents = (parentClasses.find(e) != parentClasses.end());
do {
uint64_t memberOffsetBits = ULONG_MAX;
if (memberIndex < members.size()) {
memberOffsetBits = members[memberIndex].bit_offset;
}
uint64_t parentOffsetBits = ULONG_MAX;
if (hasParents && parentIndex < parentClasses[e].size()) {
parentOffsetBits = parentClasses[e][parentIndex].bit_offset;
}
if (memberOffsetBits == ULONG_MAX && parentOffsetBits == ULONG_MAX) {
break;
}
// Truncate the typenames while printing. They can be huge.
if (memberOffsetBits < parentOffsetBits) {
std::string typeName;
if (typeToNameMap.find(members[memberIndex].type) !=
typeToNameMap.end()) {
std::optional<std::string> tmpStr =
getNameForType(members[memberIndex].type);
if (!tmpStr.has_value())
return false;
typeName = std::move(*tmpStr);
}
VLOG(1) << "Add class member type: " << typeName.substr(0, 15) << "... "
<< members[memberIndex].type << " currOffset: " << currOffsetBits
<< " expectedOffset: " << memberOffsetBits;
if (drgn_type_kind(e) != DRGN_TYPE_UNION) {
if (currOffsetBits > memberOffsetBits) {
LOG(ERROR) << "Failed to match " << e << " currOffsetBits "
<< currOffsetBits << " memberOffsetBits "
<< memberOffsetBits;
return false;
}
if (addPadding(memberOffsetBits - currOffsetBits, code)) {
paddingInfo.paddingSize += memberOffsetBits - currOffsetBits;
paddingInfo.paddings.push_back(memberOffsetBits - currOffsetBits);
}
currOffsetBits = memberOffsetBits;
}
size_t prevOffsetBits = currOffsetBits;
auto newCurrOffsetBits =
generateMember(members[memberIndex], memberNames, currOffsetBits,
code, drgn_type_kind(e) == DRGN_TYPE_UNION);
if (!newCurrOffsetBits.has_value()) {
return false;
}
currOffsetBits = *newCurrOffsetBits;
// Determine whether this type is a Thrift struct. Only try and read the
// isset values if the struct layout is as expected.
// i.e. __isset must be the last member in the struct
const auto& memberName = members[memberIndex].member_name;
bool isThriftIssetStruct =
typeName.starts_with("isset_bitset<") && memberName == "__isset";
if (feature(Feature::CaptureThriftIsset) && isThriftIssetStruct &&
memberIndex == members.size() - 1) {
thriftIssetStructTypes.insert(e);
}
if (feature(Feature::GenPaddingStats)) {
paddingInfo.isThriftStruct = isThriftIssetStruct;
/*
* Thrift has a __isset member for each field to represent that field
* is "set" or not. One byte is normally used for each field(has
* Unpacked in the name) by using @cpp.PackIsset annotation, we use
* one bit for each field instead (has Packed in the name). We're
* only looking for Unpacked __isset as those are the only ones we can
* optimise
*/
if (paddingInfo.isThriftStruct &&
typeName.find("Unpacked") != std::string::npos) {
size_t unpackedSize = (currOffsetBits - prevOffsetBits) / CHAR_BIT;
size_t packedSize = (unpackedSize + CHAR_BIT - 1) / CHAR_BIT;
size_t savingFromPacking = unpackedSize - packedSize;
if (savingFromPacking > 0) {
paddingInfo.isSetSize = unpackedSize;
paddingInfo.isSetOffset = currOffsetBits / CHAR_BIT;
}
}
}
auto currentMemberAlignmentRequirement =
getAlignmentRequirements(members[memberIndex].type);
if (!currentMemberAlignmentRequirement.has_value()) {
return false;
}
alignmentRequirement =
std::max(alignmentRequirement, *currentMemberAlignmentRequirement);
paddingInfo.alignmentRequirement = alignmentRequirement / CHAR_BIT;
memberIndex++;
} else if (parentOffsetBits < memberOffsetBits) {
std::string typeName;
if (typeToNameMap.find(parentClasses[e][parentIndex].type) !=
typeToNameMap.end()) {
std::optional<std::string> tmpStr =
getNameForType(parentClasses[e][parentIndex].type);
if (!tmpStr.has_value()) {
return false;
}
typeName = std::move(*tmpStr);
typeName.resize(15);
}
VLOG(1) << "Add parent type: " << typeName << "(...) "
<< parentClasses[e][parentIndex].type
<< " currOffset: " << currOffsetBits
<< " expectedOffset: " << parentOffsetBits;
if (currOffsetBits > parentOffsetBits && parentOffsetBits != 0) {
// If a parent is empty, drgn can return parentOffsetBits as 0. So,
// unfortunately, this check needs to be loosened.
LOG(ERROR) << "Failed to match " << e << " currOffsetBits "
<< currOffsetBits << " parentOffsetBits "
<< parentOffsetBits;
return false;
}
if (parentOffsetBits > currOffsetBits) {
addPadding(parentOffsetBits - currOffsetBits, code);
paddingInfo.paddingSize += parentOffsetBits - currOffsetBits;
paddingInfo.paddings.push_back(parentOffsetBits - currOffsetBits);
currOffsetBits = parentOffsetBits;
}
auto parentTypeName = getNameForType(parentClasses[e][parentIndex].type);
if (!parentTypeName.has_value()) {
return false;
}
VLOG(1) << "Generating parent " << *parentTypeName << " "
<< parentClasses[e][parentIndex].type << " {";
g_level += 1;
size_t offsetToNextMember = 0;
if (parentIndex + 1 < parentClasses[e].size()) {
offsetToNextMember = parentClasses[e][parentIndex + 1].bit_offset;
} else {
if (memberOffsetBits != ULONG_MAX) {
offsetToNextMember = memberOffsetBits - currOffsetBits;
} else { // when members.size() == 0
offsetToNextMember = 0;
}
}
if (!generateParent(parentClasses[e][parentIndex].type, memberNames,
currOffsetBits, code, offsetToNextMember)) {
return false;
}
auto currentMemberAlignmentRequirement =
getAlignmentRequirements(parentClasses[e][parentIndex].type);
if (!currentMemberAlignmentRequirement.has_value()) {
return false;
}
alignmentRequirement =
std::max(alignmentRequirement, *currentMemberAlignmentRequirement);
paddingInfo.alignmentRequirement = alignmentRequirement / CHAR_BIT;
g_level -= 1;
VLOG(1) << "}";
parentIndex++;
} else {
// if memberOffsetBits and parentOffsetBits are same, parent class must be
// empty
parentIndex++;
}
} while (true);
auto szBytes = getDrgnTypeSize(e);
if (!szBytes.has_value()) {
return false;
}
if (drgn_type_kind(e) != DRGN_TYPE_UNION &&
// If class is empty, class size is at least one. But don't add the
// explicit padding. It can mess up with inheritance
(*szBytes > 1 || isNumMemberGreaterThanZero(e))) {
uint64_t szBits = (*szBytes * CHAR_BIT);
if (offsetToNextMemberInSubclass && offsetToNextMemberInSubclass < szBits) {
/* We are laying out the members of a parent class*/
szBits = offsetToNextMemberInSubclass;
}
if (currOffsetBits < szBits) {
uint64_t paddingBits = szBits - currOffsetBits;
VLOG(1) << "Add padding to end of struct; curr " << currOffsetBits
<< " sz " << szBits;
addPadding(paddingBits, code);
paddingInfo.paddingSize += paddingBits;
if (paddingInfo.isSetSize == 0) {
/*
* We already account for the unnaligned remainder at the end of a
* struct if the struct has an Unpacked __is_set field. Example from
* PaddingHunter.h:
* if (isThriftStruct) {
* if (isSet_size) {
* saving_size = saving_from_packing();
* odd_sum += isSet_offset - saving_from_packing();
* }
* }
*/
paddingInfo.paddings.push_back(paddingBits);
}
}
currOffsetBits = szBits;
} else if (drgn_type_kind(e) == DRGN_TYPE_UNION) {
currOffsetBits = (*szBytes * CHAR_BIT);
}
if (currOffsetBits % alignmentRequirement != 0) {
violatesAlignmentRequirement = true;
}
VLOG(1) << "Returning " << e << " " << currOffsetBits;
out_offset_bits = currOffsetBits;
return true;
}
bool OICodeGen::generateStructDefs(std::string& code) {
std::vector<drgn_type*> structDefTypeCopy = structDefType;
std::map<drgn_type*, std::vector<ParentMember>> parentClassesCopy =
parentClasses;
while (!structDefTypeCopy.empty()) {
for (auto it = structDefTypeCopy.cbegin();
it != structDefTypeCopy.cend();) {
drgn_type* e = *it;
if (classMembersMap.find(e) == classMembersMap.end()) {
LOG(ERROR) << "Failed to find in classMembersMap " << e;
return false;
}
bool skip = false;
// Make sure that all parent class types are defined
if (parentClassesCopy.find(e) != parentClassesCopy.end()) {
auto& parents = parentClassesCopy[e];
for (auto& p : parents) {
auto it2 = std::find(structDefTypeCopy.begin(),
structDefTypeCopy.end(), p.type);
if (it2 != structDefTypeCopy.cend()) {
skip = true;
break;
}
}
}
// Make sure that all member types are defined
if (!skip) {
auto& members = classMembersMap[e];
for (auto& m : members) {
auto* underlyingType = drgn_utils::underlyingType(m.type);
if (underlyingType != e) {
auto it2 = std::find(structDefTypeCopy.begin(),
structDefTypeCopy.end(), underlyingType);
if (it2 != structDefTypeCopy.cend()) {
skip = true;
break;
}
}
}
}
auto typeName = getNameForType(e);
if (!typeName.has_value()) {
return false;
}
if (skip) {
++it;
VLOG(1) << "Skipping " << *typeName << " " << e;
continue;
} else {
VLOG(1) << "Generating struct " << *typeName << " " << e << " {";
g_level += 1;
if (!generateStructDef(e, code)) {
return false;
}
g_level -= 1;
VLOG(1) << "}";
it = structDefTypeCopy.erase(it);
}
}
}
return true;
}
bool OICodeGen::addStaticAssertsForType(drgn_type* type,
bool generateAssertsForOffsets,
std::string& code) {
auto struct_name = getNameForType(type);
if (!struct_name.has_value()) {
return false;
}
auto sz = getDrgnTypeSize(type);
if (!sz.has_value()) {
return false;
}
std::string assertStr =
"static_assert(sizeof(" + *struct_name + ") == " + std::to_string(*sz);
assertStr += ", \"Unexpected size of struct " + *struct_name + "\");\n";
std::unordered_map<std::string, int> memberNames;
if (generateAssertsForOffsets &&
!staticAssertMemberOffsets(*struct_name, type, assertStr, memberNames)) {
return false;
}
code.append(assertStr);
return true;
}
/*
* Generates a declaration for a given fully-qualified type.
*
* e.g. Given "nsA::nsB::Foo"
*
* The folowing is generated:
* namespace nsA {
* namespace nsB {
* struct Foo;
* } // nsB
* } // nsA
*/
void OICodeGen::declareThriftStruct(std::string& code, std::string_view name) {
if (auto pos = name.find("::"); pos != name.npos) {
auto ns = name.substr(0, pos);
code += "namespace ";
code += ns;
code += " {\n";
// Recurse, continuing from after the "::"
declareThriftStruct(code, name.substr(pos + 2));
code += "} // namespace ";
code += ns;
code += "\n";
} else {
code += "struct ";
code += name;
code += ";\n";
}
}
bool OICodeGen::generateJitCode(std::string& code) {
FuncGen::DeclareExterns(code);
// Include relevant headers
code.append("// relevant header includes -----\n");
// We always generate functions for `std::array` since we transform
// raw C arrays into equivalent instances of `std::array`
// This is kind of hacky and introduces a dependency on `std_array.toml` even
// when people may not expect it.
{
bool found = false;
for (const auto& el : containerInfoList) {
if (el->typeName == "std::array<") {
containerTypesFuncDef.insert(*el);
found = true;
break;
}
}
if (!found) {
LOG(ERROR) << "an implementation for `std::array` is required but none "
"was found";
return false;
}
}
std::set<std::string> includedHeaders = config.defaultHeaders;
for (const ContainerInfo& e : containerTypesFuncDef) {
includedHeaders.insert(e.header);
}
// these headers are included in OITraceCode.cpp
includedHeaders.erase("xmmintrin.h");
includedHeaders.erase("utility");
// Required for the offsetof() macro
includedHeaders.insert("cstddef");
if (config.features[Feature::JitTiming]) {
includedHeaders.emplace("chrono");
}
for (const auto& e : includedHeaders) {
code.append("#include <");
code.append(e);
code.append(">\n");
}
code.append(R"(
// storage macro definitions -----
#define SAVE_SIZE(val)
#define SAVE_DATA(val) StoreData(val, returnArg)
)");
FuncGen::DefineJitLog(code, config.features);
// The purpose of the anonymous namespace within `OIInternal` is that
// anything defined within an anonymous namespace has internal-linkage,
// and therefore won't appear in the symbol table of the resulting object
// file. Both OIL and OID do a linear search through the symbol table for
// the top-level `getSize` function to locate the probe entry point, so
// by keeping the contents of the symbol table to a minimum, we make that
// process faster.
std::string definitionsCode;
definitionsCode.append("namespace OIInternal {\nnamespace {\n");
// Use relevant namespaces
definitionsCode.append("// namespace uses\n");
std::set<std::string> usedNamespaces = config.defaultNamespaces;
for (const ContainerInfo& v : containerTypesFuncDef) {
for (auto& e : v.ns) {
usedNamespaces.insert(std::string(e));
}
}
for (auto& e : usedNamespaces) {
definitionsCode.append("using ");
definitionsCode.append(e);
definitionsCode.append(";\n");
}
printAllTypeNames();
definitionsCode.append("// forward declarations -----\n");
for (auto& e : structDefType) {
if (drgn_type_kind(e) == DRGN_TYPE_STRUCT ||
drgn_type_kind(e) == DRGN_TYPE_CLASS) {
definitionsCode.append("struct");
} else if (drgn_type_kind(e) == DRGN_TYPE_UNION) {
definitionsCode.append("union");
} else {
LOG(ERROR) << "Failed to read type";
return false;
}
definitionsCode.append(" ");
if (typeToNameMap.find(e) == typeToNameMap.end()) {
LOG(ERROR) << "Failed to find " << e << " in typeToNameMap ";
return false;
}
auto typeName = getNameForType(e);
if (!typeName.has_value()) {
return false;
}
definitionsCode.append(typeName.value());
definitionsCode.append(";\n");
}
definitionsCode.append("// stubbed classes -----\n");
for (const auto& e : knownDummyTypeList) {
std::string name;
if (!getDrgnTypeName(e, name)) {
return false;
}
auto typeName = getNameForType(e);
if (!typeName.has_value()) {
return false;
}
uint64_t sz = 0;
if (auto* err = drgn_type_sizeof(e, &sz); err != nullptr) {
bool shouldReturn = false;
std::string knownTypeName;
if (auto opt = isTypeToStub(*typeName)) {
knownTypeName = opt.value();
}
LOG(ERROR) << "Failed to query size from drgn; look in sizeMap "
<< knownTypeName << std::endl;
if (auto it = sizeMap.find(knownTypeName); it != sizeMap.end()) {
sz = it->second;
} else {
LOG(ERROR) << "Failed to get size: " << err->code << " " << err->message
<< " " << e;
shouldReturn = true;
}
drgn_error_destroy(err);
if (shouldReturn) {
return false;
}
}
auto alignment = getAlignmentRequirements(e).value_or(CHAR_BIT) / CHAR_BIT;
if (!isKnownType(name)) {
definitionsCode.append("struct alignas(" + std::to_string(alignment) +
") " + (*typeName) + " { char dummy[" +
std::to_string(sz) + "];};\n");
} else {
if (isTypeToStub(name)) {
definitionsCode.append("struct alignas(" + std::to_string(alignment) +
") " + (*typeName) + " { char dummy[" +
std::to_string(sz) + "];};\n");
}
}
}
definitionsCode.append("// enums -----\n");
for (auto& e : enumTypes) {
auto name = getNameForType(e);
if (!name.has_value()) {
return false;
}
uint64_t sz = 0;
if (auto* err = drgn_type_sizeof(e, &sz); err != nullptr) {
LOG(ERROR) << "Error when looking up size from drgn " << err->code << " "
<< err->message << " ";
drgn_error_destroy(err);
return false;
}
switch (sz) {
case 8:
definitionsCode.append("typedef uint64_t " + *name + ";\n");
break;
case 4:
definitionsCode.append("typedef uint32_t " + *name + ";\n");
break;
case 2:
definitionsCode.append("typedef uint16_t " + *name + ";\n");
break;
case 1:
definitionsCode.append("typedef uint8_t " + *name + ";\n");
break;
default:
LOG(ERROR) << "Error invalid enum size " << *name << " " << sz;
return false;
}
}
// This is basically a topological sort. We need to make sure typedefs
// are defined in the correct order.
auto sortedTypeDefMap = getSortedTypeDefMap(typedefTypes);
definitionsCode.append("// typedefs -----\n");
// Typedefs
for (auto const& e : sortedTypeDefMap) {
auto tmpStr1 = getNameForType(e.first);
auto tmpStr2 = getNameForType(e.second);
if (!tmpStr1.has_value() || !tmpStr2.has_value()) {
return false;
}
definitionsCode.append("typedef " + *tmpStr2 + " " + *tmpStr1 + ";\n");
}
definitionsCode.append("// struct definitions -----\n");
if (!generateStructDefs(definitionsCode)) {
return false;
}
funcGen.DeclareGetContainer(definitionsCode);
definitionsCode.append("}\n\n} // namespace OIInternal\n");
std::string functionsCode;
functionsCode.append("namespace OIInternal {\nnamespace {\n");
functionsCode.append("// functions -----\n");
if (!funcGen.DeclareGetSizeFuncs(functionsCode, containerTypesFuncDef,
config.features)) {
LOG(ERROR) << "declaring get size for containers failed";
return false;
}
if (feature(Feature::ChaseRawPointers)) {
functionsCode.append(R"(
template<typename T>
void getSizeType(const T* t, size_t& returnArg);
void getSizeType(const void *s_ptr, size_t& returnArg);
)");
}
for (auto& e : structDefType) {
if (drgn_type_kind(e) != DRGN_TYPE_UNION) {
auto typeName = getNameForType(e);
if (!typeName.has_value()) {
return false;
}
funcGen.DeclareGetSize(functionsCode, *typeName);
}
}
funcGen.DeclareStoreData(functionsCode);
funcGen.DeclareEncodeData(functionsCode);
funcGen.DeclareEncodeDataSize(functionsCode);
if (!funcGen.DefineGetSizeFuncs(functionsCode, containerTypesFuncDef,
config.features)) {
LOG(ERROR) << "defining get size for containers failed";
return false;
}
if (feature(Feature::ChaseRawPointers)) {
functionsCode.append(R"(
template<typename T>
void getSizeType(const T* s_ptr, size_t& returnArg)
{
JLOG("ptr val @");
JLOGPTR(s_ptr);
StoreData((uintptr_t)(s_ptr), returnArg);
if (s_ptr && pointers.add((uintptr_t)s_ptr)) {
StoreData(1, returnArg);
getSizeType(*(s_ptr), returnArg);
} else {
StoreData(0, returnArg);
}
}
void getSizeType(const void *s_ptr, size_t& returnArg)
{
JLOG("void ptr @");
JLOGPTR(s_ptr);
StoreData((uintptr_t)(s_ptr), returnArg);
}
)");
}
for (auto& e : structDefType) {
auto name = getNameForType(e);
if (!name.has_value()) {
return false;
}
if (name->find("TypedValue") == 0) {
funcGen.DefineGetSizeTypedValueFunc(functionsCode, *name);
} else if (drgn_type_kind(e) != DRGN_TYPE_UNION) {
getFuncDefinitionStr(functionsCode, e, *name);
}
}
funcGen.DefineStoreData(functionsCode);
funcGen.DefineEncodeData(functionsCode);
funcGen.DefineEncodeDataSize(functionsCode);
for (auto& structType : structDefType) {
// Don't generate member offset asserts for unions since we pad them out
bool generateOffsetAsserts =
(drgn_type_kind(structType) != DRGN_TYPE_UNION);
if (!addStaticAssertsForType(structType, generateOffsetAsserts,
functionsCode)) {
return false;
}
}
for (auto& container : containerTypeMapDrgn) {
// Don't generate member offset asserts since we don't unwind containers
if (!addStaticAssertsForType(container.first, false, functionsCode)) {
return false;
}
}
{
auto* type = rootTypeToIntrospect.type;
auto tmpStr = getNameForType(type);
if (!tmpStr.has_value()) {
return false;
}
std::string typeName = *tmpStr;
// The top-level function needs to appear outside the `OIInternal`
// namespace, or otherwise strange relocation issues may occur. We create a
// `typedef` with a known name (`__ROOT_TYPE__`) *inside* the `OIInternal`
// namespace so that we can refer to it from the top-level function without
// having to worry about appropriately referring to types inside the
// `OIInternal` namespace from outside of it, which would involve dealing
// with all the complexities of prepending `OIInternal::` to not just the
// root type but all of its (possible) template parameters.
functionsCode.append("\ntypedef " + typeName + " __ROOT_TYPE__;\n");
functionsCode.append("}\n\n} // namespace OIInternal\n");
/* Start function definitions. First define top level func for root object
*/
auto rawTypeName = drgn_utils::typeToName(type);
if (rootTypeStr.starts_with("unique_ptr") ||
rootTypeStr.starts_with("LowPtr") ||
rootTypeStr.starts_with("shared_ptr")) {
funcGen.DefineTopLevelGetSizeSmartPtr(functionsCode, rawTypeName,
config.features);
} else {
funcGen.DefineTopLevelGetSizeRef(functionsCode, rawTypeName,
config.features);
}
}
// Add definitions for Thrift data storage types.
// This is very brittle, but changes in the Thrift compiler should be caught
// by our integration tests. It might be better to build the definition of
// this struct from the debug info like we do for the types we're probing.
// That would require significant refactoring of CodeGen, however.
std::string thriftDefinitions;
for (const auto& t : thriftIssetStructTypes) {
auto fullyQualified = *fullyQualifiedName(t);
declareThriftStruct(thriftDefinitions, fullyQualified);
thriftDefinitions.append(R"(
namespace apache { namespace thrift {
template <> struct TStructDataStorage<)");
thriftDefinitions.append(fullyQualified);
thriftDefinitions.append(R"(> {
static constexpr const std::size_t fields_size = 1; // Invalid, do not use
static const std::array<folly::StringPiece, fields_size> fields_names;
static const std::array<int16_t, fields_size> fields_ids;
static const std::array<protocol::TType, fields_size> fields_types;
static const std::array<folly::StringPiece, fields_size> storage_names;
static const std::array<int, fields_size> __attribute__((weak)) isset_indexes;
};
}} // namespace thrift, namespace apache
)");
}
code.append(definitionsCode);
code.append(thriftDefinitions);
code.append(functionsCode);
std::ofstream ifs("/tmp/tmp_oid_output_2.cpp");
ifs << code;
ifs.close();
return true;
}
bool OICodeGen::isUnnamedStruct(drgn_type* type) {
return unnamedUnion.find(type) != unnamedUnion.end();
}
bool OICodeGen::generateNamesForTypes() {
std::map<std::string, std::string> templateTransformMap;
printAllTypes();
for (auto& e : structDefType) {
std::string name;
if (!getDrgnTypeName(e, name)) {
return false;
}
std::string tname = templateTransformType(name);
tname = structNameTransformType(tname);
templateTransformMap[name] = tname;
addTypeToName(e, tname);
}
// This sucks, make sure enumTypes are named before typedefTypes
// Otherwise there is a really confusing issue to untangle e.g.
// Assume groupa::groupb::OffendingType is an enum
// using OffendingType = groupa::groupb::OffendingType;
//
// This would result in 2 types a typedef and an enum. Make sure the
// underlying enum is named first.
for (auto& e : enumTypes) {
if (drgn_type_tag(e)) {
std::string name = drgn_type_tag(e);
addTypeToName(e, name);
} else {
static int index = 0;
std::string name = "__unnamed_enum_" + std::to_string(index);
addTypeToName(e, name);
}
}
for (auto& e : typedefTypes) {
std::string name;
if (!getDrgnTypeName(e.first, name)) {
return false;
}
std::string tname = templateTransformType(name);
tname = structNameTransformType(tname);
addTypeToName(e.first, tname);
}
VLOG(1) << "Printing size map";
for (auto& e : sizeMap) {
VLOG(1) << "sizeMap[" << e.first << "] : " << e.second;
}
for (auto& e : knownDummyTypeList) {
std::string name;
if (!getDrgnTypeName(e, name)) {
return false;
}
std::string tname = templateTransformType(name);
if (tname.size() == 0) {
static int index = 0;
tname = "__unnamed_dummy_struct_" + std::to_string(index);
index++;
}
tname = structNameTransformType(tname);
templateTransformMap[name] = tname;
addTypeToName(e, tname);
}
// funcDefTypeList should already include every type in classMembersMap?
// This is rather unfortunate. Assume there is an type which is a pointer to
// another concrete type, e.g. struct Foo and Foo *. If Foo is renamed
// to Foo__0 because of a conflict, the pointer also needs to be renamed to
// Foo__0 *. In the first pass of funcDefTypeList and typedefTypes, assign
// names to all types except pointer types. Then in a second pass assign names
// to pointers (and also handle multiple levels of pointer).
// TODO: Just create a separate list for pointer types. That would avoid
// having to iterate 2 times.
// First pass, ignore pointer types
for (const auto& e : funcDefTypeList) {
if (isUnnamedStruct(e)) {
bool found = false;
for (auto& t : typedefTypes) {
if (t.second == e && drgn_type_kind(t.second) != DRGN_TYPE_ENUM) {
found = true;
break;
}
}
if (found) {
continue;
}
} else if (drgn_type_kind(e) == DRGN_TYPE_POINTER) {
continue;
}
std::string name;
if (!getDrgnTypeName(e, name)) {
return false;
}
memberTransformName(templateTransformMap, name);
addTypeToName(e, name);
}
// First pass, ignore pointer types
for (auto& e : typedefTypes) {
if (isUnnamedStruct(e.second) &&
drgn_type_kind(e.second) != DRGN_TYPE_ENUM) {
} else {
// Apply template transform to only to the type which is already known
// i.e. for "typedef A B", only apply template transform to A
if (drgn_type_kind(e.second) != DRGN_TYPE_POINTER) {
std::string name;
if (!getDrgnTypeName(e.second, name)) {
return false;
}
memberTransformName(templateTransformMap, name);
addTypeToName(e.second, name);
}
}
}
// Second pass, name the pointer types
for (auto& e : funcDefTypeList) {
if (drgn_type_kind(e) == DRGN_TYPE_POINTER) {
int ptrDepth = 0;
drgn_type* ut = e;
while (drgn_type_kind(ut) == DRGN_TYPE_POINTER) {
ut = drgn_type_type(ut).type;
ptrDepth++;
}
auto ut_name = getNameForType(ut);
if (ut_name.has_value()) {
addTypeToName(e, (*ut_name) + std::string(ptrDepth, '*'));
} else {
std::string name;
if (!getDrgnTypeName(e, name)) {
return false;
}
memberTransformName(templateTransformMap, name);
addTypeToName(e, name);
}
}
}
// Second pass, name the pointer types
for (auto& e : typedefTypes) {
if (drgn_type_kind(e.second) == DRGN_TYPE_POINTER) {
int ptrDepth = 0;
drgn_type* ut = e.second;
while (drgn_type_kind(ut) == DRGN_TYPE_POINTER) {
ut = drgn_type_type(ut).type;
ptrDepth++;
}
auto utName = getNameForType(ut);
if (utName.has_value()) {
addTypeToName(e.second, (*utName) + std::string(ptrDepth, '*'));
} else {
std::string name;
if (!getDrgnTypeName(e.second, name)) {
return false;
}
memberTransformName(templateTransformMap, name);
addTypeToName(e.second, name);
}
}
}
{
// TODO: Do we need to apply a template transform to rootType
std::string name;
if (!getDrgnTypeName(rootType.type, name)) {
return false;
}
addTypeToName(rootType.type, name);
}
return true;
}
bool OICodeGen::generate(std::string& code) {
if (!populateDefsAndDecls()) {
return false;
}
if (!generateNamesForTypes()) {
return false;
}
if (!generateJitCode(code)) {
return false;
}
return true;
}
/**
* Generate static_asserts for the offsets of each member of the given type
*/
bool OICodeGen::staticAssertMemberOffsets(
const std::string& struct_name,
drgn_type* struct_type,
std::string& assert_str,
std::unordered_map<std::string, int>& memberNames,
uint64_t base_offset) {
if (knownDummyTypeList.find(struct_type) != knownDummyTypeList.end()) {
return true;
}
if (drgn_type_kind(struct_type) == DRGN_TYPE_TYPEDEF) {
// Operate on the underlying type for typedefs
return staticAssertMemberOffsets(struct_name,
drgn_utils::underlyingType(struct_type),
assert_str, memberNames, base_offset);
}
const auto* tag = drgn_type_tag(struct_type);
if (tag && isContainer(struct_type)) {
// We don't generate members for container types
return true;
}
if (parentClasses.find(struct_type) != parentClasses.end()) {
// Recurse into parents to find inherited members
for (const auto& parent : parentClasses[struct_type]) {
auto parentOffset = base_offset + parent.bit_offset / CHAR_BIT;
if (!staticAssertMemberOffsets(struct_name, parent.type, assert_str,
memberNames, parentOffset)) {
return false;
}
}
}
if (!drgn_type_has_members(struct_type)) {
return true;
}
auto* members = drgn_type_members(struct_type);
for (size_t i = 0; i < drgn_type_num_members(struct_type); ++i) {
if (members[i].name == nullptr) {
// Types can be defined in a class without assigning a member name e.g.
// struct A { struct {int i;} ;}; is a valid struct with size 4.
continue;
}
std::string memberName = members[i].name;
deduplicateMemberName(memberNames, memberName);
std::replace(memberName.begin(), memberName.end(), '.', '_');
drgn_qualified_type memberQualType{};
uint64_t bitFieldSize = 0;
if (auto* err =
drgn_member_type(&members[i], &memberQualType, &bitFieldSize);
err != nullptr) {
LOG(ERROR) << "Error when looking up member type " << err->code << " "
<< err->message << " " << memberName;
drgn_error_destroy(err);
return false;
}
// Can't use "offsetof" on bitfield members
if (bitFieldSize > 0) {
continue;
}
auto expectedOffset = base_offset + members[i].bit_offset / CHAR_BIT;
assert_str += "static_assert(offsetof(" + struct_name + ", " + memberName +
") == " + std::to_string(expectedOffset) +
", \"Unexpected offset of " + struct_name +
"::" + memberName + "\");\n";
}
return true;
}
std::map<std::string, PaddingInfo> OICodeGen::getPaddingInfo() {
return paddedStructs;
}
drgn_qualified_type OICodeGen::getRootType() {
return rootTypeToIntrospect;
};
void OICodeGen::setRootType(drgn_qualified_type rt) {
rootType = rt;
}
TypeHierarchy OICodeGen::getTypeHierarchy() {
std::map<
struct drgn_type*,
std::pair<ContainerTypeEnum, std::vector<struct drgn_qualified_type>>>
containerTypeMap;
for (auto const& [k, v] : containerTypeMapDrgn) {
const ContainerInfo& cinfo = v.first;
containerTypeMap[k] = {cinfo.ctype, v.second};
}
return {
.classMembersMap = getClassMembersMap(),
.containerTypeMap = std::move(containerTypeMap),
.typedefMap = typedefTypes,
.sizeMap = sizeMap,
.knownDummyTypeList = knownDummyTypeList,
.pointerToTypeMap = pointerToTypeMap,
.thriftIssetStructTypes = thriftIssetStructTypes,
.descendantClasses = descendantClasses,
};
}
std::string OICodeGen::Config::toString() const {
using namespace std::string_literals;
// The list of ignored members must also be part of the remote hash
std::string ignoreMembers = "IgnoreMembers=";
for (const auto& ignore : membersToStub) {
ignoreMembers += ignore.first;
ignoreMembers += "::";
ignoreMembers += ignore.second;
ignoreMembers += ';';
}
return boost::algorithm::join(toOptions(), ",") + "," + ignoreMembers;
}
std::vector<std::string> OICodeGen::Config::toOptions() const {
std::vector<std::string> options;
options.reserve(allFeatures.size());
for (const auto f : allFeatures) {
if (features[f]) {
options.emplace_back(std::string("-f") + featureToStr(f));
} else {
options.emplace_back(std::string("-F") + featureToStr(f));
}
}
return options;
}
void OICodeGen::initializeCodeGen() {
LOG(WARNING) << "OICodeGen::initializeCodeGen is no longer necessary";
};
} // namespace oi::detail
Reference in New Issue View Git Blame Copy Permalink