[clang] fix -Wuninitialized for asm goto outputs on indirect edges.

[nickdesaulniers]

Summary

Now that we support outputs from asm goto along indirect edges, we can
remove/revert some code that was added to help warn about the previous
limitation that outputs were not supported along indirect edges.

Reverts some code added in:
commit 72aa619a7fe0 ("Warn of uninitialized variables on asm goto's indirect branch")
commit 3a604fdbcd5f ("[Clang][CFG] check children statements of asm goto")
But keeps+updates the tests.

Link: https://github.com/llvm/llvm-project/issues/53562

[nickdesaulniers]

• reference 3a604fdbcd5f in commit message as well

[nickdesaulniers]

• rebase, format

[nickdesaulniers]

• rebase

[nickdesaulniers]

• rebase

[nickdesaulniers]

• final rebase

clang/lib/Analysis/UninitializedValues.cpp

while (!Queue.empty()) {
           // from a block that initializes the variable. We can't guarantee to
           // give an earlier location for the diagnostic (and it appears that
           // this code is intended to be reachable) so give a diagnostic here
           // and go no further down this path.
           Use.setUninitAfterDecl();
           continue;
         }
 
-        if (AtPredExit == MayUninitialized) {
-          // If the predecessor's terminator is an "asm goto" that initializes
-          // the variable, then don't count it as "initialized" on the indirect
-          // paths.
-          CFGTerminator term = Pred->getTerminator();
-          if (const auto *as = dyn_cast_or_null<GCCAsmStmt>(term.getStmt())) {
-            const CFGBlock *fallthrough = *Pred->succ_begin();
-            if (as->isAsmGoto() &&
-                llvm::any_of(as->outputs(), [&](const Expr *output) {
-                    return vd == findVar(output).getDecl() &&
-                        llvm::any_of(as->labels(),
-                                     [&](const AddrLabelExpr *label) {
-                          return label->getLabel()->getStmt() == B->Label &&
-                              B != fallthrough;
-                        });
-                })) {
-              Use.setUninitAfterDecl();
-              continue;
-            }
-          }
-        }
-
         unsigned &SV = SuccsVisited[Pred->getBlockID()];
         if (!SV) {
           // When visiting the first successor of a block, mark all NULL
           // successors as having been visited.
           for (CFGBlock::const_succ_iterator SI = Pred->succ_begin(),
                                              SE = Pred->succ_end();
                SI != SE; ++SI)
             if (!*SI)
for (const Expr *O : as->outputs()) {
     // semantic analysis passes.
     while (const auto *UO = dyn_cast<UnaryOperator>(Ex))
       Ex = stripCasts(C, UO->getSubExpr());
 
     // Mark the variable as potentially uninitialized for those cases where
     // it's used on an indirect path, where it's not guaranteed to be
     // defined.
     if (const VarDecl *VD = findVar(Ex).getDecl())
+      if (vals[VD] != Initialized)
         vals[VD] = MayUninitialized;
   }
 }
 
 void TransferFunctions::VisitObjCMessageExpr(ObjCMessageExpr *ME) {
   // If the Objective-C message expression is an implicit no-return that
   // is not modeled in the CFG, set the tracked dataflow values to Unknown.
   if (objCNoRet.isImplicitNoReturn(ME)) {
     vals.setAllScratchValues(Unknown);

clang/test/Analysis/uninit-asm-goto.cpp

 // RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -std=c++11 -Wuninitialized -verify %s
 
 // test1: Expect no diagnostics
 int test1(int x) {
     int y;
     asm goto("" : "=r"(y) : "r"(x) : : err);
     return y;
   err:
     return -1;
 }
 
+// test2: Expect no diagnostics
 int test2(int x) {
-  int y; // expected-warning {{variable 'y' is used uninitialized whenever its declaration is reached}}
-         // expected-note@-1 {{initialize the variable}}
+  int y;
   if (x < 42)
     asm goto("" : "+S"(x), "+D"(y) : "r"(x) :: indirect_1, indirect_2);
   else
     asm goto("" : "+S"(x), "+D"(y) : "r"(x), "r"(y) :: indirect_1, indirect_2);
   return x + y;
 indirect_1:
   return -42;
 indirect_2:
-  return y; // expected-note {{uninitialized use occurs here}}
+  return y;
 }
 
+// test3: Expect no diagnostics
 int test3(int x) {
-  int y; // expected-warning {{variable 'y' is used uninitialized whenever its declaration is reached}}
-         // expected-note@-1 {{initialize the variable}}
+  int y;
   asm goto("" : "=&r"(y) : "r"(x) : : fail);
 normal:
   y += x;
   return y;
   if (x) {
 fail:
-    return y; // expected-note {{uninitialized use occurs here}}
+    return y;
   }
   return 0;
 }
 
+// test4: Expect no diagnostics
 int test4(int x) {
-  int y; // expected-warning {{variable 'y' is used uninitialized whenever its declaration is reached}}
-         // expected-note@-1 {{initialize the variable}}
+  int y;
   goto forward;
 backward:
-  return y; // expected-note {{uninitialized use occurs here}}
+  return y;
 forward:
   asm goto("" : "=r"(y) : "r"(x) : : backward);
   return y;
 }
 
 // test5: Expect no diagnostics
 int test5(int x) {
   int y;
int test6(unsigned int *x) {
   // See through casts and unary operators.
   asm goto("" : "=r" (*(unsigned int *)(&val)) ::: indirect);
   *x = val;
   return 0;
 indirect:
   return -1;
 }
 
+// test7: Expect no diagnostics.
 int test7(int z) {
-    int x; // expected-warning {{variable 'x' is used uninitialized whenever its declaration is reached}}
-           // expected-note@-1 {{initialize the variable 'x' to silence this warning}}
+    int x;
     if (z)
       asm goto ("":"=r"(x):::A1,A2);
     return 0;
     A1:
     A2:
-    return x; // expected-note {{uninitialized use occurs here}}
+    return x;
 }
 
+// test8: Expect no diagnostics
 int test8() {
-    int x = 0; // expected-warning {{variable 'x' is used uninitialized whenever its declaration is reached}}
-               // expected-note@-1 {{variable 'x' is declared here}}
+    int x = 0;
     asm goto ("":"=r"(x):::A1,A2);
     return 0;
     A1:
     A2:
-    return x; // expected-note {{uninitialized use occurs here}}
+    return x;
+}
+
+// test9: Expect no diagnostics
+int test9 (int x) {
+    int y;
+    asm goto("": "=r"(y) :::out);
+    return 42;
+out:
+    return y;
+}
+
+int test10() {
+  int y; // expected-note {{initialize the variable 'y' to silence this warning}}
+  asm goto(""::::out);
+  return 42;
+out:
+  return y; // expected-warning {{variable 'y' is uninitialized when used here}}
 }