<table border="1" cellspacing="0" cellpadding="8">
<tr>
<th>Issue</th>
<td>
<a href=https://github.com/llvm/llvm-project/issues/71030>71030</a>
</td>
</tr>
<tr>
<th>Summary</th>
<td>
Inconsistent Output at -O1 and -O2 Optimization Levels on PowerPC64 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:**
The Proof-of-Concept (PoC) code provided demonstrates an inconsistency in the computed results of an **`unsigned long long int`** variable when compiled using Clang-18 for the PowerPC64 architecture. The discrepancy is observed specifically under the optimization levels **`-O1`** and **`-O2`**. The output of **`computedResultUll`** displays inconsistency as shown below:
```markdown
Computed Result (ULL): ffffffffffffffff
Computed Result (ULL): ffffffff
Computed Result (ULL): ffffffff
Computed Result (ULL): ffffffffffffffff
```
### **Environment:**
- **Compiler**: Clang-18
- **Target Architecture**: PowerPC64
- **Optimization Level**: This issue is exclusively observed at **`O1`** and **`O2`** optimization levels.
### ****PoC:****
```c
#include <stdio.h>
// Define a macro to find the minimum value between two numbers
#define MIN(a,b) \
({ __typeof__ (a) _a = (a); \
__typeof__ (b) _b = (b); \
_a < _b ? _a : _b; })
// Global variables
short globalShortValue = (short)1;
signed char globalCharValue = (signed char)0;
unsigned long long largeNumber = 14782061517590169264ULL;
int someIntValue = 378441747;
unsigned int unitIncrement = 1U;
// Variables to store the results of computations
unsigned long long computedResultUll = 0ULL;
short computedResultShort = (short)0;
unsigned char computedResultUChar = (unsigned char)0;
_Bool computedResultBool = (_Bool)0;
unsigned char computedResultChar = (unsigned char)0;
// Arrays used in computations
short shortArray[8];
long long int longArray[8][8];
int intArray[8][8][8];
unsigned long long ullArray[8];
signed char charArray[8][8][8];
short resultArray[8][8];
// Initialize arrays
void initializeArrays() {
for (size_t i = 0; i < 8; ++i) {
shortArray[i] = (short)-1;
ullArray[i] = 1;
for (size_t j = 0; j < 8; ++j) {
longArray[i][j] = 0LL;
resultArray[i][j] = (short)1;
for (size_t k = 0; k < 8; ++k) {
intArray[i][j][k] = 0;
charArray[i][j][k] = (signed char)0;
}
}
}
}
int main() {
initializeArrays();
// Main loop for computations
for (short index = 3; index < ((int) (short) largeNumber) - 1705/*7*/; index += 4) {
computedResultUll = (unsigned long long) ((int) MIN(globalShortValue, shortArray[index])); // Potential issue here
for (int i = 0; i < 8; i++) {
for (signed char j = ((int) (signed char) someIntValue) - 19/*0*/; j < 8; j += 4) {
for (long long int k = 2; k < 4; k += 4) {
computedResultShort -= (short) unitIncrement;
computedResultUChar = (unsigned char) (_Bool) MIN((short) globalCharValue, shortArray[index - 1]);
charArray[2][0][index] = (signed char) globalShortValue;
resultArray[0][0] &= (short) longArray[0][j];
}
for (int l = 1; l < 7; l++) {
computedResultBool = (_Bool) (ullArray[index]);
computedResultChar -= (unsigned char) intArray[0][index][j];
}
}
}
}
// Print the result
printf("Computed Result (ULL): %llx\n", computedResultUll);
}
```
### **Expected Behavior:**
Regardless of the optimization level, the value of **`computedResultUll`** should be consistently and accurately computed as an **`unsigned long long int`**.
### **Observed Behavior:**
When compiled with Clang-18 under **`-O1`** and **`-O2`** optimization levels, the computed value for **`computedResultUll`** shows inconsistency:
```markdown
Computed Result (ULL): ffffffffffffffff
Computed Result (ULL): ffffffff
Computed Result (ULL): ffffffff
Computed Result (ULL): ffffffffffffffff
```
### **Analysis:**
The inconsistency is identified under the following conditions:
1. **Nested Loops and Type Casting**: The issue is seen in a complex nested loop structure where boundary conditions involve type casting.
2. **Array Operations**: The presence of operations involving multiple arrays seems to be a contributing factor.
3. **Unsigned Type Extension**: The primary concern appears to be an incorrect extension of a value to **`unsigned long long int`**.
These conditions are specific and intricate, but the inconsistency is notable and is not attributed to Undefined Behavior.
### **Steps to Reproduce:**
1. Compile the PoC code using Clang-18 targeting PowerPC64 with **`O1`** and **`O2`** optimization levels.
2. Run the compiled binary.
3. Observe the inconsistency in the output for **`computedResultUll`**.
### **Conclusion:**
The observed inconsistency in extending values to **`unsigned long long int`**, under specific conditions involving complex loop structures and type casting operations, when compiled using Clang-18 at **`-O1`** and **`-O2`** optimization levels, warrants further investigation and resolution.
</pre>
<img width="1px" height="1px" alt="" src="http://email.email.llvm.org/o/eJzsWUmP46zW_jVkgxI5ZF5kkaHrU0v9dpV6eL9lCdsnMdUELMBJpX_9FeABO67c9B12NyqlPJyJh-cc4IRqzY4CYI1mWzTbD2hhMqnWx2txYiIexDK9rhGZ-D-MyAaRzR50olhumBRosvHPULRHUfn9IwP8oqQ8DOVhuJMigdxgRJYvcofICicyBZwreWYppDiFkxTaKGpAYyowE4kUmmkDIrliJrDJACfylBcGUqxAF9xoLA9WtnQ9jwrhRpFiLsXRfzFh0DzyEvhMFaMxB3zJQDhrjEOKC83EEe84FcfheIkPUjlvL_IC6mU3n2KqkowZSEyhYITtuFKmEwU5dcFpLGMN6gwp1jkk7MASyvkVFyIFb0rmhp3Yb2qxwhzOwHUT9fB53IRIRRq-IfUb71cWJi-MHXctVIHyzWHyk_PGWMp0zulVd9CkGutMXgSOgcuLnbtg1qy2-ztR9SuVF-Ef7yrovRs7jz-_fEFkhSYbfOh8_kDlvyPaVqmH1Bpnh82fxJkpKU4gTC-bh6XczrNGlRKTTU2cttwPqo5g8CagTqNSU6ut8xzS5IulSaPyI2MaM60LsISD94QXmp2BXxvyUdOw4kNOBZTqo-XoHkb-z-bvZBM-6eVPUttgIuFFChhNdtqkTI4yNPnU9vOEyBPew4EJwBSfaKIkNhIfmEhdAp2YYKfihM-UF4BjMBcAgc1FYlGcYlC6dpZ6I399_orIkiKyi22xQbOdl8AYW8qgxRa_vpprDvLw-oq96Aq_Uowm--oWTbZtRYw7Ss72a1wpxTdKzuDOizz5uw1-jZ3QYm_Fb2H4Py5jyutiVQ5NZ1IZfHTvvtvrvx0UpWf3FpHVGE22pbyvhElGVam1y6hqKzUiiKyiWrWnjHLL5q8Oaqc9ni6WJJqPZ-PFbBWN5ysyn9o0rEwwYbCWJ_gsgjgni-V0Ol5MF7eerHwhmPksEgU2B72Xn7VkC6G_K2gsR7SRChxJglXBF0VHbP3hoG4qp3MahePwqLcFHfpd4HvQc9B3fNg5qFRbgi0Tr1speUfVPSo13fuHnT7mswXwRim7bBTaTU0Pmh4X9-1k0Wy7RLN9ba21ALuLllhH2sowYfpEOpI9s1hw3htCC5CMqges-1F5Gt2Lt4XVZ8EMo5z9BkwdbP7tWTKLXfXOI2orj61Gi21TVOx2wyXjb3g1mHkO2gLBXOlYulpBtohs2Y2u_bQmgaHZvkvNYVMUKp0As1rjVqod2VsT2Vs3srfeyOwnnHrmoXyrPEZBooU67QnoavVWu1C9HfavJuxf3bB_tcMOKBg4RbPtrzriXof2EzLsA-U7FTe0ZNeF1sPWg_qmuahT6ESZuGFYPwVbnksi_0WZwFzK3CF4m_Mhti5RmEjh3Vd2x9fyducWWLK0W28bSjNf4TJib4d4vIhmzv1m4bYST4EhsrWmp-3h9NfssLLVlaF03kTi9wTdJRSRXSeHrHs7d2RVreceoBdpQFgwy31YBgp6M8bVs95EZp54H6ZLzd2mdr1VI2xD2mJSa60tkV15XKMG1yBt3z6At_Mpw2lXc59RpMmoaXn5iEWXKz3L6bCT2u3dwIdpd2vu7hIbLp4lHUKfnX1SPzMstiU76qjC7Cc-7SP_ryJTfwW42c81JttFMGqMYkTmXbDCKhsF1ae2dlNUehjL62XAXe7wwl32Mfafb00c-sEqE-TUpN-Km7fhRxMX1OYOso-N9cGqGpTDF2VBafaVpUBuHx8cccjdsygiM87f0WwnECGWSrcH9QCMppw_dFh9zyGxjreQ0TOTqvfI-g2OVKUctNsS9_chbGD2jT9YPdhX0JkseIpjwHVbwfCrO2fSJCkUNfZcWndrqP6TLs3dE-hzdda9O_D_b7V3LsxkTXfHN2X-sPnSd1KukKuH6SH0CfUQhpdOY-Z_nRgHzUZQftVMf9hU7PQGNWapXZcPDNKg53aQnMsLc-c8kTK_kWkjPB6VLr-CtgP5ImWuHQt-XHPAO6oNs_uIpgcDTQtGAwh7OKKOARzesfBW3BZKG1W4pg--2G0CjmUhUqquQTCYibPkZ8DGOku8s5L9pIrMFT38nIMqt2KtYHIFGkTiElfWMqVhO_RTwQ3LeXU0sUGf3Kk5Bhe4MIrFhXWMDzQxUpX-J5X_n1WyOkQ-vRsQmknRDYOdyrEloASmeQ5U1X58N1cpSAyGyoLr3ZY5Y-S_Vh1-ZKAhRJQqqFuwbh6ZHWBCjVvL48LX8xv-CGlcW9hpuFtMjUcGUhvdT-HbSk3duVulvhvI3ei_Qa5kWiTQy-XxCJfdxLLfvPNN8U4_2rhOon3UdKRdTftPNfvICH8rmg67K5oxE1RdGzaUhbcPP69ZdqYfLH934dtJ4bqbd35XqHueN7E4gqUWLcct_SfksiTxBaQm0U26srJxZBO-nem-coTJHOSkNX33V4ewefvvLUoXm-vCaHwolMlA2cBBG3b0gtaeAi15YW9Hg3Q9SVeTFR3AejxfLVfRarKMBtl6CWmUJocoHS-n6YrCIjpMF5PVdDYni2Q1Xg3YmkRkMh5HJFqM5yQaTZM5JWk0hekhBVhGaBrBiTI-4vx8Gkl1HLjiuV6Mo0k04DQGrt0PToQIuPjKavdKs_1Ara3OMC6OGk0jzrTRjRXDDIf152bmDX727KMGD5_HbojDZ4Jv--kaSxGk0d4Xn105n2HVd0aCdQF_r-Z5UCi-zozJ_QplN4tHZrIiHiXyhMiTjbP8N8yVfIPEIPLkRqcReXKj_0cAAAD__1JIJPE">