GCC Testsuite Report: Commit 80b0e4ad2f60 - Unresolved Failures

Hey everyone,

Here's the GCC testsuite status report for commit 80b0e4ad2f60de8bd57e83628b4ead46df6fb004. This report provides a summary of the test results for the gcc, g++, and gfortran compilers across various configurations. We'll break down the new failures, resolved failures, and unresolved failures to give you a clear picture of the current state. Let's dive in!

Summary

First, let's take a look at the summary tables. These tables provide a quick overview of the testsuite results, highlighting new failures, resolved failures, and unresolved failures.

Analyzing the Unresolved Failures

Okay, let's break down these unresolved failures. We need to understand what's going on, so we can tackle these issues effectively. It looks like a significant portion of the failures are concentrated in specific configurations, so let's take a closer look at those.

Linux Configurations

• linux: RVA23U64 profile lp64d medlow multilib: This configuration shows a high number of failures, with 2866 failures in gcc, 53 in g++, and 163 in gfortran. It seems like this specific profile and multilib setup is causing some serious headaches. The lp64d indicates a 64-bit long pointer and double floating-point ABI, and medlow likely refers to a medium-low code model. This combination, along with the multilib aspect, suggests potential issues in handling different code generation scenarios. Understanding the root cause here is crucial for ensuring stability across various architectures.

• linux: rv32 Bitmanip ilp32d medlow: For this configuration, we see 189 gcc failures, 29 g++ failures, and 14 gfortran failures. The rv32 indicates a 32-bit RISC-V architecture, Bitmanip suggests the inclusion of bit manipulation extensions, and ilp32d refers to a 32-bit integer, long, and pointer with double floating-point ABI. This points to potential problems within the bit manipulation extensions or the interaction between 32-bit integer and double-precision floating-point operations. It's essential to pinpoint these issues to ensure the proper functioning of bit manipulation features on 32-bit RISC-V systems.

• linux: rv32gc ilp32d medlow: Similar to the previous configuration, this one has 189 gcc failures, 29 g++ failures, and 14 gfortran failures. Here, rv32gc implies a 32-bit RISC-V architecture with the general-purpose 'C' extension. The consistency in the number of failures compared to the Bitmanip configuration might suggest an underlying issue related to the 32-bit RISC-V architecture itself, rather than just the bit manipulation extensions. Investigating the core 32-bit instruction set and its interactions with other features could be key to resolving these failures.

• linux: rv32gcv ilp32d medlow multilib: This configuration has a significant number of failures: 2865 in gcc, 61 in g++, and 251 in gfortran. The rv32gcv indicates a 32-bit RISC-V architecture with general-purpose, compressed, and vector extensions. The high failure count, especially in gcc and gfortran, suggests possible issues within the vector extensions or how they interact with the rest of the toolchain. The multilib aspect adds another layer of complexity, hinting at potential problems in generating code for different library variants. A thorough examination of the vector extension implementation and its integration with the compiler's code generation pipeline is necessary.

• linux: rv64 Bitmanip lp64d medlow: We observe 172 gcc failures, 29 g++ failures, and 14 gfortran failures in this configuration. The rv64 points to a 64-bit RISC-V architecture, and lp64d indicates a 64-bit long pointer and double floating-point ABI. Similar to the 32-bit Bitmanip configuration, the failures here could stem from issues within the bit manipulation extensions, but in the context of a 64-bit environment. Verifying the correctness of bit manipulation operations and their performance on 64-bit systems is vital.

• linux: rv64 Vector Crypto lp64d medlow multilib: This configuration shows substantial failures: 2916 in gcc, 53 in g++, and 163 in gfortran. The rv64 indicates a 64-bit RISC-V architecture, Vector Crypto suggests the inclusion of vector and cryptographic extensions, and lp64d represents a 64-bit long pointer and double floating-point ABI. The combination of vector and cryptographic extensions, along with the multilib setting, likely introduces significant complexity. Failures in this area might be due to incorrect code generation for vector or cryptographic operations, or issues arising from the interaction between these extensions and different library variants. A detailed review of the generated assembly code and the behavior of the cryptographic functions is crucial.

