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

    <tr>
        <th>Summary</th>
        <td>
            Missed optimization: inline functions, when operations can be done with smaller bit width
        </td>
    </tr>

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

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

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

<pre>
    ```c
#include <stdbool.h>
#include <stdint.h>

static inline uint64_t saturating_sub_u64(uint64_t a, uint64_t b) {
    return a > b ? a - b : 0;
}

uint32_t test1a(uint32_t a, uint32_t b) {
    return a > b ? a - b : 0;
}

uint32_t test1b(uint32_t a, uint32_t b) {
    return (uint64_t)a > (uint64_t)b ? (uint64_t)a - (uint64_t)b : (uint64_t)0;
}

uint32_t test1c(uint32_t a, uint32_t b) {
 return saturating_sub_u64(a, b);
}
```

Expected result: `test1a`, `test1b` and `test1c` functions transform to same code.

Actual result: `test1a` and `test1b` transform to same code, but `test1c` produces slightly larger code, with unnecessary zero extension operations.

This can be tested in Compiler Explorer.

x86-64 clang 19.1.0 with `-Os` option produces:

```x86asm
test1b:
        xorl    %eax, %eax
        subl %esi, %edi
        cmovael %edi, %eax
        retq

test1c:
        movl %edi, %ecx
        movl    %esi, %edx
        xorl    %eax, %eax
 subq    %rdx, %rcx
        cmovaeq %rcx, %rax
 retq

```

Related: [GCC bug 118679](https://gcc.gnu.org/bugzilla/show_bug.cgi?id=118679)
When I reported the bug in GCC, I have another example that GCC missed the optimization for, but somehow Clang optimized it correctly (see the `max_u64` and `test2` functions in that bug report). The `saturating_sub_u64` case is what Clang missed.
</pre>
<img width="1" height="1" alt="" src="http://email.email.llvm.org/o/eJysVV2P6jYQ_TXmZUTkOBCShzxw2eXqPlSVqiv1ceU4Q-LKsVl_LOz--spOYBdEq1upCCmJ5-Oc8RyPuXOy14gNWX8j66cFD34wtnk-H5WxaGm9aE333pCSTn9B6JawQmqhQodAip3zXWuMygZSPD8ySu2vNrp1nnspQGolNUKQ2perFw-O-2C5l7p_caF9CeWKsOpq5YTtPn1bwmogm2-EbgEALPpgNXAgxTO0QIo9cFimty1QUkQ_snma4GOSgr148Oh8zmeQtHIFSV__H0j7X0G-VE5YPUHerk0E7v2WD7y2d2v_TlX8GtWZ58OepajofAN0Uc8E-nw-ovDYgUUXlE8sSzp3pKQxw-W7JSUFrrvrgogLh6CFl0Y78JZrdzB2BG_A8RFBmA6zCWcrfODqH1BusiaYx7lSPcHfEjha0wWBDpyS_eDVOyhue7TXiJP0AwStUaBz3L7DB1oDePaonTQazBHj1hntZq4_B-lAcA0tpl5gB1LDzoxHqdDC5TzO3ueqXJYrEIrrHvI6yzM6QZKSLn93kaI5xvRXpqTYTqHXXpyrkruR0O28A8kB5t_ZWBWfhK2Rn1NHprdPFxdalVadvNg7-cUuRvPGUV0Mj1JY9K8Tq3lrbziM5u0-Wpzv7TPHLxzOv1iGC-3rbLPdxWZvEKYSXi-G2WUK_-R-p-4_UHGPXdLb-tv3XZRPD3lelZuarJ8Iqwbvj6khbE_Yvhci63XIjO0J27eh_5BKccL2bjCnlzb0meglKfayI8XTnIbVhG7_HFDDD7B4NDbqxQ-YoKSG77tdZPsDBv6GwLXxA1rAMx-PCsEP3EcXGKVzc2CUyyg_kibhYOxF9s6MOJgT7JLUZq8oTg_CWIsiip-wyiGmPKSkIz-nYXB7xtjtwZV6ohEJTxUQVmfwc0rxYLSUFAR3CNLBKQZOhKYKskXXFF1d1HyBTb4pKrqqKloshqZseV3Qgh4o77q2qEpeUV6t2qI71GXd5gvZMMrWNGcV3TBKi2zFKdtUOd10-QHLVpAVxZFLlSn1NsYmLaRzAZucrTb5aqF4i8ql25MxjSdIVsJYvExtE4OWbegdWVElnXefabz0CpvfphZ83f6onPl-vO5Xmimx35-D4zItOqNxOvxu5CoOi1Z6OMnOD4tgVXOnNumH0GbCjITtI5f5sTxa8xcKT9g-VeAI288lvjXs7wAAAP__5u94lw">