TypeGraph: Support bitfields

- Change member and parent offsets to work in bits, not bytes
- Printer still displays offsets in bytes, with decimals when using
  bitfields
- AddPadding: Don't pad bitfields
- CodeGen: Emit code for bitfields

Author: ajor

oi/CodeGen.cpp

@@ -247,7 +247,11 @@ void genDefsClass(const Class& c, std::string& code) {
 
   code += c.name() + " {\n";
   for (const auto& mem : c.members) {
-    code += "  " + mem.type->name() + " " + mem.name + ";\n";
+    code += "  " + mem.type->name() + " " + mem.name;
+    if (mem.bitsize) {
+      code += " : " + std::to_string(mem.bitsize);
+    }
+    code += ";\n";
   }
   code += "};\n\n";
 }
@@ -271,8 +275,10 @@ void genStaticAssertsClass(const Class& c, std::string& code) {
           ") == " + std::to_string(c.size()) +
           ", \"Unexpected size of struct " + c.name() + "\");\n";
   for (const auto& member : c.members) {
+    if (member.bitsize > 0)
+      continue;
     code += "static_assert(offsetof(" + c.name() + ", " + member.name +
-            ") == " + std::to_string(member.offset) +
+            ") == " + std::to_string(member.bitOffset / 8) +
             ", \"Unexpected offset of " + c.name() + "::" + member.name +
             "\");\n";
   }
@@ -407,7 +413,8 @@ void CodeGen::getClassSizeFuncConcrete(std::string_view funcName,
     }
 
     code += "  JLOG(\"" + member.name + " @\");\n";
-    code += "  JLOGPTR(&t." + member.name + ");\n";
+    if (member.bitsize == 0)
+      code += "  JLOGPTR(&t." + member.name + ");\n";
     code += "  getSizeType(t." + member.name + ", returnArg);\n";
   }
   code += "}\n";

oi/type_graph/AddPadding.cpp

@@ -65,13 +65,13 @@ void AddPadding::visit(Class& c) {
   paddedMembers.reserve(c.members.size());
   for (size_t i = 0; i < c.members.size(); i++) {
     if (i >= 1) {
-      addPadding(c.members[i - 1], c.members[i].offset, paddedMembers);
+      addPadding(c.members[i - 1], c.members[i].bitOffset, paddedMembers);
     }
     paddedMembers.push_back(c.members[i]);
   }
 
   if (!c.members.empty()) {
-    addPadding(c.members.back(), c.size(), paddedMembers);
+    addPadding(c.members.back(), c.size() * 8, paddedMembers);
   }
 
   c.members = std::move(paddedMembers);
@@ -82,16 +82,32 @@ void AddPadding::visit(Class& c) {
 }
 
 void AddPadding::addPadding(const Member& prevMember,
-                            uint64_t paddingEnd,
+                            uint64_t paddingEndBits,
                             std::vector<Member>& paddedMembers) {
-  uint64_t prevMemberEnd = prevMember.offset + prevMember.type->size();
-  uint64_t padding = paddingEnd - prevMemberEnd;
-  if (padding == 0)
+  uint64_t prevMemberSizeBits;
+  if (prevMember.bitsize == 0) {
+    prevMemberSizeBits = prevMember.type->size() * 8;
+  } else {
+    prevMemberSizeBits = prevMember.bitsize;
+  }
+
+  uint64_t prevMemberEndBits = prevMember.bitOffset + prevMemberSizeBits;
+  uint64_t paddingBits = paddingEndBits - prevMemberEndBits;
+  if (paddingBits == 0)
     return;
 
-  auto* primitive = typeGraph_.make_type<Primitive>(Primitive::Kind::Int8);
-  auto* paddingArray = typeGraph_.make_type<Array>(primitive, padding);
-  paddedMembers.emplace_back(paddingArray, MemberPrefix, prevMemberEnd);
+  if (paddingBits % 8 == 0) {
+    // Pad with an array of bytes
+    auto* primitive = typeGraph_.make_type<Primitive>(Primitive::Kind::Int8);
+    auto* paddingArray =
+        typeGraph_.make_type<Array>(primitive, paddingBits / 8);
+    paddedMembers.emplace_back(paddingArray, MemberPrefix, prevMemberEndBits);
+  } else {
+    // Pad with a bitfield
+    auto* primitive = typeGraph_.make_type<Primitive>(Primitive::Kind::Int64);
+    paddedMembers.emplace_back(primitive, MemberPrefix, prevMemberEndBits,
+                               paddingBits);
+  }
 }
 
 }  // namespace type_graph