• linux: rv64gc lp64d medlow: This setup has 172 gcc failures, 29 g++ failures, and 14 gfortran failures. The rv64gc implies a 64-bit RISC-V architecture with the general-purpose 'C' extension. The similar number of failures compared to the 64-bit Bitmanip configuration could point to a general issue within the 64-bit RISC-V architecture's core instruction set. A comprehensive analysis of the instruction set architecture (ISA) implementation and its interaction with the compiler is needed.

• linux: rv64gcv lp64d medlow multilib: We see 2864 gcc failures, 53 g++ failures, and 163 gfortran failures in this configuration. The rv64gcv indicates a 64-bit RISC-V architecture with general-purpose, compressed, and vector extensions. Similar to the 32-bit rv32gcv configuration, the high failure count suggests potential problems within the vector extensions or how they interact with other parts of the compiler. The multilib aspect further complicates matters, potentially introducing issues related to library compatibility. Investigating the vector extension implementation and its interaction with the code generation pipeline, particularly in a multilib environment, is critical.

Newlib Configurations

Now, let's shift our focus to the Newlib configurations. Newlib is a C standard library implementation often used in embedded systems, and it's important to ensure that our toolchain works well with it.

• newlib: RVA23U64 profile lp64d medlow multilib: This configuration shows 2852 gcc failures and 57 g++ failures. The RVA23U64 profile likely refers to a specific RISC-V architecture profile, lp64d is the 64-bit long pointer and double floating-point ABI, and medlow is a medium-low code model. The multilib aspect suggests that the issues might be related to how the compiler generates code for different variants of the Newlib library. It's crucial to understand which parts of Newlib are causing these failures and whether it's a code generation problem or a library issue.

• newlib: rv32 Bitmanip ilp32d medlow: Here, we see 386 gcc failures and 33 g++ failures. The rv32 indicates a 32-bit RISC-V architecture, Bitmanip points to bit manipulation extensions, and ilp32d represents a 32-bit integer, long, and pointer with double floating-point ABI. The failures might be due to the interaction between the bit manipulation extensions and the Newlib library, especially in a 32-bit environment. Examining the generated code for bit manipulation operations and how they interface with Newlib functions is essential.

• newlib: rv32gc ilp32d medlow: This configuration has 203 gcc failures and 33 g++ failures. The rv32gc indicates a 32-bit RISC-V architecture with the general-purpose 'C' extension. The failures could be related to the core 32-bit RISC-V instruction set or how it interacts with Newlib. Investigating the system calls and standard library functions used by Newlib in this configuration is crucial.

• newlib: rv32gcv ilp32d medlow multilib: We observe 3021 gcc failures and 65 g++ failures in this configuration. The rv32gcv indicates a 32-bit RISC-V architecture with general-purpose, compressed, and vector extensions. The high failure count suggests potential issues within the vector extensions or their interaction with Newlib. The multilib aspect adds complexity, hinting at potential problems in library variant compatibility. Analyzing the generated code for vector operations and their interaction with Newlib, especially in a multilib setting, is critical.

• newlib: rv32imac ilp32 medlow multilib: This configuration shows a very high number of failures: 24817 in gcc and 10748 in g++. The rv32imac indicates a 32-bit RISC-V architecture with integer, multiply/divide, atomic, and compressed extensions. The sheer number of failures suggests a fundamental issue, possibly related to the code generation for these core extensions or their interaction with Newlib. A deep dive into the generated assembly code and the behavior of the compiler's backend for these extensions is necessary.

• newlib: rv32imac_zba_zbb_zbc_zbs ilp32 medlow multilib: Similar to the previous configuration, this one has a very high failure count: 24915 in gcc and 10748 in g++. The added _zba_zbb_zbc_zbs indicates the inclusion of bit manipulation extensions. The consistent failure count suggests that the core issue likely lies within the rv32imac extensions themselves, rather than the bit manipulation extensions. However, the interaction between these extensions and Newlib still needs to be investigated.

