Merge pull request #1410 from Mellanox/master_devel

Merge  master_devel to master branch

Author: ahmadawwad

adb_parser/adb_condVar.cpp

@@ -39,6 +39,9 @@
 #include "adb_instance.h"
 
 using namespace std;
+
+u_int64_t pop_from_buf(const u_int8_t* buff, u_int32_t bit_offset, u_int32_t field_size);
+
 template<typename T_OFFSET>
 _AdbCondVar_impl<T_OFFSET>::_AdbCondVar_impl(string original_name) : _original_name(original_name)
 {
@@ -84,13 +87,13 @@ typename _AdbCondVar_impl<T_OFFSET>::AdbInstance* _AdbCondVar_impl<T_OFFSET>::ge
     return this->_instance;
 }
 template<typename T_OFFSET>
-void _AdbCondVar_impl<T_OFFSET>::evaluate(uint8_t* buffer)
+void _AdbCondVar_impl<T_OFFSET>::evaluate(uint8_t* buffer, T_OFFSET offset_shift)
 {
     if (!is_evaluated())
     {
         if (this->_instance)
         {
-            uint64_t value = this->_instance->popBuf(buffer);
+            uint64_t value = pop_from_buf(buffer, this->_instance->offset + offset_shift, this->_instance->get_size());
             set_value(static_cast<int>(value));
         }
         else

adb_parser/adb_condVar.h

@@ -58,7 +58,7 @@ class _AdbCondVar_impl
     int get_value() const;
     AdbInstance* get_instance() const;
     const string& get_original_name() const;
-    void evaluate(uint8_t* buffer);
+    void evaluate(uint8_t* buffer, T_OFFSET offset_shift = 0);
 
 private:
     bool _evaluated{false};
@@ -69,4 +69,4 @@ class _AdbCondVar_impl
 
 using AdbCondVarLegacy = _AdbCondVar_impl<uint32_t>;
 using AdbCondVar = _AdbCondVar_impl<uint64_t>;
-#endif // ADB_CONDVAR_H
+#endif // ADB_CONDVAR_H

adb_parser/adb_condition.cpp

@@ -248,23 +248,24 @@ void _AdbCondition_impl<T_OFFSET>::update_enum(const string& var_name)
     }
 }
 template<typename T_OFFSET>
-uint64_t _AdbCondition_impl<T_OFFSET>::evaluate(uint8_t* buffer)
+uint64_t _AdbCondition_impl<T_OFFSET>::evaluate(uint8_t* buffer, T_OFFSET offset_shift)
 {
     for (auto& pair : _vars_map)
     {
         const string& var_name = pair.first;
         auto& cond_var = pair.second;
         try
         {
-            cond_var.evaluate(buffer);
+            cond_var.evaluate(buffer, offset_shift);
         }
         catch (const AdbException& e)
         {
             throw AdbException("Failed to evaluate condition variable '" + var_name + "': " + e.what());
         }
     }
     ConditionExpr<T_OFFSET> expr_evaluator(_vars_map);
-    char condition_str_cpy[MAX_CONDITION_SIZE];
+
+    char condition_str_cpy[MAX_CONDITION_SIZE + 1];
     char* condition_str_ptr = condition_str_cpy;
     strncpy(condition_str_cpy, _condition_str.c_str(), MAX_CONDITION_SIZE);
     uint64_t result = 0;

adb_parser/adb_condition.h

@@ -58,7 +58,7 @@ class _AdbCondition_impl
     map<string, AdbCondVar>& get_vars_map();
     const std::string& get_condition() const;
     void update_enum(const std::string& var_name);
-    uint64_t evaluate(uint8_t* buffer);
+    uint64_t evaluate(uint8_t* buffer, T_OFFSET offset_shift = 0);
 
 private:
     void init_variables();
@@ -95,4 +95,4 @@ class ConditionExpr : public Expr
     }
     void Error(const std::string& msg) override;
 };