oi/type_graph/AddPadding.h

@@ -45,7 +45,7 @@ class AddPadding final : public RecursiveVisitor {
   void visit(Type& type) override;
   void visit(Class& c) override;
 
-  static const inline std::string MemberPrefix = "__oid_padding";
+  static const inline std::string MemberPrefix = "__oi_padding";
 
  private:
   std::unordered_set<Type*> visited_;

oi/type_graph/DrgnParser.cpp

@@ -212,13 +212,14 @@ void DrgnParser::enumerateClassParents(struct drgn_type* type,
     }
 
     auto ptype = enumerateType(parent_qual_type.type);
-    uint64_t poffset = drgn_parents[i].bit_offset / 8;
+    uint64_t poffset = drgn_parents[i].bit_offset;
     Parent p(ptype, poffset);
     parents.push_back(p);
   }
 
-  std::sort(parents.begin(), parents.end(),
-            [](const auto& a, const auto& b) { return a.offset < b.offset; });
+  std::sort(parents.begin(), parents.end(), [](const auto& a, const auto& b) {
+    return a.bitOffset < b.bitOffset;
+  });
 }
 
 void DrgnParser::enumerateClassMembers(struct drgn_type* type,
@@ -257,17 +258,16 @@ void DrgnParser::enumerateClassMembers(struct drgn_type* type,
     if (drgn_members[i].name)
       member_name = drgn_members[i].name;
 
-    // TODO bitfields
-
     auto mtype = enumerateType(member_type);
-    uint64_t moffset = drgn_members[i].bit_offset / 8;
+    uint64_t moffset = drgn_members[i].bit_offset;
 
-    Member m(mtype, member_name, moffset);  // TODO
+    Member m{mtype, member_name, moffset, bit_field_size};
     members.push_back(m);
   }
 
-  std::sort(members.begin(), members.end(),
-            [](const auto& a, const auto& b) { return a.offset < b.offset; });
+  std::sort(members.begin(), members.end(), [](const auto& a, const auto& b) {
+    return a.bitOffset < b.bitOffset;
+  });
 }
 
 void DrgnParser::enumerateTemplateParam(drgn_type_template_parameter* tparams,

oi/type_graph/Flattener.cpp

@@ -62,7 +62,7 @@ void flattenParent(const Parent& parent,
     for (size_t i = 0; i < parentClass->members.size(); i++) {
       const auto& member = parentClass->members[i];
       flattenedMembers.push_back(member);
-      flattenedMembers.back().offset += parent.offset;
+      flattenedMembers.back().bitOffset += parent.bitOffset;
       if (i == 0) {
         flattenedMembers.back().align =
             std::max(flattenedMembers.back().align, parentClass->align());
@@ -71,7 +71,8 @@ void flattenParent(const Parent& parent,
   } else if (Container* parentContainer =
                  dynamic_cast<Container*>(&parentType)) {
     // Create a new member to represent this parent container
-    flattenedMembers.emplace_back(parentContainer, "__parent", parent.offset);
+    flattenedMembers.emplace_back(parentContainer, "__parent",
+                                  parent.bitOffset);
   } else {
     throw std::runtime_error("Invalid type for parent");
   }
@@ -169,8 +170,8 @@ void Flattener::visit(Class& c) {
   std::size_t member_idx = 0;
   std::size_t parent_idx = 0;
   while (member_idx < c.members.size() && parent_idx < c.parents.size()) {
-    auto member_offset = c.members[member_idx].offset;
-    auto parent_offset = c.parents[parent_idx].offset;
+    auto member_offset = c.members[member_idx].bitOffset;
+    auto parent_offset = c.parents[parent_idx].bitOffset;
     if (member_offset < parent_offset) {
       // Add our own member
       const auto& member = c.members[member_idx++];

oi/type_graph/Printer.cpp

@@ -166,16 +166,22 @@ void Printer::print_param(const TemplateParam& param) {
 void Printer::print_parent(const Parent& parent) {
   depth_++;
   prefix();
-  out_ << "Parent (offset: " << parent.offset << ")" << std::endl;
+  out_ << "Parent (offset: " << static_cast<double>(parent.bitOffset) / 8 << ")"
+       << std::endl;
   print(*parent.type);
   depth_--;
 }
 
 void Printer::print_member(const Member& member) {
   depth_++;
   prefix();
-  out_ << "Member: " << member.name << " (offset: " << member.offset
-       << align_str(member.align) << ")" << std::endl;
+  out_ << "Member: " << member.name
+       << " (offset: " << static_cast<double>(member.bitOffset) / 8;
+  out_ << align_str(member.align);
+  if (member.bitsize != 0) {
+    out_ << ", bitsize: " << member.bitsize;
+  }
+  out_ << ")" << std::endl;
   print(*member.type);
   depth_--;
 }

oi/type_graph/RemoveIgnored.cpp

@@ -47,7 +47,8 @@ void RemoveIgnored::visit(Class& c) {
     auto* primitive = typeGraph_.make_type<Primitive>(Primitive::Kind::Int8);
     auto* paddingArray =
         typeGraph_.make_type<Array>(primitive, c.members[i].type->size());
-    c.members[i] = Member{paddingArray, c.members[i].name, c.members[i].offset};
+    c.members[i] =
+        Member{paddingArray, c.members[i].name, c.members[i].bitOffset};
   }
 }
 

oi/type_graph/Types.h

@@ -69,14 +69,15 @@ class Type {
 struct Member {
   Member(Type* type,
          const std::string& name,
-         uint64_t offset,
-         uint64_t align = 0)
-      : type(type), name(name), offset(offset), align(align) {
+         uint64_t bitOffset,
+         uint64_t bitsize = 0)
+      : type(type), name(name), bitOffset(bitOffset), bitsize(bitsize) {
   }
 
   Type* type;
-  std::string name;  // TODO make optional?
-  uint64_t offset;
+  std::string name;
+  uint64_t bitOffset;
+  uint64_t bitsize;
   uint64_t align = 0;
 };
 
@@ -91,11 +92,11 @@ struct Function {
 
 class Class;
 struct Parent {
-  Parent(Type* type, uint64_t offset) : type(type), offset(offset) {
+  Parent(Type* type, uint64_t bitOffset) : type(type), bitOffset(bitOffset) {
   }
 
   Type* type;
-  uint64_t offset;
+  uint64_t bitOffset;
 };
 
 struct TemplateParam {

test/integration/bitfields.toml

@@ -0,0 +1,125 @@
+definitions = '''
+  struct Single {
+    int bitfield : 3;
+  };
+
+  struct WithinBytes {
+    char a : 3;
+    char b : 5;
+    char c : 7;
+  };
+
+  struct StraddleBytes {
+    char a : 7;
+    char b : 7;
+    char c : 2;
+  };
+
+  struct Mixed {
+    int a;
+    char b : 4;
+    short c : 12;
+    char d;
+    int e : 22;
+  };
+
+  #pragma clang diagnostic push
+  #pragma clang diagnostic ignored "-Wbitfield-width"
+  // The bitfield will max out at the size of its type. Extra bits act as padding.
+  struct MoreBitsThanType {
+    char a : 29;
+  };
+  #pragma clang diagnostic pop
+
+  // A zero-sized bitfield adds default padding between neighbouring bitfields
+  struct ZeroBits {
+    char b1 : 3;
+    char : 0;
+    char b2 : 2;
+  };
+
+  enum class MyEnum {
+    One,
+    Two,
+    Three,
+  };
+
+  struct Enum {
+    MyEnum e : 2;
+    MyEnum f : 4;
+  };
+'''
+# TODO The sizes do not take bitfields into account. They count each field as
+# if they were regular primitives.
+[cases]
+  [cases.single]
+    cli_options = ["-ftype-graph"]
+    oil_skip = "not implemented"
+    param_types = ["Single&"]
+    setup = "return {};"
+    expect_json = '''[
+      {"staticSize":4, "dynamicSize":0, "exclusiveSize":0, "members":[
+        {"staticSize":4, "dynamicSize":0, "exclusiveSize":4}
+    ]}]'''
+  [cases.within_bytes]
+    cli_options = ["-ftype-graph"]
+    oil_skip = "not implemented"
+    param_types = ["WithinBytes&"]
+    setup = "return {};"
+    expect_json = '''[
+      {"staticSize":2, "dynamicSize":0, "exclusiveSize":0, "members":[
+        {"staticSize":1, "dynamicSize":0, "exclusiveSize":1},
+        {"staticSize":1, "dynamicSize":0, "exclusiveSize":1},
+        {"staticSize":1, "dynamicSize":0, "exclusiveSize":1}
+    ]}]'''
+  [cases.straddle_bytes]
+    cli_options = ["-ftype-graph"]
+    oil_skip = "not implemented"
+    param_types = ["StraddleBytes&"]
+    setup = "return {};"
+    expect_json = '''[
+      {"staticSize":3, "dynamicSize":0, "exclusiveSize":0, "members":[
+        {"staticSize":1, "dynamicSize":0, "exclusiveSize":1},
+        {"staticSize":1, "dynamicSize":0, "exclusiveSize":1},
+        {"staticSize":1, "dynamicSize":0, "exclusiveSize":1}
+    ]}]'''
+  [cases.mixed]
+    cli_options = ["-ftype-graph"]
+    oil_skip = "not implemented"
+    param_types = ["Mixed&"]
+    setup = "return {};"
+    expect_json = '''[
+      {"staticSize":12, "dynamicSize":0, "exclusiveSize":0, "members":[
+        {"staticSize":4, "dynamicSize":0, "exclusiveSize":4},
+        {"staticSize":1, "dynamicSize":0, "exclusiveSize":1},
+        {"staticSize":2, "dynamicSize":0, "exclusiveSize":2},
+        {"staticSize":1, "dynamicSize":0, "exclusiveSize":1},
+        {"staticSize":4, "dynamicSize":0, "exclusiveSize":4}
+    ]}]'''
+  [cases.more_bits_than_type] # TODO member sizes are wrong
+    skip = "drgn errors out"
+    cli_options = ["-ftype-graph"]
+    oil_skip = "not implemented"
+    param_types = ["MoreBitsThanType&"]
+    setup = "return {};"
+    expect_json = '"TODO"'
+  [cases.zero_bits]
+    cli_options = ["-ftype-graph"]
+    oil_skip = "not implemented"
+    param_types = ["ZeroBits&"]
+    setup = "return {};"
+    expect_json = '''[
+      {"staticSize":2, "dynamicSize":0, "exclusiveSize":0, "members":[
+        {"staticSize":1, "dynamicSize":0, "exclusiveSize":1},
+        {"staticSize":1, "dynamicSize":0, "exclusiveSize":1}
+    ]}]'''
+  [cases.enum]
+    cli_options = ["-ftype-graph"]
+    oil_skip = "not implemented"
+    param_types = ["Enum&"]
+    setup = "return {};"
+    expect_json = '''[
+      {"staticSize":4, "dynamicSize":0, "exclusiveSize":0, "members":[
+        {"staticSize":4, "dynamicSize":0, "exclusiveSize":4},
+        {"staticSize":4, "dynamicSize":0, "exclusiveSize":4}
+    ]}]'''