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

    <tr>
        <th>Summary</th>
        <td>
            Theoretical strict aliasing violation in out_ptr_t operator void**?
        </td>
    </tr>

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

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

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

<pre>
    (I'm filing this as an issue in the implementation, but, unless I'm wrong, I don't see good solutions beyond fixing the standard.)

I was curious how one is meant to implement `std::out_ptr_t::operator void**` and noticed both libc++ and libstdc++ just cast the pointer from `T**` to `void**`:
https://github.com/llvm/llvm-project/blob/main/libcxx/include/__memory/out_ptr.h#L81

Is this cast actually a valid implementation? I mean, this is presumably the intended implementation of `operator void**` because keeping two pointers in the `out_ptr_t` would definitely not be cheap. But ISTM this would cause a strict aliasing violation in the application. AIUI, this is not strictly legal by [strict aliasing](https://en.cppreference.com/w/cpp/language/reinterpret_cast#Type_aliasing):

```
// ptr has dynamic type int*
// https://en.cppreference.com/w/cpp/language/type#Dynamic_type
int *ptr;
// *voidp has type void*
void **voidp = (void**)&ptr;
// ptr is being accessed as a void*, but ptr, of type int*, is not
// type-accessible as a void* because int* and void* are not
// similar.
// https://en.cppreference.com/w/cpp/language/implicit_conversion#Similar_types
*voidp;
```

Now, I played with Clang and GCC in Godbolt and it looks like neither considers types this fine-grained for strict aliasing analysis, so this is probably fine in practice. But if I'm understanding this right and this is just a compiler-specific implementation-detail, it seems we have two consequences:

First, libc++ should probably have a comment to make it clear we're relying on Clang and GCC providing more guarantees than the standard does. (Is that documented anywhere by Clang and GCC?)

Second, `out_ptr_t` is, AIUI, meant to be specialized by user code for custom smart pointers. While an STL implementation can be more easily tied to specific compilers, it's a bit harder for user code to justify doing this, especially if the compilers do not actually document this property. ISTM that means that a more UB-avoiding implementation needs to maintain both `T*` and `void*` storage and track a flag for which was used. That seems poor. Especially when the aim of specialization would be to return a pointer to the smart pointer's underlying storage.

Am I just misunderstanding things? Is this just a mistake in the standard? Is it time to just relax the strict aliasing rule and allow `T*` to be accessed as `void*`, not just convertible to/from?
</pre>
<img width="1" height="1" alt="" src="http://email.email.llvm.org/o/eJysVl9vOrsR_TTmZRS08QIJDzyQ_MpVpNu-_HLVx2jWHti58dpb2wvZfvrK9kKA21ZqdSUkYNeef-fMmcEQ-GCJNmL5IpY_ZjjE1vmNxiPrhuyscXrcCPn8JuRTB3s2bA8QWw6AAdAChzAQsIXYEnDXG-rIRozsrJCv0AwxfQ3WUAhQjJy8s4f09A10OvUUIRDBwTkNwZkh3Q3Q0Oishj1_FY8EIaLV6PVcyLWotqLavsEJA6jBsxsCtO4EzhJwgI7QRojuOyIQqypELeqtqLduiB999B9x-tuTx-g8HB1rIbfps6oArQbrIivS0LjYguFGCfki5Et-Z7gJUZ-f_D6ECApDzLH2jm0kD3vvuuT6_dtsdOnBjasURrVtY-xD-il3Qu4OHNuhmSvXCbkz5nj-eui9-51UFHLXGNcIueuQbXrJjfr6EnLHVplBk5C7j4-OOudHIXdTyvNWyPrX58epfqFAmcNGFQc0ZgSEIxrW92jWO3jLhU3Q5WscoPcUhg4bMxYC2EhW0_1dcPuU83-oc0MKh0DwSdRnrE_uXL9wZla6fQFtVcHJDUaDpj1bjmTGBBQ0BKol7OfwMkR4-_n-1xJnOVycIIToWUVAwxiSuyM7U6KcfGHfG1b50Ry2b7-9XSec_BQLZgRDBzTQjCCWL3dmxfKHkM-3kJKdq773tCdPVtGE7UnIner7hCDaw4CHhJynnH_vKX4kdISs38eePi7m5bqQJn1W1fSpJkfQRw8tBtCjxY4VxLHP4KSKXw7938Ela0LWP4rxj_y32nJqMrntoxf1y7cXIbcJ7j7Hk-M4o1_lF1CIUM6I-gcI-XzFD7kWcnVvM6XHSSISfqgUhUA6C9I3tbL2pJPpp9vflEC-TlB-m0yvH4opbgzdGLswtFzPzX9-hZ5uDQXu2KCf_wl1Tk3EiuOHcvZIPmRNrX8WB7nsIXspxZsqdE2Gavs3dypK2xscScOJYwuvyUfO4pfX18T6X5xunIn5EUcwzn0GMPxJYIljSx6Us4F1asjstrTDni09HDyyJQ175__QWmjRjIFDCiG4K9FwTZaMZCD57z2qpLOlcXk_DYrBJo9J9S9Dx_OhLXGejWXdRVCu69mQfwg9Kd6zupOgB00R2WTo87zpApwIWjxSFpyUIP1jSJCES2ft2Ic8v66UP7RZTS45ZAvZfx4z0UGHn5ScKEPo4URCPnkCT2ZMaTh7V__euyPnDDvnCQ4DerSRcpHR3kw-0I7CPHVIVm6MoJ0akt9EfzueWvKU9OjGg6h3l4n5k5SzOqV0r6gFpbPcXQZoQ5Ariob_mebgCEPIfNCUIVdDiK6D0KGPF9Wew99bTk1k4ef7r_fDQKFNZnO2hIHT7GDSydsFvDOcoQAm5FPqx4YjtOh1GqzOX0USXeYB70fQ7kyWdJWm4M2YaJVqebEM2mU1v8y9cy0LtXqfxlUc5-dBgjFXZSo8lvh_e3nA1H3J512alkiHwge2EdmWJeK8DEwLxtUqsKogROfxQIXgHtUnIOwNHnK6p5ZVmzeeIZCew3uKozC5d87P4S_fyZ5amoYZd0n9LhiW2MpEbHLhPMXBW8DLzhJdId01pBmA3I-FxVOg88KqbQdvpRE7Dn_oWnsIeXmYVGNq2I5DzI1yS_HpJEeI3F2ATd2DX9PBW43xgyn1QmPc6bq8hb3X4-Gm2IkeCf-yuGWFjVn6oxNylxY3Ue9melPrdb3GGW0enxb141O1Wq9n7WaN1aJ62jePS6zX9WO1XC4aqbVUVb2sda1nvJGVXFa1fH5cVIvleo6Pq2axXKhVo2XzjFIsKuqQzTxtdXPnD7O8S28e63qxWM4MNmRCXsultHQqm7aQMm3pfpNXwWY4BLGoDIcYvs1EjoY27y05T5EVmv--8lxUAP7dflbvZoM3m_95N83RBiF3UzrHjfxXAAAA__8DODL2">