added bitfield

Author: klemens-morgenstern

include/mrdox/Metadata/BitField.hpp

@@ -0,0 +1,83 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Klemens D. Morgenstern
+//
+//
+// Official repository: https://github.com/cppalliance/mrdox
+//
+
+#ifndef MRDOX_METADATA_BITFIELD_HPP
+#define MRDOX_METADATA_BITFIELD_HPP
+
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+
+namespace clang {
+namespace mrdox {
+
+
+constexpr std::uint32_t makeMask(unsigned char Offset,
+                                 unsigned char Size)
+{
+    auto init = std::numeric_limits<std::uint32_t>::max();
+    auto offset = init << Offset;
+    auto rest   = init >>= (sizeof(std::uint32_t) * 8) - (Offset + Size);
+    return offset & rest;
+}
+
+
+template<unsigned char Offset,
+         unsigned char Size = 1u,
+         typename T = std::uint32_t>
+struct BitField
+{
+    using underlying_type = std::uint32_t;
+    underlying_type value;
+
+    constexpr static underlying_type mask = makeMask(Offset, Size);
+    constexpr static underlying_type offset = Offset;
+    constexpr static underlying_type size = Size;
+
+    constexpr T get() const noexcept
+    {
+        constexpr underlying_type simple_mask = makeMask(0u, Offset + Size);
+        auto val = value & simple_mask;
+
+        if constexpr (std::is_signed<T>::value && (Size + Offset) < (sizeof(underlying_type) * 8u))
+        {
+            constexpr underlying_type minus = static_cast<underlying_type>(1) << (Size + Offset);
+            if ((val & minus) != static_cast<underlying_type>(0))
+                val |= ~simple_mask; //2s complement - I think
+        }
+        val >>= Offset;
+        return static_cast<T>(val);
+    }
+
+    constexpr operator T () const noexcept
+    {
+        return get();
+    }
+
+    constexpr void set(T val) noexcept
+    {
+        auto update = (static_cast<underlying_type>(val) << Offset) & mask;
+        value = (value & ~mask) | update;
+    }
+
+    constexpr T operator=(T val) noexcept { set(val); return val;}
+};
+
+template<unsigned char Offset>
+using BitFlag = BitField<Offset, 1u, bool>;
+
+using BitFieldFullValue = BitField<0, 32>;
+
+}
+}
+
+#endif //MRDOX_METADATA_BITFIELD_HPP

include/mrdox/MetadataFwd.hpp

@@ -49,6 +49,13 @@ struct TypedefInfo;
 struct VarInfo;
 struct VerbatimBlock;
 
+
+template<unsigned char Offset,
+         unsigned char Size,
+         typename T>
+struct BitField;
+using BitFieldFullValue = BitField<0, 32, std::uint32_t>;
+
 } // mrdox
 } // clang
 

source/api/AST/BitcodeWriter.cpp

@@ -552,6 +552,24 @@ emitRecord(
     Stream.EmitRecordWithAbbrev(Abbrevs.get(ID), Record);
 }
 
+
+// Bits
+void
+BitcodeWriter::
+emitRecord(
+    std::initializer_list<BitFieldFullValue> values,
+    RecordId ID)
+{
+    Assert(RecordIdNameMap[ID]);
+    Assert(RecordIdNameMap[ID].Abbrev == &Integer32ArrayAbbrev);
+    if (!prepRecordData(ID, true))
+        return;
+    Record.push_back(values.size());
+    for(std::uint32_t value : values)
+        Record.push_back(value);
+    Stream.EmitRecordWithAbbrev(Abbrevs.get(ID), Record);
+}
+
 // SymbolIDs
 void
 BitcodeWriter::
@@ -776,7 +794,7 @@ emitBlock(
     emitSymbolPart(I);
     emitRecord(I.Access, FUNCTION_ACCESS);
     emitRecord(I.IsMethod, FUNCTION_IS_METHOD);
-    emitRecord(FUNCTION_BITS, I.specs0, I.specs1);
+    emitRecord({I.specs0.raw, I.specs1.raw}, FUNCTION_BITS);
     emitBlock(I.Parent, FieldId::F_parent);
     emitBlock(I.ReturnType);
     for (const auto& N : I.Params)

source/api/AST/BitcodeWriter.hpp

@@ -35,6 +35,7 @@
 namespace clang {
 namespace mrdox {
 
+
 class BitcodeWriter
 {
 public:
@@ -94,6 +95,7 @@ class BitcodeWriter
     void emitRecord(Location const& Loc, RecordId ID);
     void emitRecord(bool Value, RecordId ID);
     void emitRecord(TemplateInfo const& Templ);
+    void emitRecord(std::initializer_list<BitFieldFullValue> values, RecordId ID);
     //void emitRecord(Reference const& Ref, RecordId ID);
 
     bool prepRecordData(RecordId ID, bool ShouldEmit = true);

source/api/AST/DecodeRecord.hpp

@@ -266,6 +266,27 @@ decodeRecord(
     return llvm::Error::success();
 }
 
+template<std::size_t N>
+inline
+llvm::Error
+decodeRecord(
+    Record const& R,
+    std::array<BitFieldFullValue*, N> values,
+    llvm::StringRef Blob)
+{
+    auto n = R[0];
+    if(n != N)
+        return makeError("wrong size(", n, ") for Bitfields[", N, "]");
+    for(std::size_t i = 0; i < N; ++i)
+    {
+        auto const v = R[i + 1];
+        if(v > (std::numeric_limits<std::uint32_t>::max)())
+            return makeError(v, " is out of range for Bits");
+        *values[i] = v;
+    }
+    return llvm::Error::success();
+}
+
 } // mrdox
 } // clang