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

    <tr>
        <th>Summary</th>
        <td>
            Incorrect code-gen with stack-slot sharing for `sincos` results
        </td>
    </tr>

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

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

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

<pre>
    We have encountered a miscompile where stack-slot sharing is incorrect for the results of:

`void sincosf(float x, float *sin, float *cos);`

I've bisected it to [llvmorg-20-init-6824-g3073c3c2290a](https://github.com/llvm/llvm-project/commit/3073c3c2290a6d9b12fbaefa40dd22eef6312895), so this is a regression in llvm20.

Note that a fix for an apparently related issue was made in [PR 118117](https://github.com/llvm/llvm-project/pull/118117) ([llvmorg-20-init-15653-ga7dafea384a5](https://github.com/llvm/llvm-project/commit/a7dafea384a519342b2fbe210ed101c1e67f3be7)), but this problem still persists.

Here is a reduced test-case that shows a run-time failure:
```
extern "C" {
  int printf(const char *, ...);
 float cosf(float);
  float sinf(float);
  float fabsf(float);
}
int n_errors = 0;

__attribute__((noinline))
void CheckClose(float &computed, float &expected, float &tolerance, int lnum) {
  float diff = fabsf(computed - expected);
  if (diff >= tolerance) {
    printf("Expected  %f +/ %f but was %f (failure on line %d)\n",
           expected, tolerance, computed, lnum);
    ++n_errors;
  } else {
    printf("Expected  %f +/ %f and was %f\n", expected, tolerance, computed);
  }
}

float input_value = 0.33981341f;
float expected_pos_cos =  0.94281685f;
float expected_neg_cos = -0.94281685f;
float expected_neg_sin = -0.33331117f;

int main() {
 float value = input_value;            // 0.33981341f (input)
  float local_cos = ::cosf(value);      // 0.94281685f (computed)
  float local_sin = ::sinf(value);      // 0.33331117f (computed)
  float close = 0.000010f;
 {
    float computed = local_cos;
    float expected = expected_pos_cos;
 CheckClose(computed, expected, close, __LINE__);
  }
  {
    float computed = -local_sin;
    float expected = expected_neg_sin;
 CheckClose(computed, expected, close, __LINE__);
  }
  {
    float computed = -local_cos; // 0.33331117f is passed, expected -0.94281685f
 float expected = expected_neg_cos;
    CheckClose(computed, expected, close, __LINE__);
  }
  printf("%d error(s).  %s\n", n_errors, ((n_errors == 0) ? "PASS" : "FAIL"));
}
```
The problem only manifests (for me at least) when `cosf` and `sinf` are turned into builtins.  That happens with the PS5 target (and PS4), but it doesn't happen for me with the target `x86_64-unknown-linux-gnu`.  So to see the run-time failure in a godbolt link, starting with C++ source doesn't demonstrate it.  So I'm posting an [llvm IR godbolt link](https://godbolt.org/z/M697bqGxb) that processes the IR at `-O2`, and shows the run-time failure.

Note that dropping `has-predecessor-max-steps` ("llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp") to a low number (the default is 8192) suppresses the transformation, and so hides the failure. Using the current head of `main`, dropping it to 13:
`-O2 -mllvm -has-predecessor-max-steps=13`
makes the problem latent.

The problem is still there in the head of `main` (tested with [llvmorg-21-init-12399-gc78e6bbd830a](https://github.com/llvm/llvm-project/commit/c78e6bbd830a4633fa7c80aebb9680b6acf913c6)).
</pre>
<img width="1" height="1" alt="" src="http://email.email.llvm.org/o/eJzEV19v47gR_zT0y0AGRVn_HvzgOOttgOvdYnNFHw2KGlm8lUiVpJJsP31BSlbkXFLs9QpcYCCSSA7nN_Obf9xaeVGIe5LekfR-w0fXarN__s1I6_TzptL19_0_EVr-hIBK6FE5NFgDh15aoftBdgjPLRoE67j4FtlOO7AtN1JdQFqQSmhjUDhotAHXIhi0Y-cs6IYkB0LDL6NPWtZg_W7bEFY0neYOXgg7wvRI2MFKdfMutCWsJMkdyegk54Gw_AmhkhaFwxqkA6eBpHdd99Rrc4kYjaSSLsoKtosuCc0TkQjGSspJek9Y0To3WK8WOxF2ukjXjtVW6J6wkxcx_4sGo39D4Qg7Cd330j-sZWV1WcWsqTg2fEfrmjHEJktiVpSp15gdwWpwrTePBQ4GLwatlVqBVOBvYHQ7IfpZOwTXcgccGvkSjMgV8GHgBpXrvoPBjges1o4Iz9xCz2v0gkh69-UrxHERx_n_CG8Yu46w0yyDlUBY8Y454zRLk-jC85o3yJNix9M_a8-1rLhMdqxiTYUspljHNBYxZnmTVJgHewaTVqObbDoYXXXYg3Wy62BAY6V1djbo3zxVZ6vXo8AaHFoXCW5nO9tWP4flUUVO9ggNl91ocCZrRucfPeCLQ6OAMHYkjAHJ7wg9AEjlYDBSOc9joZV1IFpuPGO9mtvtdmYtPcxcXnP-dW1etFJ9vNjw6p2jJL8n9OD1UGc0RhsLJLkHOq_Sw_nMnTOyGh2ez96lrFBaqk4qnO1JDyEgjy2Kb8dOW1xikrDMx_3osF5HY4YvQwi6m49Od2i4Eui_eoU6NfaBR_kaRi2bJqh4xXO9ASJ4lbtgl43n4Xzokz-3uudVNry6gTD2aZYDQFjqBdwRdpqePXN84MwLxexx0Aq8Sfz3cH16VIQxwo6z-PlvjfwG8NpOM_ArBJgUuLs66Pqd5PeAncU_DoKregHxqumPKFeuLl_YQ-hh8o1Uw-jOT7wbcWLRNknKIk52cTOdm7Zd7zkP2p6FnhgHdFvuWBFnRfr-ZoWXZXP0I5utz2vT5iRJkjiO82ahtSdYz32VKFY8mKS8AlgBIsndyo8wZak1Qs-GsH-KiStfOy14tyjuM0NymIN4khts-kboAg5WBH9P7hXjJHeO_4_lLnb4WK7wETx7j1JKYzobbUWzayqaA89vXmC-svbWJWHXW8_Pm29SxzoS1owU0_oRzuefHn7-5JPRGzbCf1cxWkz2YzrOHPordJxM857ffM3i1t5efRsPC48_hnXjp_8bsnX28XkQQr4irPC91zbkIbtKN0s-Y0eYC8uqBE1VyIdm4rMW-3J4fAylMzn419Ph4acgp3xTytZV99cWlwqvVfcdeq5kg9bZkLq1gR7BxxJy68PWd6cKSEZDgGY0JEqS0RBX_tUguNEo30Ipp6EaZeeksluAX30_0PJhQGXhWbo29K9fHlNw3FzQV7jCS_vyuFv1INJBrdEqwvLraZjVWmRcz2f0pcjO2S4a1Teln1XUSTW-RBc1koxuAR61b2At4tQ5v2lJfJPH4aLrSnfOl6pvobV03DjffYfbjlOdAatHI3ClWY29700MdwjSTXf5_rmHQdtwnqtr6wwPX2-vea-5m9a32lwIO_2bsNPfszKv_vX5pfJeCL3VYLRAa9EGOA9fvZ9IRqNfmPctOwbfTA3Ye3h_1xPXRg-DV5VktOU2GgzW6G_QJur5S2QdDtY7eeLvteWUFWGno67xMyrCTo_YoXBSq_vD5zevWzEMEyO9Hzh0-hnU2Ffo27nC61hjw8fO-Rgu4jLstOMwmFeYznBlG2167oUuKDW0sp63XPHBP6xH4z-J0fgGH1rkNejGIwylbbLTAnyacOJk6U6jXxhEfXBa9LFJkvs4mcKp599mJa5B5ccJ5WZbr6NN2rmldmHekyoc-72CwTRofZIKFFwPDPE8MLCkLKOLyAvMqqoukj8_gK1l7bIkaXguCsqxqsqsoFXGRVPGicim7LLd1PukLpOSb3Af57s8Y7uyKDftvqmrJONFU-2aUrBKUJ4yrHdplmZY8l2-kXtGWUrTuKQJS2i5TUSJoiliWhd5LBJBdhR7LrutV9XHwybMZvt4R3dlvOl4hZ0NEzdjCp-nyc2zLL3fmH3AV40XS3a0C4PLIsZJ1-H-YZmoha4xuqCazPzO_O3TzpTqfHHI6HX23oym2_9hUwc9rR8HJyBPe_afAAAA__84vQCU">