fix(svdconv): guard bit masks and bound dimension expansion

tools/svdconv/SVDConv/README.md

@@ -48,6 +48,14 @@ due to backward compatibility reasons. All newly developed/updated SVD files sho
 in the same directory as `svdconv.exe`. On Linux and macOS, SVDConv reports error M133 and
 returns exit code 2. The intermediate `.sfd` file may still be generated.
 Use `--generate=sfd` to generate SFD output on any supported platform.
+SVDConv supports Cortex-M devices with register and field ranges within 32 bits. Wider intermediate arithmetic
+prevents overflow; it does not add support for 64-bit input or output. SFD/SFR rejects wider ranges with M226 before
+SFD file creation. SFR compilation is skipped when SFD generation fails.
+
+Dimension expansion has a cumulative limit of 1,000,000 generated indices and model copies per input file.
+Nested arrays, inherited content, and repeated expansion share this limit. Exceeding it reports M249 and stops
+processing that input before any output generator runs. This bounds expansion work, not the XML file size or total
+process memory. Invalid dimension index ranges and overflowing expansion addresses report M250.
 
 ## Return Codes
 
@@ -287,6 +295,8 @@ The following table shows the errors and warnings issued by svdconv.
 | M241 |  ERROR |  Parse Error: 'VALUE' invalid for Array generation |  Correct SVD.|
 | M242 |  WARNING |  'LEVEL' 'NAME' `<dimArrayIndex>` found, but no `<dim>` |  Correct SVD.|
 | M243 |  WARNING |  'LEVEL' 'NAME' `<dimArrayIndex>` found, but `<dim>` does not describe an array |  Correct SVD.|
+| M249 |  ERROR |  Dimension expansion exceeds the per-input limit of 'NUM' generated indices and model copies. |  Reduce the total expanded model size.|
+| M250 |  ERROR |  Dimension 'NAME' has an invalid or overflowing index/address range. |  Correct the dimension range or increment.|
 
 ### Data Check Errors
 

tools/svdconv/SVDConv/src/SVDConv.cpp

@@ -253,6 +253,13 @@ SVD_ERR SvdConv::CheckSvdFile()
   if(success) { LogMsg("M040", NAME("Deleting XML Tree"), TIME(t2));  }
 	else        { LogMsg("M111", NAME("Deleting XML Tree"));            }
 
+  // A partial model from an exhausted expansion budget must never reach a generator.
+  if(m_svdModel->HasExpansionError()) {
+    delete m_svdModel;
+    m_svdModel = nullptr;
+    return SVD_ERR_VERIFY;
+  }
+
   // ----------------------  Calculate Model  ----------------------
   t1 = CrossPlatformUtils::ClockInMsec();
   success = m_svdModel->CalculateModel();
