Do not print confusing warning when a parser state contains an assign…

…ment to an l-value slice (p4lang#4948)

* Do not print confusing warning when a parser state contains an assignment to an l-value slice

Signed-off-by: Kyle Cripps <[email protected]>

* Add additional test case

Signed-off-by: Kyle Cripps <[email protected]>

* rename test

Signed-off-by: Kyle Cripps <[email protected]>

* Add assertion for AbstractSlice

Signed-off-by: Kyle Cripps <[email protected]>

---------

Signed-off-by: Kyle Cripps <[email protected]>

midend/interpreter.cpp

@@ -741,9 +741,16 @@ void ExpressionEvaluator::postorder(const IR::Operation_Ternary *expression) {
     auto e1i = e1->to<ScalarValue>();
     auto e2i = e2->to<ScalarValue>();
     if (e0i->isUninitialized()) {
-        auto result = new SymbolicStaticError(expression->e0, "Uninitialized");
-        set(expression, result);
-        return;
+        // This cannot be an uninitialized read if 'expression' is the LHS of
+        // an assignment to a sliced l-value.
+        if (!evaluatingLeftValue) {
+            auto result = new SymbolicStaticError(expression->e0, "Uninitialized");
+            set(expression, result);
+            return;
+        } else {
+            BUG_CHECK(expression->is<IR::AbstractSlice>(), "%1%: Expected AbstractSlice.",
+                      expression);
+        }
     } else if (e1i->isUninitialized()) {
         auto result = new SymbolicStaticError(expression->e1, "Uninitialized");
         set(expression, result);

testdata/p4_16_samples/parser-unroll-uninitialized-slice-read.p4

@@ -0,0 +1,12 @@
+#include <core.p4>
+
+parser p(packet_in packet, out bit<8> f, out bit<4> g) {
+    state start {
+        g = f[3:0];
+        transition accept;
+    }
+}
+
+parser simple(packet_in packet, out bit<8> f, out bit<4> g);
+package top(simple e);
+top(p()) main;

testdata/p4_16_samples/parser-unroll-uninitialized-slice-write.p4

@@ -0,0 +1,16 @@
+#include <core.p4>
+
+struct S {
+    bit<8> f;
+}
+
+parser p(packet_in packet, out S s) {
+    state start {
+        s.f[3:0] = 2;
+        transition accept;
+    }
+}
+
+parser simple(packet_in packet, out S s);
+package top(simple e);
+top(p()) main;

testdata/p4_16_samples_outputs/parser-unroll-uninitialized-slice-read-first.p4

@@ -0,0 +1,12 @@
+#include <core.p4>
+
+parser p(packet_in packet, out bit<8> f, out bit<4> g) {
+    state start {
+        g = f[3:0];
+        transition accept;
+    }
+}
+
+parser simple(packet_in packet, out bit<8> f, out bit<4> g);
+package top(simple e);
+top(p()) main;

testdata/p4_16_samples_outputs/parser-unroll-uninitialized-slice-read-frontend.p4

@@ -0,0 +1,12 @@
+#include <core.p4>
+
+parser p(packet_in packet, out bit<8> f, out bit<4> g) {
+    state start {
+        g = f[3:0];
+        transition accept;
+    }
+}
+
+parser simple(packet_in packet, out bit<8> f, out bit<4> g);
+package top(simple e);
+top(p()) main;

testdata/p4_16_samples_outputs/parser-unroll-uninitialized-slice-read-midend.p4

@@ -0,0 +1,12 @@
+#include <core.p4>
+
+parser p(packet_in packet, out bit<8> f, out bit<4> g) {
+    state start {
+        g = f[3:0];
+        transition accept;
+    }
+}
+
+parser simple(packet_in packet, out bit<8> f, out bit<4> g);
+package top(simple e);
+top(p()) main;

testdata/p4_16_samples_outputs/parser-unroll-uninitialized-slice-read.p4

@@ -0,0 +1,12 @@
+#include <core.p4>
+
+parser p(packet_in packet, out bit<8> f, out bit<4> g) {
+    state start {
+        g = f[3:0];
+        transition accept;
+    }
+}
+
+parser simple(packet_in packet, out bit<8> f, out bit<4> g);
+package top(simple e);
+top(p()) main;

testdata/p4_16_samples_outputs/parser-unroll-uninitialized-slice-read.p4-stderr

@@ -0,0 +1,9 @@
+parser-unroll-uninitialized-slice-read.p4(5): [--Wwarn=uninitialized_use] warning: f may be uninitialized
+        g = f[3:0];
+            ^
+parser-unroll-uninitialized-slice-read.p4(3): [--Wwarn=uninitialized_out_param] warning: out parameter 'f' may be uninitialized when 'p' terminates
+parser p(packet_in packet, out bit<8> f, out bit<4> g) {
+                                      ^
+parser-unroll-uninitialized-slice-read.p4(3)
+parser p(packet_in packet, out bit<8> f, out bit<4> g) {
+       ^

testdata/p4_16_samples_outputs/parser-unroll-uninitialized-slice-write-first.p4

@@ -0,0 +1,16 @@
+#include <core.p4>
+
+struct S {
+    bit<8> f;
+}
+
+parser p(packet_in packet, out S s) {
+    state start {
+        s.f[3:0] = 4w2;
+        transition accept;
+    }
+}
+
+parser simple(packet_in packet, out S s);
+package top(simple e);
+top(p()) main;

testdata/p4_16_samples_outputs/parser-unroll-uninitialized-slice-write-frontend.p4

@@ -0,0 +1,16 @@
+#include <core.p4>
+
+struct S {
+    bit<8> f;
+}
+
+parser p(packet_in packet, out S s) {
+    state start {
+        s.f[3:0] = 4w2;
+        transition accept;
+    }
+}
+
+parser simple(packet_in packet, out S s);
+package top(simple e);
+top(p()) main;

testdata/p4_16_samples_outputs/parser-unroll-uninitialized-slice-write-midend.p4

@@ -0,0 +1,16 @@
+#include <core.p4>
+
+struct S {
+    bit<8> f;
+}
+
+parser p(packet_in packet, out S s) {
+    state start {
+        s.f[3:0] = 4w2;
+        transition accept;
+    }
+}
+
+parser simple(packet_in packet, out S s);
+package top(simple e);
+top(p()) main;

testdata/p4_16_samples_outputs/parser-unroll-uninitialized-slice-write.p4

@@ -0,0 +1,16 @@
+#include <core.p4>
+
+struct S {
+    bit<8> f;
+}
+
+parser p(packet_in packet, out S s) {
+    state start {
+        s.f[3:0] = 2;
+        transition accept;
+    }
+}
+
+parser simple(packet_in packet, out S s);
+package top(simple e);
+top(p()) main;

testdata/p4_16_samples_outputs/parser-unroll-uninitialized-slice-write.p4-stderr

@@ -0,0 +1,3 @@
+parser-unroll-uninitialized-slice-write.p4(9): [--Wwarn=uninitialized_use] warning: s.f may be uninitialized
+        s.f[3:0] = 2;
+        ^^^

testdata/p4_16_samples_outputs/parser-unroll/parser-unroll-uninitialized-slice-read-first.p4

@@ -0,0 +1,12 @@
+#include <core.p4>
+
+parser p(packet_in packet, out bit<8> f, out bit<4> g) {
+    state start {
+        g = f[3:0];
+        transition accept;
+    }
+}
+
+parser simple(packet_in packet, out bit<8> f, out bit<4> g);
+package top(simple e);
+top(p()) main;

testdata/p4_16_samples_outputs/parser-unroll/parser-unroll-uninitialized-slice-read-frontend.p4

@@ -0,0 +1,12 @@
+#include <core.p4>
+
+parser p(packet_in packet, out bit<8> f, out bit<4> g) {
+    state start {
+        g = f[3:0];
+        transition accept;
+    }
+}
+
+parser simple(packet_in packet, out bit<8> f, out bit<4> g);
+package top(simple e);
+top(p()) main;

testdata/p4_16_samples_outputs/parser-unroll/parser-unroll-uninitialized-slice-read-midend.p4

@@ -0,0 +1,12 @@
+#include <core.p4>
+
+parser p(packet_in packet, out bit<8> f, out bit<4> g) {
+    state start {
+        g = f[3:0];
+        transition accept;
+    }
+}
+
+parser simple(packet_in packet, out bit<8> f, out bit<4> g);
+package top(simple e);
+top(p()) main;

testdata/p4_16_samples_outputs/parser-unroll/parser-unroll-uninitialized-slice-read.p4

@@ -0,0 +1,12 @@
+#include <core.p4>
+
+parser p(packet_in packet, out bit<8> f, out bit<4> g) {
+    state start {
+        g = f[3:0];
+        transition accept;
+    }
+}
+
+parser simple(packet_in packet, out bit<8> f, out bit<4> g);
+package top(simple e);
+top(p()) main;

testdata/p4_16_samples_outputs/parser-unroll/parser-unroll-uninitialized-slice-read.p4-stderr

@@ -0,0 +1,12 @@
+parser-unroll-uninitialized-slice-read.p4(5): [--Wwarn=uninitialized_use] warning: f may be uninitialized
+        g = f[3:0];
+            ^
+parser-unroll-uninitialized-slice-read.p4(3): [--Wwarn=uninitialized_out_param] warning: out parameter 'f' may be uninitialized when 'p' terminates
+parser p(packet_in packet, out bit<8> f, out bit<4> g) {
+                                      ^
+parser-unroll-uninitialized-slice-read.p4(3)
+parser p(packet_in packet, out bit<8> f, out bit<4> g) {
+       ^
+parser-unroll-uninitialized-slice-read.p4(5): [--Wwarn=ignore-prop] warning: Result of 'g = f[3:0]' is not defined: Error: Uninitialized
+        g = f[3:0];
+          ^

testdata/p4_16_samples_outputs/parser-unroll/parser-unroll-uninitialized-slice-write-first.p4

@@ -0,0 +1,16 @@
+#include <core.p4>
+
+struct S {
+    bit<8> f;
+}
+
+parser p(packet_in packet, out S s) {
+    state start {
+        s.f[3:0] = 4w2;
+        transition accept;
+    }
+}
+
+parser simple(packet_in packet, out S s);
+package top(simple e);
+top(p()) main;

testdata/p4_16_samples_outputs/parser-unroll/parser-unroll-uninitialized-slice-write-frontend.p4

@@ -0,0 +1,16 @@
+#include <core.p4>
+
+struct S {
+    bit<8> f;
+}
+
+parser p(packet_in packet, out S s) {
+    state start {
+        s.f[3:0] = 4w2;
+        transition accept;
+    }
+}
+
+parser simple(packet_in packet, out S s);
+package top(simple e);
+top(p()) main;

testdata/p4_16_samples_outputs/parser-unroll/parser-unroll-uninitialized-slice-write-midend.p4

@@ -0,0 +1,16 @@
+#include <core.p4>
+
+struct S {
+    bit<8> f;
+}
+
+parser p(packet_in packet, out S s) {
+    state start {
+        s.f[3:0] = 4w2;
+        transition accept;
+    }
+}
+
+parser simple(packet_in packet, out S s);
+package top(simple e);
+top(p()) main;

testdata/p4_16_samples_outputs/parser-unroll/parser-unroll-uninitialized-slice-write.p4

@@ -0,0 +1,16 @@
+#include <core.p4>
+
+struct S {
+    bit<8> f;
+}
+
+parser p(packet_in packet, out S s) {
+    state start {
+        s.f[3:0] = 2;
+        transition accept;
+    }
+}
+
+parser simple(packet_in packet, out S s);
+package top(simple e);
+top(p()) main;

testdata/p4_16_samples_outputs/parser-unroll/parser-unroll-uninitialized-slice-write.p4-stderr

@@ -0,0 +1,3 @@
+parser-unroll-uninitialized-slice-write.p4(9): [--Wwarn=uninitialized_use] warning: s.f may be uninitialized
+        s.f[3:0] = 2;
+        ^^^