Version 1.4.19 std::array/std::vector fixed

Author: mikhailmoiseev

sc_tool/lib/sc_tool/SCTool.cpp

@@ -90,8 +90,16 @@ namespace sc {
     );
 
     // Pass command line options to Clang tooling for parsing
-    CommonOptionsParser op(args.argc, args.argv, ScToolCategory);
-    ClangTool Tool(op.getCompilations(), op.getSourcePathList());
+    //CommonOptionsParser op(args.argc, args.argv, ScToolCategory);
+    auto op = CommonOptionsParser::create(args.argc, args.argv, ScToolCategory, 
+                                          llvm::cl::OneOrMore);
+        
+    if (!op) {
+        auto error = op.takeError();
+        outs() << "Errors happen during parsing parameters\n";
+    }
+    
+    ClangTool Tool(op.get().getCompilations(), op.get().getSourcePathList());
 
     // Run SVC
     auto factory = getNewSCElabActionFactory();

sc_tool/lib/sc_tool/SCToolFrontendAction.cpp

@@ -112,8 +112,8 @@ Object* getOuterArray(SCDesign& designDB, Object* memberObj)
     return arrayObj;
 }
 
-const std::string SCElabASTConsumer::TOOL_VERSION = "1.4.18";
-const std::string SCElabASTConsumer::TOOL_DATE = "15 Apr,2022";
+const std::string SCElabASTConsumer::TOOL_VERSION = "1.4.19";
+const std::string SCElabASTConsumer::TOOL_DATE = "22 Apr,2022";
 
 void SCElabASTConsumer::HandleTranslationUnit(clang::ASTContext &astCtx)
 {
@@ -139,7 +139,7 @@ void SCElabASTConsumer::HandleTranslationUnit(clang::ASTContext &astCtx)
     //const char* optNames[] = {doConstCfg, doConstStmt, doModuleBuilder}; 
     //const char* optNames[] = {doGenFuncCall, doGenStmt, doModuleBuilder};  
     //const char* optNames[] = {doConstStmt, doUseDef, doModuleBuilder};  
-    const char* optNames[] = {doUseDef, doConstStmt, doModuleBuilder};  
+    const char* optNames[] = {doModuleBuilder};  
     size_t optSize = sizeof(optNames)/sizeof(const char*);
     //DebugOptions::enable(optNames, optSize); 
 

sc_tool/lib/sc_tool/ScProcAnalyzer.cpp

@@ -543,7 +543,7 @@ void ScProcAnalyzer::initNonDefinedVars(sc_elab::ProcessView& procView,
 //                    cout << "  verVar " << verVar->getName() << endl;
 //                    if (!initVals.empty()) {
 //                        cout << "  add localparam for " << val;
-//                        for (auto& iv : initVals) cout << " " << iv.toString(10);
+//                        for (auto& iv : initVals) cout << " " << sc::APSintToString(iv, 10);
 //                        cout << endl;
 //                    } else {
 //                        cout << "  add localparam for EMPTY" << endl;

sc_tool/lib/sc_tool/cfg/SValue.cpp

@@ -10,6 +10,7 @@
  */
 
 #include "sc_tool/cfg/SValue.h"
+#include "sc_tool/utils/StringFormat.h"
 #include "sc_tool/utils/ScTypeTraits.h"
 #include "sc_tool/utils/CppTypeTraits.h"
 
@@ -513,10 +514,10 @@ string SValue::asString(bool debug) const {
     } else 
     if (isInteger()) {
         char radix = getRadix();
-        if (radix == 10) return getInteger().toString(10);
+        if (radix == 10) return sc::APSintToString(getInteger(), 10);
 
         char prefix = radix == 16 ? 'x' : radix == 8 ? 'o' : 'b';
-        return (prefix + getInteger().toString(radix));
+        return (prefix + sc::APSintToString(getInteger(), radix));
     } else 
     if (isScChannel()) {
         return channel->asString(debug);

sc_tool/lib/sc_tool/cfg/ScState.cpp

@@ -666,6 +666,37 @@ SValue ScState::createArrayInState(clang::QualType arrayType, unsigned level)
     }
 }
 
+SValue ScState::createStdArrayInState(clang::QualType arrayType, unsigned level)
+{
+    if (isStdArray(arrayType)) {
+        auto elmType = getTemplateArgAsType(arrayType, 0);
+        SCT_TOOL_ASSERT (elmType, "createStdArrayInState : No type inferred");
+        auto sizeArg = sc::getTemplateArg(arrayType, 1);
+        SCT_TOOL_ASSERT (sizeArg, "createStdArrayInState : No size inferred");
+        size_t size = sizeArg->getAsIntegral().getZExtValue();
+        
+        // Create array object
+        SValue arrayRootVal = SValue(*elmType, size, 0);
+        
+        // Fill array with elements
+        for (unsigned i = 0; i < size; i++) {
+            // Recursive call to create sub-arrays
+            SValue eval = createStdArrayInState(*elmType, level);
+            // Put sub_array value into @aval
+            arrayRootVal.getArray().setOffset(i);
+            putValue(arrayRootVal, eval, false); //@val -> @eval
+            setValueLevel(arrayRootVal, level);
+        }
+        if (arrayRootVal.getArray().getSize() > 0) {
+            arrayRootVal.getArray().setOffset(0);
+        }
+        return arrayRootVal;
+        
+    } else {
+        return NO_VALUE;
+    }
+}
+
 // \return <value found, array with unknown index returned>
 std::pair<bool, bool> 
 ScState::getValue(const SValue& lval, SValue& rval, bool deReference,
@@ -1671,7 +1702,7 @@ vector<SValue>ScState::getAllRecordArrayElementsForAny(const SValue& val,
 
 // Is value simple enough to store its value, if not no value put to state 
 // Not used for now
-bool ScState::isSimpleValue(const SValue& val) const 
+/*bool ScState::isSimpleValue(const SValue& val) const 
 {
     // Go up and count array number
     vector<SValue> valStack;
@@ -1693,7 +1724,7 @@ bool ScState::isSimpleValue(const SValue& val) const
     const QualType& type = val.getType();
     bool comlType = (arrNum == 1) && sc::isArray(type);
     return !comlType;
-}
+}*/
 
 // Get all fields for given record value with 
 // TODO: update for inner records

sc_tool/lib/sc_tool/cfg/ScState.h

@@ -336,9 +336,12 @@ class ScState
     /// re-declaration which required to get variable for value
     void removeSubValues(const SValue& val);
 
-    /// Recursively create multi-dimensional array and its elements at
-    /// specified value level
+    /// Recursively create multi-dimensional array and its elements 
+    /// at specified value level
     SValue createArrayInState(clang::QualType arrayType, unsigned level = 0);
+    /// Recursively create multi-dimensional std::array and its elements 
+    /// at specified value level
+    SValue createStdArrayInState(clang::QualType arrayType, unsigned level = 0);
 
     /// Get value of @lval into @rval, set @rval into @NO_VALUE if no value for
     /// @lval found
@@ -527,7 +530,8 @@ class ScState
                                 unsigned crossModule = 0) const;
 
     /// Is value simple enough to store its value, if not no value put to state 
-    bool isSimpleValue(const SValue& val) const;
+    /// Not used
+    ///bool isSimpleValue(const SValue& val) const;
 
     /// Get all fields for given record value with 
     InsertionOrderSet<SValue> getRecordFields(const SValue& recval) const;

sc_tool/lib/sc_tool/cfg/ScTraverseCommon.cpp

@@ -34,7 +34,8 @@ bool sc::isUserCallExpr(clang::Stmt* stmt)
             (((nsname && *nsname == "std") || isLinkageDecl(funcDecl)) &&
                (fname == "printf" || fname == "fprintf" || 
                 fname == "sprintf" || fname == "snprintf" ||
-                fname == "fopen" || fname == "fclose"))) {
+                fname == "fopen" || fname == "fclose" || 
+                fname == "operator[]"))) {
             return false;
         }
         return true;

