Merge pull request #127 from kornilova-l/fix-fields-offsets

Represent structs with bit fields as arrays

Author: kornilova203

bindgen/ir/IR.cpp

@@ -34,9 +34,10 @@ void IR::addEnum(std::string name, const std::string &type,
 
 void IR::addStruct(std::string name, std::vector<std::shared_ptr<Field>> fields,
                    uint64_t typeSize, std::shared_ptr<Location> location,
-                   bool isPacked) {
-    std::shared_ptr<Struct> s = std::make_shared<Struct>(
-        name, std::move(fields), typeSize, std::move(location), isPacked);
+                   bool isPacked, bool isBitField) {
+    std::shared_ptr<Struct> s =
+        std::make_shared<Struct>(name, std::move(fields), typeSize,
+                                 std::move(location), isPacked, isBitField);
     structs.push_back(s);
     std::shared_ptr<TypeDef> typeDef = getTypeDefWithName("struct_" + name);
     if (typeDef) {

bindgen/ir/IR.h

@@ -36,7 +36,7 @@ class IR {
 
     void addStruct(std::string name, std::vector<std::shared_ptr<Field>> fields,
                    uint64_t typeSize, std::shared_ptr<Location> location,
-                   bool isPacked);
+                   bool isPacked, bool isBitField);
 
     void addUnion(std::string name, std::vector<std::shared_ptr<Field>> fields,
                   uint64_t maxSize, std::shared_ptr<Location> location);

bindgen/ir/Struct.cpp

@@ -8,10 +8,12 @@
 Field::Field(std::string name, std::shared_ptr<Type> type)
     : TypeAndName(std::move(name), std::move(type)) {}
 
-Field::Field(std::string name, std::shared_ptr<Type> type, uint64_t offset)
-    : TypeAndName(std::move(name), std::move(type)), offset(offset) {}
+Field::Field(std::string name, std::shared_ptr<Type> type,
+             uint64_t offsetInBits)
+    : TypeAndName(std::move(name), std::move(type)),
+      offsetInBits(offsetInBits) {}
 
-uint64_t Field::getOffset() const { return offset; }
+uint64_t Field::getOffsetInBits() const { return offsetInBits; }
 
 StructOrUnion::StructOrUnion(std::string name,
                              std::vector<std::shared_ptr<Field>> fields,
@@ -29,12 +31,12 @@ bool StructOrUnion::hasHelperMethods() const { return !fields.empty(); }
 
 Struct::Struct(std::string name, std::vector<std::shared_ptr<Field>> fields,
                uint64_t typeSize, std::shared_ptr<Location> location,
-               bool isPacked)
+               bool isPacked, bool isBitField)
     : StructOrUnion(std::move(name), std::move(fields), std::move(location)),
-      typeSize(typeSize), isPacked(isPacked) {}
+      typeSize(typeSize), isPacked(isPacked), isBitField(isBitField) {}
 
 std::shared_ptr<TypeDef> Struct::generateTypeDef() {
-    if (fields.size() < SCALA_NATIVE_MAX_STRUCT_FIELDS) {
+    if (isRepresentedAsStruct()) {
         return std::make_shared<TypeDef>(getTypeAlias(), shared_from_this(),
                                          nullptr);
     } else {
@@ -56,7 +58,7 @@ std::string Struct::generateHelperClass() const {
     s << "  implicit class " << type << "_ops(val p: native.Ptr[" << type
       << "])"
       << " extends AnyVal {\n";
-    if (fields.size() <= SCALA_NATIVE_MAX_STRUCT_FIELDS) {
+    if (isRepresentedAsStruct()) {
         s << generateHelperClassMethodsForStructRepresentation();
     } else {
         s << generateHelperClassMethodsForArrayRepresentation();
@@ -72,6 +74,9 @@ std::string Struct::generateHelperClass() const {
 }
 
 bool Struct::hasHelperMethods() const {
+    if (isBitField) {
+        return false;
+    }
     if (!isRepresentedAsStruct()) {
         return !fields.empty();
     }
@@ -176,7 +181,7 @@ Struct::generateGetterForStructRepresentation(unsigned fieldIndex) const {
 }
 
 bool Struct::isRepresentedAsStruct() const {
-    return fields.size() <= SCALA_NATIVE_MAX_STRUCT_FIELDS;
+    return fields.size() <= SCALA_NATIVE_MAX_STRUCT_FIELDS && !isBitField;
 }
 
 std::string
@@ -188,9 +193,10 @@ Struct::generateSetterForArrayRepresentation(unsigned int fieldIndex) const {
     std::string castedField = "p._1";
 
     PointerType pointerToFieldType = PointerType(field->getType());
-    if (field->getOffset() > 0) {
-        castedField = "(" + castedField + " + " +
-                      std::to_string(field->getOffset()) + ")";
+    uint64_t offsetInBytes = field->getOffsetInBits() / 8;
+    if (offsetInBytes > 0) {
+        castedField =
+            "(" + castedField + " + " + std::to_string(offsetInBytes) + ")";
     }
     castedField = "!" + castedField + ".cast[" + pointerToFieldType.str() + "]";
     if (isAliasForType<ArrayType>(field->getType().get()) ||
@@ -215,8 +221,9 @@ Struct::generateGetterForArrayRepresentation(unsigned fieldIndex) const {
     std::string methodBody;
 
     PointerType pointerToFieldType = PointerType(field->getType());
-    if (field->getOffset() > 0) {
-        methodBody = "(p._1 + " + std::to_string(field->getOffset()) + ")";
+    uint64_t offsetInBytes = field->getOffsetInBits() / 8;
+    if (offsetInBytes > 0) {
+        methodBody = "(p._1 + " + std::to_string(offsetInBytes) + ")";
     } else {
         methodBody = "p._1";
     }
@@ -233,7 +240,6 @@ Struct::generateGetterForArrayRepresentation(unsigned fieldIndex) const {
     s << "    def " << getter << ": " << returnType << " = " << methodBody
       << "\n";
     return s.str();
-    return "";
 }
 
 Union::Union(std::string name, std::vector<std::shared_ptr<Field>> fields,

bindgen/ir/Struct.h

@@ -13,15 +13,15 @@ class Field : public TypeAndName {
   public:
     Field(std::string name, std::shared_ptr<Type> type);
 
-    Field(std::string name, std::shared_ptr<Type> type, uint64_t offset);
+    Field(std::string name, std::shared_ptr<Type> type, uint64_t offsetInBits);
 
-    uint64_t getOffset() const;
+    uint64_t getOffsetInBits() const;
 
   protected:
     /**
      * Offset in bytes from address of struct/union.
      */
-    uint64_t offset = 0;
+    uint64_t offsetInBits = 0;
 };
 
 class StructOrUnion {
@@ -52,8 +52,8 @@ class Struct : public StructOrUnion,
                public std::enable_shared_from_this<Struct> {
   public:
     Struct(std::string name, std::vector<std::shared_ptr<Field>> fields,
-           uint64_t typeSize, std::shared_ptr<Location> location,
-           bool isPacked);
+           uint64_t typeSize, std::shared_ptr<Location> location, bool isPacked,
+           bool isBitField);
 
     std::shared_ptr<TypeDef> generateTypeDef() override;
 
@@ -74,9 +74,11 @@ class Struct : public StructOrUnion,
     bool operator==(const Type &other) const override;
 
   private:
-    /* type size is needed if number of fields is bigger than 22 */
+    /** type size is needed if number of fields is bigger than 22 */
     uint64_t typeSize;
     bool isPacked;
+    /** true if at least one field is bit field */
+    bool isBitField;
 
     bool isRepresentedAsStruct() const;
 

bindgen/visitor/TreeVisitor.cpp

@@ -130,14 +130,17 @@ void TreeVisitor::handleStruct(clang::RecordDecl *record, std::string name) {
     const clang::ASTRecordLayout &recordLayout =
         astContext->getASTRecordLayout(record);
 
+    bool isBitFieldStruct = false;
     for (const clang::FieldDecl *field : record->fields()) {
+        if (field->isBitField()) {
+            isBitFieldStruct = true;
+        }
         std::shared_ptr<Type> ftype =
             typeTranslator.translate(field->getType(), &name);
         uint64_t recordOffsetInBits =
             recordLayout.getFieldOffset(field->getFieldIndex());
-        assert(recordOffsetInBits % 8 == 0);
-        fields.push_back(std::make_shared<Field>(
-            field->getNameAsString(), ftype, recordOffsetInBits / 8));
+        fields.push_back(std::make_shared<Field>(field->getNameAsString(),
+                                                 ftype, recordOffsetInBits));
 
         cycleDetection.AddDependency(newName, field->getType());
     }
@@ -156,7 +159,7 @@ void TreeVisitor::handleStruct(clang::RecordDecl *record, std::string name) {
     assert(sizeInBits % 8 == 0);
 
     ir.addStruct(name, std::move(fields), sizeInBits / 8, getLocation(record),
-                 record->hasAttr<clang::PackedAttr>());
+                 record->hasAttr<clang::PackedAttr>(), isBitFieldStruct);
 }
 
 bool TreeVisitor::VisitVarDecl(clang::VarDecl *varDecl) {

tests/samples/Struct.h

@@ -60,6 +60,19 @@ struct __attribute__((__packed__)) packedStruct { // no helper methods
     char a;
 };
 
+struct bitFieldStruct { // no helper methods
+    unsigned char b1 : 3;
+    unsigned char : 0; // start a new byte
+    unsigned char b2 : 6;
+    unsigned char b3 : 2;
+};
+
+struct bitFieldOffsetDivByEight { // no helper methods
+    unsigned b1 : 8;
+    unsigned b2 : 8;
+    unsigned char b3 : 8;
+};
+
 char getCharFromAnonymousStruct(struct structWithAnonymousStruct *s);
 
 char getIntFromAnonymousStruct(struct structWithAnonymousStruct *s);

tests/samples/Struct.scala

@@ -14,6 +14,8 @@ object Struct {
   type struct_bigStruct = native.CArray[Byte, native.Nat.Digit[native.Nat._1, native.Nat.Digit[native.Nat._1, native.Nat._2]]]
   type struct_structWithAnonymousStruct = native.CStruct2[native.CInt, native.CArray[Byte, native.Nat._8]]
   type struct_packedStruct = native.CStruct1[native.CChar]
+  type struct_bitFieldStruct = native.CArray[Byte, native.Nat._2]
+  type struct_bitFieldOffsetDivByEight = native.CArray[Byte, native.Nat._4]
   type enum_struct_op = native.CUnsignedInt
   def setPoints(points: native.Ptr[struct_points], x1: native.CInt, y1: native.CInt, x2: native.CInt, y2: native.CInt): Unit = native.extern
   def getPoint(points: native.Ptr[struct_points], pointIndex: enum_pointIndex): native.CInt = native.extern