-#endif // ADB_CONDITION_Hs
+#endif // ADB_CONDITION_Hs

adb_parser/adb_exceptionHolder.cpp

@@ -128,7 +128,7 @@ string ExceptionHolder::printAdbExceptionMap()
     vector<string> warnings = ExceptionHolder::adbExceptionMap[ExceptionHolder::WARN_EXCEPTION];
     for (vector<string>::iterator it = warnings.begin(); it != warnings.end(); ++it)
     {
-        errorStr += "-" + ExceptionHolder::WARN_EXCEPTION + "- " + "- " + *it + ";";
+        errorStr += "-" + ExceptionHolder::WARN_EXCEPTION + "- " + *it + ";";
     }
     return errorStr;
 }

adb_parser/adb_field.cpp

@@ -452,6 +452,22 @@ string AdbField_impl<T_OFFSET>::toXml(const string& addPrefix)
     return xml;
 }
 
+template<typename T_OFFSET>
+bool AdbField_impl<T_OFFSET>::compareFieldsForXmlOutput(AdbField_impl<T_OFFSET>* f1, AdbField_impl<T_OFFSET>* f2)
+{
+    AdbField_impl<T_OFFSET> first = *f1;
+    AdbField_impl<T_OFFSET> second = *f2;
+    if (first.offset / 32 < second.offset / 32)
+    {
+        return true;
+    }
+    else if (first.offset / 32 == second.offset / 32)
+    {
+        return first.offset > second.offset;
+    }
+    return false;
+}
+
 // Explicit instantiations
 template class AdbField_impl<u_int32_t>;
 template class AdbField_impl<u_int64_t>;

adb_parser/adb_field.h

@@ -124,6 +124,10 @@ class AdbField_impl
     bool isReserved{false};
     string condition; // field's visibility dynamic condition
 
+    // FOR USER USAGE
+    // (BigEndian)
+    static bool compareFieldsForXmlOutput(AdbField_impl<T_OFFSET>* f1, AdbField_impl<T_OFFSET>* f2);
+
     // FOR USER USAGE
     void* userData{nullptr};
 };

adb_parser/adb_instance.cpp

@@ -53,24 +53,6 @@
 namespace Regex = mstflint::common::regex;
 namespace Algorithm = mstflint::common::algorithm;
 
-string addPathSuffixForArraySupport(string path)
-{
-    if (path[path.length() - 1] == ']')
-    { // Won't add suffix if leaf is in Array
-        return "";
-    }
-    size_t pos = 0;
-    string suffix = "";
-    while ((pos = path.find("[")) != std::string::npos)
-    { // Add array index number in path to suffix.
-        size_t end_pos = path.find("]");
-        size_t len = end_pos - pos - 1;
-        suffix = suffix + "_" + path.substr(pos + 1, len);
-        path.erase(0, end_pos + 1);
-    }
-    return suffix;
-}
-
 template<bool e, typename T_OFFSET>
 _AdbInstance_impl<e, T_OFFSET>::_AdbInstance_impl(AdbField* i_fieldDesc,
                                                   AdbNode* i_nodeDesc,
@@ -366,6 +348,28 @@ string _AdbInstance_impl<e, O>::evalExpr(string expr, AttrsMap* vars)
     return expr;
 }
 
+/**
+ * Function: _AdbInstance_impl::addPathSuffixForArraySupport
+ **/
+template<bool e, typename O>
+string _AdbInstance_impl<e, O>::addPathSuffixForArraySupport(string path)
+{
+    if (path[path.length() - 1] == ']')
+    { // Won't add suffix if leaf is in Array
+        return "";
+    }
+    size_t pos = 0;
+    string suffix = "";
+    while ((pos = path.find("[")) != std::string::npos)
+    { // Add array index number in path to suffix.
+        size_t end_pos = path.find("]");
+        size_t len = end_pos - pos - 1;
+        suffix = suffix + "_" + path.substr(pos + 1, len);
+        path.erase(0, end_pos + 1);
+    }
+    return suffix;
+}
+
 /**
  * Function: _AdbInstance_impl::_AdbInstance_impl
  **/