• newlib: rv32imc ilp32 medlow multilib: Again, we see a high number of failures: 24782 in gcc and 10748 in g++. The rv32imc indicates a 32-bit RISC-V architecture with integer, multiply/divide, and compressed extensions. The consistency in failure counts across these rv32im* configurations strongly suggests a core problem within the code generation or runtime support for these fundamental extensions when using Newlib.

• newlib: rv32imc_zba_zbb_zbc_zbs ilp32 medlow multilib: This configuration also exhibits high failure counts: 24880 in gcc and 10748 in g++. The inclusion of bit manipulation extensions (_zba_zbb_zbc_zbs) doesn't seem to significantly alter the number of failures, further indicating that the root cause is likely in the rv32imc extensions or their interaction with Newlib.

• newlib: rv32imc_zba_zbb_zbc_zbs_zicsr_zifencei ilp32 medlow multilib: The failure counts remain high: 24880 in gcc and 10748 in g++. The added _zicsr_zifencei indicates control and fence instructions, but the consistent failure pattern suggests that the problem isn't specific to these instructions. It's more likely a general issue within the core rv32imc extensions and their Newlib integration.

• newlib: rv32imc_zicsr_zifencei ilp32 medlow multilib: The high failure counts persist: 24782 in gcc and 10748 in g++. This reinforces the idea that the problem is not isolated to the control and fence instructions (_zicsr_zifencei) but is more likely a fundamental issue within the rv32imc extensions and their interaction with Newlib.

• newlib: rv64 Bitmanip lp64d medlow: We see 186 gcc failures and 33 g++ failures in this configuration. The rv64 indicates a 64-bit RISC-V architecture, Bitmanip points to bit manipulation extensions, and lp64d is the 64-bit ABI. The failures here could be due to the interaction between the bit manipulation extensions and Newlib in a 64-bit environment. It's important to verify the correctness of bit manipulation operations when using Newlib in 64-bit mode.

• newlib: rv64 Vector Crypto lp64d medlow multilib: This configuration has 2902 gcc failures and 57 g++ failures. The rv64 indicates a 64-bit RISC-V architecture, Vector Crypto suggests vector and cryptographic extensions, and lp64d represents the 64-bit ABI. The failures might be related to the vector or cryptographic extensions or their interaction with Newlib. The multilib aspect adds complexity, hinting at potential library variant compatibility issues. A detailed analysis of the generated code for vector and cryptographic operations and their interaction with Newlib is needed.

• newlib: rv64gc lp64d medlow: We observe 186 gcc failures and 33 g++ failures in this configuration. The rv64gc indicates a 64-bit RISC-V architecture with the general-purpose 'C' extension. The failures could be due to issues with the core 64-bit RISC-V instruction set or its interaction with Newlib. Examining the system calls and standard library functions used by Newlib in this configuration is crucial.

• newlib: rv64gcv lp64d medlow multilib: This configuration shows 2850 gcc failures and 57 g++ failures. The rv64gcv indicates a 64-bit RISC-V architecture with general-purpose, compressed, and vector extensions. The failures might be related to the vector extensions or their interaction with Newlib. The multilib aspect suggests potential library compatibility issues. Analyzing the generated code for vector operations and their interaction with Newlib in a multilib environment is essential.

• newlib: rv64imac lp64 medlow multilib: We see 194 gcc failures and 33 g++ failures in this configuration. The rv64imac indicates a 64-bit RISC-V architecture with integer, multiply/divide, atomic, and compressed extensions. The failures could be related to the code generation for these core extensions or their interaction with Newlib. A deep dive into the generated assembly code and the behavior of the compiler's backend for these extensions is necessary.

