SystemC Library and Application C++ Standard Version Conflict
The core issue revolves around a mismatch between the C++ standard used to compile the SystemC library provided with ARM Fast Models v11.15 and the C++ standard used to compile the consumer application. The SystemC library in Fast Models v11.15 is compiled with C++11 support, while the application in question is compiled with C++14. This discrepancy leads to linker errors, specifically undefined references to symbols that are versioned based on the C++ standard used during compilation.
The error message indicates that the application is attempting to link against a version of the SystemC library that expects C++11 symbols, but the application is providing C++14 symbols. This is evident from the undefined reference to sc_core::sc_api_version_2_3_3_cxx201402L, where cxx201402L denotes the C++14 standard. The SystemC library, however, is compiled with C++11, which uses a different symbol versioning scheme.
The SystemC library relies on the C++ standard version for symbol versioning and API compatibility. When the library and the application are compiled with different C++ standards, the symbol names do not match, leading to linker errors. This is a common issue when dealing with libraries that are tightly coupled to the C++ standard version, as is the case with SystemC.
C++ Standard Version Mismatch and Symbol Versioning
The primary cause of the issue is the mismatch in C++ standard versions between the SystemC library and the application. The SystemC library provided with ARM Fast Models v11.15 is compiled with C++11, while the application is compiled with C++14. This discrepancy leads to symbol versioning issues, as the C++ standard version is embedded in the symbol names.
The SystemC library uses a feature of the C++ language known as "symbol versioning" to ensure that the correct version of the library is linked against the application. Symbol versioning is a mechanism that allows multiple versions of a library to coexist in the same binary, with each version having its own set of symbols. This is particularly important for libraries like SystemC, which may have different versions that are not backward compatible.
When the SystemC library is compiled with C++11, the symbols are versioned with cxx201103L, which corresponds to the C++11 standard. When the application is compiled with C++14, the symbols are versioned with cxx201402L, which corresponds to the C++14 standard. The linker is unable to resolve the symbols because the version strings do not match.
Another contributing factor is the lack of explicit documentation or warnings about the C++ standard version used to compile the SystemC library. While the ARM documentation does mention that Fast Models is compiled with C++11 support, this information is not always readily accessible or highlighted, leading to potential oversights during the application development process.
Resolving C++ Standard Mismatch and Ensuring Compatibility
To resolve the C++ standard mismatch and ensure compatibility between the SystemC library and the application, the following steps should be taken:
Step 1: Verify the C++ Standard Version Used by the SystemC Library
The first step is to verify the C++ standard version used to compile the SystemC library. This can be done by examining the documentation provided with ARM Fast Models v11.15 or by inspecting the library itself using tools like nm or objdump. The documentation explicitly states that Fast Models is compiled with C++11 support, so this should be confirmed before proceeding.
Step 2: Compile the Application with the Same C++ Standard Version
Once the C++ standard version used by the SystemC library has been confirmed, the application should be compiled with the same version. In this case, the application should be compiled with C++11. This can be achieved by specifying the -std=c++11 flag when invoking the compiler. For example, if using gcc, the command would be:
g++ -std=c++11 -o my_application my_application.cpp -lSystemC
This ensures that both the application and the SystemC library are compiled with the same C++ standard version, eliminating the symbol versioning mismatch.
Step 3: Update Build System Configuration
If the application is built using a build system like CMake, the build configuration should be updated to enforce the use of C++11. This can be done by adding the following line to the CMakeLists.txt file:
set(CMAKE_CXX_STANDARD 11)
This ensures that all source files in the project are compiled with C++11, regardless of the default compiler settings.
Step 4: Test the Application with the Correct C++ Standard Version
After updating the build configuration, the application should be rebuilt and tested to ensure that the linker errors have been resolved. The application should now link successfully against the SystemC library, and any runtime behavior should be consistent with expectations.
Step 5: Document the C++ Standard Version Requirement
To prevent similar issues in the future, the C++ standard version requirement should be clearly documented in the project’s build instructions and README files. This ensures that all developers working on the project are aware of the requirement and can configure their development environment accordingly.
Step 6: Consider Upgrading to a Newer Version of Fast Models
If the project requirements allow, consider upgrading to a newer version of ARM Fast Models that may support a more recent C++ standard. Newer versions of Fast Models may be compiled with C++14 or later, which could align better with the application’s requirements. However, this should be done with caution, as upgrading to a newer version of Fast Models may introduce other compatibility issues that need to be addressed.
Step 7: Handle Multiple C++ Standard Versions in the Codebase
In some cases, it may be necessary to support multiple C++ standard versions in the same codebase. This can be achieved using preprocessor directives to conditionally compile code based on the C++ standard version. For example:
#if __cplusplus >= 201402L
// C++14 or later code
#else
// C++11 code
#endif
This approach allows the codebase to be compatible with multiple C++ standard versions, but it should be used sparingly to avoid complicating the codebase.
Step 8: Monitor for Future Updates and Compatibility Issues
Finally, it is important to monitor for future updates to the SystemC library and ARM Fast Models, as well as any changes to the C++ standard. This ensures that the project remains compatible with the latest tools and libraries, and any potential issues can be addressed proactively.
By following these steps, the C++ standard mismatch between the SystemC library and the application can be resolved, ensuring a smooth integration and avoiding linker errors. This approach also helps to future-proof the project by documenting the C++ standard version requirement and considering potential upgrades to newer versions of Fast Models.
