<table border="1" cellspacing="0" cellpadding="8">
    <tr>
        <th>Issue</th>
        <td>
            <a href=https://github.com/llvm/llvm-project/issues/70495>70495</a>
        </td>
    </tr>

    <tr>
        <th>Summary</th>
        <td>
            Incorrect Output with -O3 Optimization on MIPS64 Due to Complex Type Casting and Nested Loop Structure
        </td>
    </tr>

    <tr>
      <th>Labels</th>
      <td>
            new issue
      </td>
    </tr>

    <tr>
      <th>Assignees</th>
      <td>
      </td>
    </tr>

    <tr>
      <th>Reporter</th>
      <td>
          gyuminb
      </td>
    </tr>
</table>

<pre>
    ### **Description:**

When compiling the given PoC on MIPS64 architecture with Clang-18, an unexpected behavior arises exclusively under **`-O3`** optimization. The issue seems to be related to complex type casting, especially involving **`_Bool`**, and the nested loop structure. The program exhibits different outputs when optimization level **`-O3`** is applied as compared to **`-O0`**, **`-O1`**, and **`-O2`**.

### **Environment:**

- **Compiler**: Clang-18
- **Target Architecture**: MIPS64
- **Optimization Level**: This issue is exclusively observed at **`O3`** optimization level.

### ****PoC:****

```c
#include <stdio.h>

short short_val = 1;
long long int flag_val = 0x0123456789abcdefLL;
_Bool bool_flag = 0;
unsigned long long int ull_result = 0ULL;
short short_array[18][18];
int int_array[18][18][18];
_Bool bool_array[15][15];
long long int result_array[15];
unsigned long long int subtraction_const = 18446744073709526850ULL;

void init() {
 for (size_t i = 0; i < 18; ++i) 
        for (size_t j = 0; j < 18; ++j) {
            short_array[i][j] = (short)-24751; // Represents 18446744073709526865 when interpreted as unsigned long long due t overflow.
            for (size_t k = 0; k < 18; ++k) 
 int_array[i][j][k] = 1;
        }
    
    for (size_t i = 0; i < 15; ++i) 
        for (size_t j = 0; j < 15; ++j)
 bool_array[i][j] = 1;

    for (size_t i = 0; i < 15; ++i) 
 result_array[i] = (i % 2 == 0) ? 1LL : 0LL;
}

#define max(a,b) \
    ({ __typeof__ (a) _a = (a); \
       __typeof__ (b) _b = (b); \
       _a > _b ? _a : _b; })

int main() {
    init();
 for (_Bool flag = 0; flag < 1; flag += (_Bool)1) 
    {
        for (int i = 0; i < 12; i += 2) 
        {
            for (int j = 0; j < 13; j += 3) 
            {
                
                for (unsigned long long int k = 0; k < ((unsigned long long int) max(((_Bool) int_array[i][0][0] ? (int) short_array[i][0] : 1), ((_Bool) int_array[0][0][i] ? (int) short_array[i][0] : int_array[i][0][0]))) - subtraction_const/*15*/; k++)
                {
                    if (((_Bool) flag_val))
                    {
 bool_flag = (_Bool) max((bool_flag), ((_Bool) short_val));
 ull_result = (unsigned long long int) (max((int) bool_array[0][i], 0) % (int) int_array[0][j][k]);
                    }
 }
            } 
        } 
        result_array [flag] = ((long long int) ((int) ((flag_val))));
    }
    printf("result_array [0]: %lx\n", result_array [0]);  
}
```

### **Expected Behavior:**

The output for **`result_array[0]`** should remain consistent across different optimization levels.

### **Observed Behavior:**

At **`-O3`** optimization level, the output for **`result_array[0]`** deviates from the expected result, as seen in the other optimization levels (**`-O0`**, **`-O1`**, and **`-O2`**).

### **Analysis:**

The bug appears to stem from a combination of factors:

1. Complex type casting, notably involving the **`_Bool`** type.
2. The nested loop structure, particularly the **`for`** loop containing an intricate calculation for its boundary condition.
3. A series of assignments and type castings leading up to the assignment of **`result_array[flag]`**.

When these factors interplay under **`-O3`** optimization, the compiler might be making incorrect assumptions or optimizations that lead to the observed discrepancy.

### **Steps to Reproduce:**

1. Compile the PoC code using Clang-18 on MIPS64 with **`O3`** optimization.
2. Execute the compiled binary.
3. Notice the different output for **`result_array[0]`** as compared to other optimization levels.

### **Evidence:**

Outputs from various optimization levels:

```
-O0, -O1, -O2 Output:
result_array [0]: ffffffff89abcdef

-O3 Output:
result_array [0]: 123456789abcdef
```

### **Conclusion:**