@@ -334,6 +341,7 @@ SVD_ERR SvdConv::CheckSvdFile()
   // ----------------------  Generate SFD File  ----------------------
   if(m_svdOptions.IsGenerateSfd()) {
     t1 = CrossPlatformUtils::ClockInMsec();
+    success = false;
     if(device) {
       generator->SetSvdFileName(path);
       generator->SetProgramInfo(version, descr, copyright);
@@ -346,7 +354,7 @@ SVD_ERR SvdConv::CheckSvdFile()
   }
 
   // ----------------------  Generate SFR File  ----------------------
-  if(m_svdOptions.IsGenerateSfr()) {
+  if(m_svdOptions.IsGenerateSfr() && success) {
     t1 = CrossPlatformUtils::ClockInMsec();
     if(device) {
       generator->SetSvdFileName(path);

tools/svdconv/SVDConv/src/SVDConv_Msgs.cpp

@@ -114,6 +114,9 @@ const MsgTable SvdConv::msgTable = {
   { "M247", { MsgLevel::LEVEL_ERROR,    CRLF_B,   "C Expression: Error occurred during generation!"                             } },
   { "M248", { MsgLevel::LEVEL_ERROR,    CRLF_B,   "C Expression: Referenced Object must be Register or Field!"                  } },
 
+  { "M249", { MsgLevel::LEVEL_ERROR,    CRLF_B,   "Dimension expansion exceeds the per-input limit of %NUM% generated indices and model copies." } },
+  { "M250", { MsgLevel::LEVEL_ERROR,    CRLF_B,   "Dimension '%NAME%' has an invalid or overflowing index/address range."     } },
+
 
   // 300... Data Check Errors
   { "M300", { MsgLevel::LEVEL_ERROR,    CRLF_B,   ""                                                                            } },

tools/svdconv/SVDGenerator/include/SfdData.h

@@ -73,6 +73,9 @@ class SfdData {
   bool IsValid                      (SvdItem* item);
 
 private:
+  static bool CheckBitRange         (SvdItem* item);
+  static bool CheckBitRanges        (SvdItem* item);
+
   const SvdOptions&   m_options;
   FileIo*             m_fileIo;
   SfdGenerator*       m_gen;

tools/svdconv/SVDGenerator/src/HeaderData_Field.cpp

@@ -40,7 +40,9 @@ bool HeaderData::CreateFields(SvdRegister* reg, string structName)
     FIELDMAPLIST sortedFields;
     AddFields(fieldCont, sortedFields);
 
-    CreateSortedFields(sortedFields, regSize, structName);
+    if(!CreateSortedFields(sortedFields, regSize, structName)) {
+      return false;
+    }
   }
 
   return true;
@@ -74,10 +76,11 @@ bool HeaderData::AddFields(SvdItem* container, FIELDMAPLIST& sortedFields)
       }
     }
 
-    const auto name = field->GetNameCalculated();
-    uint32_t offs = (uint32_t) field->GetOffset();
-    uint32_t width = (uint32_t) field->GetBitWidth();
-    uint32_t mask = ((1<<width)-1) << offs;
+    uint32_t offset, bitWidth;
+    if(!SvdUtils::GetBitRange32(field->GetOffset(), field->GetBitWidth(), offset, bitWidth)) {
+      continue;
+    }
+    const auto mask = SvdUtils::CreateBitMask32(bitWidth, offset);
 
     ONESTRUCT* oneStruct = nullptr;
     for(auto& oneStr : sortedFields) {
@@ -93,8 +96,8 @@ bool HeaderData::AddFields(SvdItem* container, FIELDMAPLIST& sortedFields)
       oneStruct = &*sortedFields.rbegin();
     }
 
+    oneStruct->fields.emplace(offset, field);
     oneStruct->mask |= mask;
-    oneStruct->fields[offs] = field;
   }
 
   return true;
@@ -104,20 +107,30 @@ bool HeaderData::AddFields(SvdItem* container, FIELDMAPLIST& sortedFields)
 bool HeaderData::CreateSortedFields(const FIELDMAPLIST& sortedFields, uint32_t regSize, string structName)
 {
   m_reservedFieldCnt = 0;
+  if(regSize > sizeof(uint32_t)) {
+    m_gen->Generate<C_ERROR>("Register bitfields exceed 32 bits", -1);
+    return false;
+  }
+  const auto registerBits = regSize * 8;
 
   for(const auto& oneStruct : sortedFields) {
     uint32_t offsCnt = 0;
     m_gen->Generate<STRUCT|BEGIN>("");
 
     for(const auto& [newOffs, field] : oneStruct.fields) {
-      int32_t res = newOffs - offsCnt;
-
-      GenerateReservedField(res, regSize);
-      offsCnt += res;
-      offsCnt += CreateField(field, regSize, offsCnt);
+      if(newOffs < offsCnt || newOffs > registerBits) {
+        m_gen->Generate<C_ERROR>("Reserved bits calculation error", -1);
+        return false;
+      }
+      GenerateReservedField(newOffs - offsCnt, regSize);
+      const auto fieldWidth = CreateField(field, regSize, newOffs);
+      if(fieldWidth > registerBits - newOffs) {
+        m_gen->Generate<C_ERROR>("Reserved bits calculation error", -1);
+        return false;
+      }
+      offsCnt = newOffs + fieldWidth;
     }
-
-    GenerateReservedField((regSize * 8) - offsCnt, regSize);  // fill up (pad) bitfields
+    GenerateReservedField(registerBits - offsCnt, regSize);  // fill up (pad) bitfields
 
     m_gen->Generate<STRUCT|END>("%s", structName.c_str());
   }
@@ -131,27 +144,23 @@ uint32_t HeaderData::CreateField(SvdField* field, uint32_t regSize, uint32_t off
     return false;
   }
 
-  uint32_t sizeNeeded = 0;
-
   const auto& dataType  = SvdUtils::GetDataTypeString(regSize);
   const auto name       = field->GetNameCalculated();
   const auto descr      = field->GetDescriptionCalculated();
   const auto accType    = field->GetEffectiveAccess();
-  uint32_t   fieldWidth = field->GetBitWidth();
-  uint32_t   fieldPos   = (uint32_t)field->GetOffset();
+  uint32_t fieldPos, fieldWidth;
+  if(!SvdUtils::GetBitRange32(field->GetOffset(), field->GetBitWidth(), fieldPos, fieldWidth)) {
+    return 0;
+  }
 
   m_gen->Generate<MAKE|MK_FIELD_STRUCT>("%s", accType, dataType.c_str(), regSize, fieldWidth, name.c_str());
-  uint32_t lastBit = fieldPos + fieldWidth -1;
+  const auto lastBit = fieldPos + fieldWidth -1;
   m_gen->Generate<MAKE|MK_DOXY_COMMENT_BITFIELD>("%s", fieldPos, lastBit, !descr.empty()? descr.c_str() : name.c_str());
 
-  if(sizeNeeded < fieldWidth) {
-    sizeNeeded = fieldWidth;
-  }
-
   if(offsCnt != fieldPos) {
     m_gen->Generate<C_ERROR>("Reserved bits calculation error", -1);
   }
 
-  return sizeNeeded;
+  return fieldWidth;
 }
 

tools/svdconv/SVDGenerator/src/HeaderData_PosMask.cpp

@@ -218,9 +218,11 @@ bool HeaderData::CreateFieldPosMask(SvdField* field, PosMaskNames *posMaskNames)
   const auto& alternateGroup  = posMaskNames->alternate;
   const auto  name            = field->GetNameCalculated();
   const auto  fieldName       = field->GetHierarchicalNameResulting();
-  uint32_t firstBit           = (uint32_t)field->GetOffset();
-  uint32_t bitWidth           = field->GetEffectiveBitWidth();
-  uint32_t bitMaxNum          = (uint32_t) ((((uint64_t)(1) << bitWidth) -1));
+  uint32_t firstBit, bitWidth;
+  if(!SvdUtils::GetBitRange32(field->GetOffset(), field->GetEffectiveBitWidth(), firstBit, bitWidth)) {
+    return false;
+  }
+  const auto bitMaxNum = SvdUtils::CreateBitMask32(bitWidth);
 
   if(!alternateGroup.empty()) 
     m_gen->Generate<MAKE|MK_FIELD_POSMASK3  >("%s_%s", name.c_str(), firstBit, bitMaxNum, fieldName.c_str(), alternateGroup.c_str());

tools/svdconv/SVDGenerator/src/SfdData.cpp

@@ -10,9 +10,65 @@
 #include "SvdItem.h"
 #include "FileIo.h"
 #include "SvdDevice.h"
+#include "SvdDimension.h"
+#include "SvdField.h"
+#include "SvdPeripheral.h"
+#include "SvdRegister.h"
+#include "SvdUtils.h"
+#include "ErrLog.h"
 
 using namespace std;
 
+bool SfdData::CheckBitRange(SvdItem* item)
+{
+  const auto reg = dynamic_cast<SvdRegister*>(item);
+  const auto field = dynamic_cast<SvdField*>(item);
+  if(reg || field) {
+    uint32_t offset, width;
+    if(!SvdUtils::GetBitRange32(field ? field->GetOffset() : 0, item->GetEffectiveBitWidth(), offset, width)) {
+      LogMsg("M226", MSG("SFD supports only bit ranges within 32 bits: '" + item->GetNameCalculated() + "'"), item->GetLineNumber());
+      return false;
+    }
+  }
+  return true;
+}
+
+bool SfdData::CheckBitRanges(SvdItem* item)
+{
+  if(!item->IsValid()) {
+    return true;
+  }
+  if(!CheckBitRange(item)) {
+    return false;
+  }
+
+  const auto peripheral = dynamic_cast<SvdPeripheral*>(item);
+  const auto condition = peripheral ? peripheral->GetDisableCondition() : nullptr;
+  if(condition && condition->IsValid()) {
+    for(const auto& symbol : condition->GetSymbolsList()) {
+      if(symbol.token.type != SvdCExpressionParser::xme_identi) {
+        continue;
+      }
+      const auto referenced = symbol.svdItem;
+      if(!referenced || !referenced->IsValid()) {
+        LogMsg("M226", MSG("Invalid item referenced by an SFD expression: '" + condition->GetText() + "'"), condition->GetLineNumber());
+        return false;
+      }
+      if(!CheckBitRange(referenced)) {
+        return false;
+      }
+    }
+  }
+
+  for(const auto child : item->GetChildren()) {
+    if(!CheckBitRanges(child)) {
+      return false;
+    }
+  }
+  const auto dim = item->GetDimension();
+  return !dim || CheckBitRanges(dim);
+}
+
 
 SfdData::SfdData(const FileHeaderInfo &fileHeaderInfo, const SvdOptions& options):
   m_options(options),
@@ -45,10 +101,21 @@ bool SfdData::Create(SvdItem *item, const string &fileName)
     return false;
   }
 
-  m_fileIo->Create(fileName);
-
   const auto device = dynamic_cast<SvdDevice*>(item);
-  if(!device) {
+  if(!device || !CheckBitRanges(device)) {
+    return false;
+  }
+  for(const auto& [name, reg] : device->GetExpressionRegistersList()) {
+    if(!reg || !reg->IsValid()) {
+      LogMsg("M226", MSG("Invalid register referenced by an SFD expression: '" + name + "'"));
+      return false;
+    }
+    if(!CheckBitRanges(reg)) {
+      return false;
+    }
+  }
+
+  if(!m_fileIo->Create(fileName)) {
     return false;
   }
 

tools/svdconv/SVDGenerator/src/SfdData_SingleItems.cpp

@@ -768,7 +768,7 @@ bool SfdData::CreateRegisterItem(SvdRegister* reg)
   if(cont && cont->IsValid() && cont->GetChildCount()) {
     list<SvdItem*> fieldsList;
     CreateFields(cont, fieldsList);
-    const auto accMaskReadRtree = (uint32_t) reg->GetAccessMask();
+    const auto accMaskReadRtree = reg->GetAccessMask();
 
     CreateItemDescription(reg, "RTree");
     m_gen->Generate<RTREE|BEGIN            >("SFDITEM_REG__%s", itemName.c_str());
@@ -873,10 +873,14 @@ bool SfdData::CreateFieldItem(SvdField* field)
   const auto dispName   = field->GetDisplayNameCalculated();
   const auto fieldDescr = SvdUtils::CheckTextGeneric_SfrCC2(field->GetDescriptionCalculated());
   const auto  regName   = field->GetParentRegisterNameHierarchical();
-  const auto firstBit   = (uint32_t)field->GetOffset();
-  const auto bitWidth   = (uint32_t)field->GetEffectiveBitWidth();
   const auto accessType = field->GetEffectiveAccess();
   const auto regAddress = (uint32_t)field->GetAbsoluteAddress();
+  uint32_t firstBit = 0;
+  uint32_t bitWidth = 0;
+  if(!SvdUtils::GetBitRange32(field->GetOffset(), field->GetEffectiveBitWidth(), firstBit, bitWidth)) {
+    LogMsg("M226", MSG("SFD supports only bit ranges within 32 bits: '" + fieldName + "'"), field->GetLineNumber());
+    return false;
+  }
 
   uint32_t regBitWidth = 32;
   const auto parent = field->GetParent();
@@ -894,8 +898,8 @@ bool SfdData::CreateFieldItem(SvdField* field)
   field->GetValuesDescriptionString(valuesDescr);
   valuesDescr = SvdUtils::CheckTextGeneric_SfrCC2(valuesDescr);
 
-  uint32_t lastBit = firstBit + bitWidth -1;
-  uint32_t bitMaxNum = (uint32_t) (((uint64_t)(1) << bitWidth) -1);
+  const auto lastBit = firstBit + bitWidth -1;
+  const auto bitMaxNum = SvdUtils::CreateBitMask32(bitWidth);
 
   CreateItemDescription(field, "Item");
   m_gen->Generate<ITEM|BEGIN>("SFDITEM_FIELD__%s", itemName.c_str());
@@ -1011,6 +1015,11 @@ bool SfdData::CreateEnumValueSet(SvdEnumContainer *cont, SvdField* field)
     return true;
   }
 
+  const auto bitWidth = field->GetEffectiveBitWidth();
+  if(bitWidth == 0 || bitWidth > MAX_BITWIDTH_FOR_COMBO) {
+    return false;
+  }
+
   const auto defaultValue = cont->GetDefaultValue();
   map<uint32_t, SvdEnum*> enumValues;
 
@@ -1028,8 +1037,7 @@ bool SfdData::CreateEnumValueSet(SvdEnumContainer *cont, SvdField* field)
     enumValues[val.u32] = enu;
   }
 
-  const auto bitWidth = field->GetEffectiveBitWidth();
-  const auto bitMaxNum = (uint32_t)((1UL << (uint64_t)bitWidth));
+  const uint32_t bitMaxNum = 1U << bitWidth;
 
   for(uint32_t bitNum=0; bitNum<bitMaxNum; bitNum++) {
     auto element = enumValues.find(bitNum);

tools/svdconv/SVDGenerator/src/SvdGenerator.cpp

@@ -110,11 +110,11 @@ bool SvdGenerator::SfdFile(SvdDevice *device, const string &path)
   SetFileHeader(fileHeaderInfo, device);
 
   const auto sfdData = new SfdData(fileHeaderInfo, m_options);
-  sfdData->Create(device, fileName);
+  const bool success = sfdData->Create(device, fileName);
 
   delete sfdData;
 
-  return true;
+  return success;
 }
 
 bool SvdGenerator::SfrFile(SvdDevice *device, const string &path)

tools/svdconv/SVDModel/include/SvdDimension.h

@@ -95,8 +95,9 @@ class SvdDimension : public SvdItem
   bool                            SetDimIndexList       (const std::list<std::string>&  dimIndexList)  { m_dimIndexList = dimIndexList; return true; }
   bool                            SetDimName            (const std::string&             dimName     )  { m_dimName      = dimName     ; return true; }
 
-  int32_t                             GetAddressBitsUnits   ();
-  int32_t                             CalcAddressIncrement  ();
+  uint32_t                        GetAddressBitsUnits   ();
+  uint64_t                        CalcAddressIncrement  ();
+  bool                            CheckExpansionRange   (uint64_t start, uint64_t increment);
   bool                            IsTagAllowed          (const std::string& tag);
   bool                            InitAllowedTags       ();