• newlib: rv64imac_zba_zbb_zbc_zbs lp64 medlow multilib: This configuration has a very high number of failures: 25255 in gcc and 10792 in g++. The added _zba_zbb_zbc_zbs indicates the inclusion of bit manipulation extensions. The sheer number of failures suggests a fundamental issue, possibly related to the interaction between the rv64imac extensions, bit manipulation extensions, and Newlib. A comprehensive analysis of the generated code for these extensions and their interplay with Newlib is needed.

• newlib: rv64imc lp64 medlow multilib: Again, we see a high number of failures: 201 gcc failures and 33 g++ failures. The rv64imc indicates a 64-bit RISC-V architecture with integer, multiply/divide, and compressed extensions. The failures could be related to the core 64-bit RISC-V instruction set or its interaction with Newlib. Investigating the system calls and standard library functions used by Newlib in this configuration is crucial.

• newlib: rv64imc_zba_zbb_zbc_zbs lp64 medlow multilib: This configuration also exhibits high failure counts: 25220 in gcc and 10792 in g++. The inclusion of bit manipulation extensions (_zba_zbb_zbc_zbs) doesn't seem to significantly alter the number of failures, further indicating that the root cause is likely in the rv64imc extensions or their interaction with Newlib.

• newlib: rv64imc_zba_zbb_zbc_zbs_zicsr_zifencei lp64 medlow multilib: The failure counts remain high: 25220 in gcc and 10792 in g++. The added _zicsr_zifencei indicates control and fence instructions, but the consistent failure pattern suggests that the problem isn't specific to these instructions. It's more likely a general issue within the core rv64imc extensions and their Newlib integration.

• newlib: rv64imc_zicsr_zifencei lp64 medlow multilib: The high failure counts persist: 201 gcc failures and 33 g++ failures. This reinforces the idea that the problem is not isolated to the control and fence instructions (_zicsr_zifencei) but is more likely a fundamental issue within the rv64imc extensions and their interaction with Newlib.

Key Takeaways and Next Steps

Based on the analysis, here are some key takeaways:

1. RV32 and RV64 Architectures: There are recurring failures across both 32-bit and 64-bit RISC-V architectures, suggesting underlying issues within the architecture-specific code generation or runtime support.
2. Newlib Integration: A significant number of failures are observed when using Newlib, particularly with configurations involving rv32im* and rv64im* extensions. This points to potential problems in the interaction between the compiler-generated code for these extensions and the Newlib library.
3. Vector and Crypto Extensions: The configurations involving vector and cryptographic extensions (rv*gcv, Vector Crypto) also show a high number of failures, indicating possible issues within these extensions or their interaction with other features and libraries.
4. Multilib Configurations: The presence of multilib in many failing configurations suggests potential problems in generating code that is compatible with different library variants. This area requires careful attention to ensure that the compiler can handle multilib scenarios correctly.

To address these issues, the following steps are recommended:

1. Detailed Failure Analysis: Investigate specific failure logs and test cases to understand the exact nature of the problems. This will help in identifying the root causes and developing targeted fixes.
2. Code Generation Review: Carefully review the generated assembly code for the failing configurations, paying close attention to the instructions used for the RISC-V extensions and their interaction with Newlib.
3. Newlib Interaction: Analyze the interface between the compiler-generated code and the Newlib library functions. This includes examining system calls, standard library functions, and any assumptions made by the compiler about Newlib's behavior.
4. Multilib Handling: Ensure that the compiler correctly handles multilib configurations by generating code that is compatible with different library variants. This might involve adjusting code generation strategies or adding specific multilib support code.
5. Community Collaboration: Engage with the RISC-V and GCC communities to share findings, discuss potential solutions, and collaborate on fixes. This will help in leveraging the collective expertise of the community and ensuring the long-term stability of the toolchain.

Associated Run

For more details, you can check out the associated run on GitHub Actions:

https://github.com/patrick-rivos/gcc-postcommit-ci/actions/runs/16830880741

This link provides access to the full logs and test results, which can be invaluable for debugging and fixing the identified issues.

That's all for this report, folks! Let's keep pushing forward to make GCC even better. If you have any insights or want to discuss further, feel free to chime in!