@@ -541,6 +545,37 @@ void _AdbInstance_impl<e, O>::init_props(unsigned char adabe_version) // logic o
     {
         return;
     }
+
+    if (parent)
+    {
+        if (!parent->inst_props.valid_array_index)
+        {
+            inst_props.valid_array_index = 0;
+        }
+
+        if (!inst_props.valid_array_index)
+        {
+            inst_props.access_r = 1;
+            inst_props.access_w = 1;
+            inst_props.is_semaphore = 0;
+        }
+        else
+        {
+            if (!parent->inst_props.access_w)
+            {
+                inst_props.access_w = 0;
+            }
+            if (!parent->inst_props.access_r)
+            {
+                inst_props.access_r = 0;
+            }
+            if (parent->inst_props.is_semaphore)
+            {
+                inst_props.is_semaphore = 1;
+            }
+        }
+    }
+
     if (isPartOfArray())
     {
         string fiVal = getInstanceAttr("valid_first_index");
@@ -579,17 +614,28 @@ void _AdbInstance_impl<e, O>::init_props(unsigned char adabe_version) // logic o
     {
         sem = getInstanceAttr("sem");
         access_type = getInstanceAttr("rw");
+        if (access_type.empty())
+        {
+            access_type = getInstanceAttr("access");
+        }
         if (!sem.empty())
         {
             inst_props.is_semaphore = stoi(sem) > 0;
         }
         if (access_type == "WO")
         {
             inst_props.access_r = 0;
+            inst_props.access_w = 1;
         }
         else if (access_type == "RO")
         {
             inst_props.access_w = 0;
+            inst_props.access_r = 1;
+        }
+        else if (access_type == "RW")
+        {
+            inst_props.access_r = 1;
+            inst_props.access_w = 1;
         }
     }
 
@@ -598,36 +644,6 @@ void _AdbInstance_impl<e, O>::init_props(unsigned char adabe_version) // logic o
     {
         inst_props.is_semaphore = stoi(sem) > 0;
     }
-
-    if (parent)
-    {
-        if (!parent->inst_props.valid_array_index)
-        {
-            inst_props.valid_array_index = 0;
-        }
-
-        if (!inst_props.valid_array_index)
-        {
-            inst_props.access_r = 1;
-            inst_props.access_w = 1;
-            inst_props.is_semaphore = 0;
-        }
-        else
-        {
-            // if (parent->inst_ops.access_r && !parent->inst_ops.access_w)
-            // {
-            //     inst_ops.access_w = 0;
-            // }
-            // if (!parent->inst_ops.access_r && parent->inst_ops.access_w)
-            // {
-            //     inst_ops.access_r = 0;
-            // }
-            if (parent->inst_props.is_semaphore)
-            {
-                inst_props.is_semaphore = 1;
-            }
-        }
-    }
 }
 
 /**
@@ -1046,7 +1062,7 @@ template<bool eval_expr, typename O>
 template<bool U>
 typename enable_if<U, _AdbCondition_impl<O>*>::type _AdbInstance_impl<eval_expr, O>::getCondition()
 {
-    return &(inst_ops_props.condition);
+    return inst_ops_props.condition.get_condition().empty() ? nullptr : &(inst_ops_props.condition);
 }
 
 template<bool eval_expr, typename O>
@@ -1056,6 +1072,20 @@ typename enable_if<!U, _AdbCondition_impl<O>*>::type _AdbInstance_impl<eval_expr
     return nullptr;
 }
 
+template<bool eval_expr, typename O>
+template<bool U>
+typename enable_if<U, _AdbCondition_impl<O>*>::type _AdbInstance_impl<eval_expr, O>::getArraySizeCondition()
+{
+    return inst_ops_props.conditionalSize.get_condition().empty() ? nullptr : &(inst_ops_props.conditionalSize);
+}
+
+template<bool eval_expr, typename O>
+template<bool U>
+typename enable_if<!U, _AdbCondition_impl<O>*>::type _AdbInstance_impl<eval_expr, O>::getArraySizeCondition()
+{
+    return nullptr;
+}
+
 /**
  * Function: _AdbInstance_impl::isEnumExists
  **/