The **`-O3`** optimization level in Clang-18 for MIPS64 introduces a distinct behavior in the provided PoC, which is not observed at lower optimization levels. Given the complexity of the code, especially around type casting and loop structures, there seems to be a misoptimization issue in the compiler. This inconsistency raises concerns about the reliability of high-level optimizations in certain scenarios and warrants a thorough investigation.
</pre>
<img width="1px" height="1px" alt="" src="http://email.email.llvm.org/o/eJysWFuP4joS_jXul1Kj4BAuDzxwmV4dqffMaGdW-4icpCCeMXZkO3Rzfv3Kdu5Az8yeRQhyqSrXzZ-rihnDTxJxTZItSfZPrLKF0uvTtTpzmT6lKr-uCY3DFwjdELrZo8k0Ly1XksSb8IxEexLVv_8pUEKmziUXXJ7AFggnfkEJX9QOlIR__vHl63wGTGcFt5jZSiO8cVvATjB5ep4uCd0Bk1BJfC8xs5hDigW7cKWBaW7QAL5nojL8guIKlcxR16qRefT8OSbzKNyCKi0_87-Y03UC3woEbkyFYBDPBqyCFEGjYG4Nq7zSAt_BXkuEjBnL5ckpg6bEjDMhrsDlRYmLs6td8bBVSrRrBuVzb7ZE4yQLpUowVlfe1qBHqdVJszPge8FTbg3k_HhEjdKCqmxZWQNvzo99C0DgBcUDU7kBVpaCYw7MeEuYDlb16KOBmr0X0xv9ey9p-3LSj_M4Lz7JC9dKnlHau3nxXNPtfGqgriniTRf4Ad03pk9oYdPLk44lJNGQ4XPfV6_OVx39t4KbOvh8mD8qNagvzm22M_pREoUQfOiG8P2idp0TblzhhPtv1srgMhNVjkDinbE5V5OCxJ_6PKZQ2oL_PVyYABLvYUribXgrlDyB_-HSwlGwU0sUvUdTGs-S-WK5YmmW4_H1teXzyQupUuLgmAJD-7aSHh5yGIqvhDhoNJWwgf7fPYF9NZnW7EqS7XRJkn3731A6SVw-ohpT9xRtGZKaMOkTDlUNao5YfmKeqVKrWebifciUNMHK6XI2my9ms2gRL6JVQufLZGB4-L0ongOX3BK6JHQFZFG_hqNyKLU0_C88WOCtp_3lDqZLd03oltAt95yBrf4Mub933N9vuL8P1-19hlHhwXvfSbL34px4R0Do6pnOFsk0iHwh9AX-haVGg9KaO36YJwGruLSoS402YNAd7-YVggV1QX0U6m1yq-HQzB-dmT9uzPzRc1I_jXpmkWT7o7Gu2yrNWmSx7x50Vz-LU_K34pQM41QzD9J6HJfpKMX-hpKj3cB7oedAaALU3QZhjit-genrKzgAjfqp3niuRa8cj1winNk7oUtG6C71_Mmu52G6JIstHA7udFXHwwEC6QoOrFHC3XrN-4wAIyYv-5A2TOkjJif2UyB8CXcbOKSedLFvnd-B0ZlxebNtAXrbucuhOgABlQbI2dztfODqO7qtlQ3FAl1Nh6lzs11r-R4jb6JL6-sgld5m4d3d3xN5m5dxfR1ExrciH4od7p47Cz5A2ZvN7V38gNrpE5IrfBs33tv5UffnIx9sdsR38a-m24ALSSiLHq4QDVbgv7vCx8r65d0Xnm-PII_Dm2nia4kX77SwvTsQGcfkUbB8Sh_h1pdN1VAr8pC5kzysG_qy2mC1JPe929Yz9aLtBhvVGB9mBqHLdr360QBRe_FyKgRso0kvbneC3DtABorddUhzkgzOlN7rm_05ftJHZiDJ1nusQ2dCl_es7gwIN6MIjlw6PvNKzaU9ek46Xt87Id44N4l3kuwkodT57i5dwF8YHw5Nkfth09C0eNu6xbvbOriOKbRFNajUZfroPPPKtHW7KVQlctDocB3cLuLGugaLZVqZQcd1U-GbD0v8z03L8KHSG_sLXWlYznnW_i825njhzKKBo1ZnL6LtmQOfb-eMa3hdfRYWsQXqezaHJPq_NYuErj704kYycTXcPIx4Wp1cT4tM-17dWDwHO5nrb1Mug_LqCEeWWaW9pJ6M6QR2Dzp6qSxLB-2888yDlt5z16bQ0L7f7eyd4JJpy7NKMC2uQ5lHpTuJnjFT0jIu3erMV8-aZ8w6PYWT4I1zqcCtgVRVMmf66phy7ucZQaF4AhswqDka54kw0Dn7St2PIXqGGxDIcrdcVTqHOvU6esf9KOlqNLo_B_DzHlugwSYOdScg2K9PZ5odkNXDATjzU2EhdTXlD-5BL1NaY2adytXZj58MqGEiG7AFs97MxsC2vc-5yTSWTGbXD9Pyq8XS55vreVReZXg3Qevk4gL9Ml_UDjKVI1TGadtMNHrzLj_i-umAoUuzT--YVRb7XsnBJb2-dqH_U1meBZrxAOk3UGQ0MHoIEB-Pfy48R_nAW5_rmZbfvhemuarMvRVGO3h0hDhMojtwCOT_KAS5LdejU-xYf5oByGAs9Tn-VTGjMcpvHHM7Jf3E6cHI9FsfKH5yVjgYb9PLxbjOL4cfPl0NMJfslsvMdpPTGvxLrVyccpewzolvBc8K4MYh4mAUJtTbgySAf_hpbpOXAt-5vTr0CE9yHI1MmXbYNUAiD01D8DQ1AujhdJbBmZuBFvUQTw7gYlIP-GR7zGdX0MwPizMlM9TSAEtVZT2bRsFZykWteMFPxXNw7hBNXN2A2oE0mAyly9sAq28uNzzGgi2UVtWpcGcJGstPYR8_5es4X8Ur9oTr6Xy1nMXxNFk8FetpNo8xWbI8yugySRhGc5pGMZ0uojld5NkTX9OIxtOILqbLZDVdTFi6oOkiTWaYzo-zjJFZ5GoaMRHicp4ofXryPlkvotkqeRIsRWH8QJ9SiW_BYa58S_ZPeu14ntPqZMgsEtxY00mx3Apc_9ECbdgVAbj8LumHoQO2fYUuWM1R-83FedeL85_hrHx14f7ahPup0mJdWFuG4_-F0JcTt0WVTjJ1JvTFKVX_PZdafcfMtUDeFEPoizf1vwEAAP__Phodgg">