When doing a shift operation, both arguments are subjected to
integer promotion and the type of the result is simply the type
of the promoted left operand. Easy.
But for a shift-assignment, things are slightly more complex:
-) 'a >>= n' should be equivalent to 'a = a >> n'
-) but the type of the result must be the type of the left
operand *before* integer promotion.
Currently, the linearization code use the type of the right
operand to infer of the type of the operation. But simply changing
the code to use the type of the left operand will also be wrong
(for example for signed/unsigned divisions). Nasty.
For example, the following C code:
int s = ...;
s >>= 11U;
is linearized as a logical shift:
lsr.32 %r2 <- %arg1, $11
while, of course it's an arithmetic shift that is expected:
asr.32 %r2 <- %arg1, $11
So, add a testcase for these.
Signed-off-by: Luc Van Oostenryck <luc.vanoostenryck@xxxxxxxxx>
---
validation/linear/bug-assign-op0.c | 115 +++++++++++++++++++++++++++++
1 file changed, 115 insertions(+)
create mode 100644 validation/linear/bug-assign-op0.c
diff --git a/validation/linear/bug-assign-op0.c b/validation/linear/bug-assign-op0.c
new file mode 100644
index 000000000000..0cabc6222b8a
--- /dev/null
+++ b/validation/linear/bug-assign-op0.c
@@ -0,0 +1,115 @@
+int asr(int s)
+{
+ s >>= 11U;
+ return s;
+}
+
+unsigned int lsr(unsigned int u)
+{
+ u >>= 11;
+ return u;
+}
+
+int divr(int s, unsigned long u)
+{
+ extern int use(int, unsigned);
+ int t = s;
+ s = s / u;
+ u = u / t;
+ return use(s, u);
+}
+
+int sdivul(int s, unsigned long u)
+{
+ s /= u; // divu
+ return s;
+}
+
+unsigned int udivsl(unsigned int u, long s)
+{
+ u /= s; // divs
+ return u;
+}
+
+int uldivs(int s, unsigned long u)
+{
+ u /= s; // divu
+ return u;
+}
+
+unsigned int sldivu(unsigned int u, long s)
+{
+ s /= u; // divs
+ return s;
+}
+
+/*
+ * check-name: bug-assign-op0
+ * check-command: test-linearize -Wno-decl $file
+ * check-known-to-fail
+ *
+ * check-output-start
+asr:
+.L0:
+ <entry-point>
+ asr.32 %r2 <- %arg1, $11
+ ret.32 %r2
+
+
+lsr:
+.L2:
+ <entry-point>
+ lsr.32 %r6 <- %arg1, $11
+ ret.32 %r6
+
+
+divr:
+.L4:
+ <entry-point>
+ sext.64 %r11 <- (32) %arg1
+ divu.64 %r13 <- %r11, %arg2
+ trunc.32 %r14 <- (64) %r13
+ divu.64 %r18 <- %arg2, %r11
+ trunc.32 %r21 <- (64) %r18
+ call.32 %r22 <- use, %r14, %r21
+ ret.32 %r22
+
+
+sdivul:
+.L6:
+ <entry-point>
+ sext.64 %r26 <- (32) %arg1
+ divu.64 %r27 <- %r26, %arg2
+ trunc.32 %r28 <- (64) %r27
+ ret.32 %r28
+
+
+udivsl:
+.L8:
+ <entry-point>
+ zext.64 %r33 <- (32) %arg1
+ divs.64 %r34 <- %r33, %arg2
+ trunc.32 %r35 <- (64) %r34
+ ret.32 %r35
+
+
+uldivs:
+.L10:
+ <entry-point>
+ sext.64 %r39 <- (32) %arg1
+ divu.64 %r41 <- %arg2, %r39
+ trunc.32 %r43 <- (64) %r41
+ ret.32 %r43
+
+
+sldivu:
+.L12:
+ <entry-point>
+ zext.64 %r46 <- (32) %arg1
+ divs.64 %r48 <- %arg2, %r46
+ trunc.32 %r50 <- (64) %r48
+ ret.32 %r50
+
+
+ * check-output-end
+ */
--
2.27.0