@@ -1290,7 +1320,7 @@ _AdbInstance_impl<e, O>* _AdbInstance_impl<e, O>::getUnionSelectedNodeName(const
     }
 
     throw AdbException("Union selector field (" + unionSelector->layout_item_name +
-                       ") doesn't define selector value (" + to_string(selectorVal));
+                       ") doesn't define selector value (" + to_string(selectorVal) + ")");
 }
 
 /**
@@ -1347,6 +1377,30 @@ bool _AdbInstance_impl<e, O>::isConditionalNode()
     return false;
 }
 
+/**
+ * Function: _AdbInstance_impl::containsDynamicArray
+ **/
+template<bool e, typename O>
+bool _AdbInstance_impl<e, O>::containsDynamicArray()
+{
+    if (!isNode())
+    {
+        return false;
+    }
+
+    _AdbInstance_impl<e, O>* last = nullptr;
+    last = subItems.back();
+    while (last)
+    {
+        if (last->fieldDesc->array_type >= AdbField_impl<O>::ArrayType::unlimited)
+        {
+            return true;
+        }
+        last = last->isNode() ? last->subItems.back() : nullptr;
+    }
+    return false;
+}
+
 /**
  * Function: _AdbInstance_impl::isConditionValid
  * Throws exception: AdbException
@@ -1420,7 +1474,8 @@ vector<_AdbInstance_impl<e, O>*> _AdbInstance_impl<e, O>::getLeafFields(bool ext
                 }
                 else
                 {
-                    subItems[i]->layout_item_name += addPathSuffixForArraySupport(subItems[i]->fullName());
+                    subItems[i]->layout_item_name +=
+                      _AdbInstance_impl<e, O>::addPathSuffixForArraySupport(subItems[i]->fullName());
                 }
                 subItems[i]->inst_props.is_name_extended = true;
             }
@@ -1504,6 +1559,22 @@ template typename enable_if<true, _AdbCondition_impl<uint32_t>*>::type
   _AdbInstance_impl<true, uint32_t>::getCondition<true>();
 template typename enable_if<true, _AdbCondition_impl<uint64_t>*>::type
   _AdbInstance_impl<true, uint64_t>::getCondition<true>();
+
+template typename enable_if<!false, _AdbCondition_impl<uint32_t>*>::type
+  _AdbInstance_impl<false, uint32_t>::getCondition<false>();
+template typename enable_if<!false, _AdbCondition_impl<uint64_t>*>::type
+  _AdbInstance_impl<false, uint64_t>::getCondition<false>();
+
+template typename enable_if<true, _AdbCondition_impl<uint32_t>*>::type
+  _AdbInstance_impl<true, uint32_t>::getArraySizeCondition<true>();
+template typename enable_if<true, _AdbCondition_impl<uint64_t>*>::type
+  _AdbInstance_impl<true, uint64_t>::getArraySizeCondition<true>();
+
+template typename enable_if<!false, _AdbCondition_impl<uint32_t>*>::type
+  _AdbInstance_impl<false, uint32_t>::getArraySizeCondition<false>();
+template typename enable_if<!false, _AdbCondition_impl<uint64_t>*>::type
+  _AdbInstance_impl<false, uint64_t>::getArraySizeCondition<false>();
+
 LayoutItemAttrsMap::LayoutItemAttrsMap(AttrsMap& field_desc_attrs) : _field_desc_attrs(field_desc_attrs) {}
 
 LayoutItemAttrsMap& LayoutItemAttrsMap::operator=(const LayoutItemAttrsMap& other)