I skimmed through the code to see where transformation like
(a - 1) -> (a + UINT_MAX) are performed. It seems there are only two
places, match.pd (/* A - B -> A + (-B) if B is easily negatable.  */)
and fold-const.c.

In order to be able to reliably know whether to zero-extend or to
sign-extend the constant (1) in

 (ulong)(a - 1) + 1 -> (ulong)(a) + 0
                 or -> (ulong)(a) + (ulong)(UINT_MAX + 1)

we'd have to know if the constant was converted by a transformation like
above.

I first tried removing the two transformations altogether but this
causes around 20 new regressions on s390x and I didn't go through all of
them to see whether they can be fixed. Is there a rationale for applying
the transformations other than canonicalization? I saw some
optimizations that only apply to PLUS_EXPRs but that can easily be
changed to also include MINUS_EXPR.

My other attempt entails an additional flag TREE_WAS_SIGNED for the lack
of a better naming idea. It is set when the above transformation takes
place. I used (NODE)->base.deprecated_flag but there may be better
choices. Tentative/example patch attached for reference.

Using this, the type extension in my original patch can be changed to
w1 = w1.from (w1, TYPE_PRECISION (type), TREE_WAS_SIGNED (@1)
	      ? SIGNED : TYPE_SIGN (inner_type));
which works for me and does not introduce regressions on s390x.

Is this a viable approach?

Regards
 Robin