sc_tool/lib/sc_tool/cthread/ScThreadBuilder.cpp

@@ -24,6 +24,7 @@
 #include "sc_tool/ScCommandLine.h"
 #include "sc_tool/utils/BitUtils.h"
 #include "sc_tool/utils/VerilogKeywords.h"
+#include <llvm/Support/Debug.h>
 #include <sstream>
 
 using namespace llvm;

sc_tool/lib/sc_tool/diag/ScToolDiagnostic.h

@@ -201,6 +201,8 @@ class ScDiag {
         CPP_FOR_WITHOUT_DECL        = 229,
         SYNTH_PART_INIT_VAR         = 230,
         CPP_STRING_BINARY_OPER      = 231,
+        CPP_STATIC_STD_VECTOR       = 232,
+        SYNTH_LITER_OVERFLOW        = 233,
 
         SC_FATAL_ELAB_TYPES_NS      = 300,
         SC_WARN_ELAB_UNSUPPORTED_TYPE,
@@ -698,6 +700,14 @@ class ScDiag {
             {clang::DiagnosticIDs::Error, 
             "Binary operation with string argument not supported"};
 
+        idFormatMap[CPP_STATIC_STD_VECTOR] =
+            {clang::DiagnosticIDs::Error, 
+            "Static std::vector is not supportd yet"};
+        
+        idFormatMap[SYNTH_LITER_OVERFLOW] =
+            {clang::DiagnosticIDs::Error, 
+            "Literal is too big, up to 4096 symbols supported"};
+        
         // Elaboration
         idFormatMap[SC_FATAL_ELAB_TYPES_NS] =
             {clang::DiagnosticIDs::Fatal,
@@ -857,5 +867,5 @@ class ScDiag {
 } // end namespace sc
 
 
-
+    
 #endif //SCTOOL_SCTOOLDIAGNOSTIC_H

sc_tool/lib/sc_tool/dyn_elab/Reflection.cpp

@@ -9,6 +9,8 @@
  * Author: Roman Popov
  */
 
+
+#include <sc_tool/utils/CppTypeTraits.h>
 #include <sc_tool/dyn_elab/Reflection.h>
 #include <sc_tool/dyn_elab/GlobalContext.h>
 
@@ -410,6 +412,9 @@ ArrayObject::getArrayObjectKind(clang::QualType canonicalType)
 
         if (isStdVector(canonicalType))
             return ArrayObject::STD_VECTOR;
+        
+        if (isStdArray(canonicalType))
+            return ArrayObject::STD_ARRAY;
     }
 
     return llvm::None;
@@ -445,6 +450,14 @@ size_t ArrayObject::size() const
             return byteVec->size() / elSize;
         }
 
+        case STD_ARRAY: {
+            auto type = typedObj.getType();
+            auto tempArg = sc::getTemplateArg(type, 1);
+            size_t size = tempArg->getAsIntegral().getZExtValue();
+            
+            return size;
+        }
+
         case SC_VECTOR: {
             return getScVecInner(typedObj)->size();
         }
@@ -478,6 +491,12 @@ TypedObject ArrayObject::operator[](size_t idx) const
             startPtr = byteVec->data();
             elPtr = startPtr + idx * sizeOfEl;
         } break;
+        
+        case STD_ARRAY: {
+            std::array<uint8_t, 1> *byteVec =(std::array<uint8_t,1>*) typedObj.getPtr();
+            startPtr = byteVec->data();
+            elPtr = startPtr + idx * sizeOfEl;
+        } break;
 
         case SC_VECTOR:
             elPtr = getScVecInner(typedObj)->at(idx);