[WebAssembly] Update InstPrinter and AsmParser for new EH instructions

[aheejin]

Summary

This updates InstPrinter and AsmParser for delegate and catch_all
instructions. Both will reject programs with multiple catch_alls per a
single try. And InstPrinter uses EHInstStack to figure out whether
to print catch label comments: It does not print catch label comments
for second catch or catch_all in a try.

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

class WebAssemblyAsmParser final : public MCTargetAsmParser {
   } CurrentState = FileStart;
 
   // For ensuring blocks are properly nested.
   enum NestingType {
     Function,
     Block,
     Loop,
     Try,
+    CatchAll,
     If,
     Else,
     Undefined,
   };
   std::vector<NestingType> NestingStack;
 
   MCSymbol *LastFunctionLabel = nullptr;
 
std::pair<StringRef, StringRef> nestingString(NestingType NT) {
     switch (NT) {
     case Function:
       return {"function", "end_function"};
     case Block:
       return {"block", "end_block"};
     case Loop:
       return {"loop", "end_loop"};
     case Try:
-      return {"try", "end_try"};
+      return {"try", "end_try/delegate"};
+    case CatchAll:
+      return {"catch_all", "end_try"};
     case If:
       return {"if", "end_if"};
     case Else:
       return {"else", "end_if"};
     default:
       llvm_unreachable("unknown NestingType");
     }
   }
bool ParseInstruction(ParseInstructionInfo & /*Info*/, StringRef Name,
     } else if (Name == "else") {
       if (pop(Name, If))
         return true;
       push(Else);
     } else if (Name == "catch") {
       if (pop(Name, Try))
         return true;
       push(Try);
+    } else if (Name == "catch_all") {
+      if (pop(Name, Try))
+        return true;
+      push(CatchAll);
     } else if (Name == "end_if") {
       if (pop(Name, If, Else))
         return true;
     } else if (Name == "end_try") {
+      if (pop(Name, Try, CatchAll))
+        return true;
+    } else if (Name == "delegate") {
       if (pop(Name, Try))
         return true;
     } else if (Name == "end_loop") {
       if (pop(Name, Loop))
         return true;
     } else if (Name == "end_block") {
       if (pop(Name, Block))
         return true;

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyInstPrinter.h

class WebAssemblyInstPrinter final : public MCInstPrinter {
   SmallVector<std::pair<uint64_t, bool>, 4> ControlFlowStack;
   SmallVector<uint64_t, 4> EHPadStack;
   // 'delegate' can target any block-like structure, but in case the target is
   // 'try', it rethrows to the corresponding 'catch'. Because it can target all
   // blocks but with a slightly different semantics with branches, we need a
   // separate stack for 'delegate'.
   SmallVector<uint64_t, 4> DelegateStack;
 
+  enum EHInstKind { TRY, CATCH, CATCH_ALL };
+  SmallVector<EHInstKind, 4> EHInstStack;
+
 public:
   WebAssemblyInstPrinter(const MCAsmInfo &MAI, const MCInstrInfo &MII,
                          const MCRegisterInfo &MRI);
 
   void printRegName(raw_ostream &OS, unsigned RegNo) const override;
   void printInst(const MCInst *MI, uint64_t Address, StringRef Annot,
                  const MCSubtargetInfo &STI, raw_ostream &OS) override;
 

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyInstPrinter.cpp

case WebAssembly::BLOCK_S:
       DelegateStack.push_back(ControlFlowCounter++);
       return;
 
     case WebAssembly::TRY:
     case WebAssembly::TRY_S:
       ControlFlowStack.push_back(std::make_pair(ControlFlowCounter, false));
       EHPadStack.push_back(ControlFlowCounter);
       DelegateStack.push_back(ControlFlowCounter++);
+      EHInstStack.push_back(TRY);
       return;
 
     case WebAssembly::END_LOOP:
     case WebAssembly::END_LOOP_S:
       if (ControlFlowStack.empty() || DelegateStack.empty()) {
         printAnnotation(OS, "End marker mismatch!");
       } else {
         ControlFlowStack.pop_back();
case WebAssembly::END_BLOCK_S:
         printAnnotation(
             OS, "label" + utostr(ControlFlowStack.pop_back_val().first) + ':');
         DelegateStack.pop_back();
       }
       return;
 
     case WebAssembly::END_TRY:
     case WebAssembly::END_TRY_S:
-      if (ControlFlowStack.empty()) {
+      if (ControlFlowStack.empty() || EHInstStack.empty()) {
         printAnnotation(OS, "End marker mismatch!");
       } else {
         printAnnotation(
             OS, "label" + utostr(ControlFlowStack.pop_back_val().first) + ':');
+        EHInstStack.pop_back();
       }
       return;
 
     case WebAssembly::CATCH:
     case WebAssembly::CATCH_S:
     case WebAssembly::CATCH_ALL:
     case WebAssembly::CATCH_ALL_S:
+      // There can be multiple catch instructions for one try instruction, so
+      // we print a label only for the first 'catch' label.
+      if (EHInstStack.empty()) {
+        printAnnotation(OS, "try-catch mismatch!");
+      } else if (EHInstStack.back() == CATCH_ALL) {
+        printAnnotation(OS, "catch/catch_all cannot occur after catch_all");
+      } else if (EHInstStack.back() == TRY) {
         if (EHPadStack.empty() || DelegateStack.empty()) {
           printAnnotation(OS, "try-catch mismatch!");
         } else {
-        printAnnotation(OS, "catch" + utostr(EHPadStack.pop_back_val()) + ':');
+          printAnnotation(OS,
+                          "catch" + utostr(EHPadStack.pop_back_val()) + ':');
           DelegateStack.pop_back();
         }
+        EHInstStack.pop_back();
+        if (Opc == WebAssembly::CATCH || Opc == WebAssembly::CATCH_S) {
+          EHInstStack.push_back(CATCH);
+        } else {
+          EHInstStack.push_back(CATCH_ALL);
+        }
+      }
       return;
 
     case WebAssembly::RETHROW:
     case WebAssembly::RETHROW_S:
       // 'rethrow' rethrows to the nearest enclosing catch scope, if any. If
       // there's no enclosing catch scope, it throws up to the caller.
       if (EHPadStack.empty()) {
         printAnnotation(OS, "to caller");
       } else {
         printAnnotation(OS, "down to catch" + utostr(EHPadStack.back()));
       }
       return;
 
     case WebAssembly::DELEGATE:
     case WebAssembly::DELEGATE_S:
       if (ControlFlowStack.empty() || EHPadStack.empty() ||
-          DelegateStack.empty()) {
+          DelegateStack.empty() || EHInstStack.empty()) {
         printAnnotation(OS, "try-delegate mismatch!");
       } else {
         // 'delegate' is
         // 1. A marker for the end of block label
         // 2. A destination for throwing instructions
         // 3. An instruction that itself rethrows to another 'catch'
         assert(ControlFlowStack.back().first == EHPadStack.back() &&
                EHPadStack.back() == DelegateStack.back());
         std::string Label = "label/catch" +
                             utostr(ControlFlowStack.pop_back_val().first) +
                             ": ";
         EHPadStack.pop_back();
         DelegateStack.pop_back();
+        EHInstStack.pop_back();
         uint64_t Depth = MI->getOperand(0).getImm();
         if (Depth >= DelegateStack.size()) {
           Label += "to caller";
         } else {
           Label += "down to catch" + utostr(DelegateStack.rbegin()[Depth]);
         }
         printAnnotation(OS, Label);
       }

llvm/test/MC/WebAssembly/annotations.s

test_annotation:
   br_if     0
   loop
   br_if     1
   end_loop
   end_block
   try
   rethrow   0
   catch     __cpp_exception
+  catch_all
   block
   try
   br        0
+  try
+  delegate  1
   catch_all
   end_try
   end_block
   rethrow   0
   end_try
   end_try
   end_function
 
 
 # CHECK:      test_annotation:
 # CHECK:        try
 # CHECK-NEXT:   br        0               # 0: down to label0
 # CHECK-NEXT:   catch     __cpp_exception # catch0:
 # CHECK-NEXT:   block
 # CHECK-NEXT:   br_if     0               # 0: down to label1
 # CHECK-NEXT:   loop                      # label2:
 # CHECK-NEXT:   br_if     1               # 1: down to label1
 # CHECK-NEXT:   end_loop
 # CHECK-NEXT:   end_block                 # label1:
 # CHECK-NEXT:   try
 # CHECK-NEXT:   rethrow   0               # down to catch3
 # CHECK-NEXT:   catch     __cpp_exception # catch3:
+# CHECK-NEXT:   catch_all{{$}}
 # CHECK-NEXT:   block
 # CHECK-NEXT:   try
 # CHECK-NEXT:   br        0               # 0: down to label5
+# CHECK-NEXT:   try
+# CHECK-NEXT:   delegate    1             # label/catch6: down to catch4
 # CHECK-NEXT:   catch_all                 # catch5:
 # CHECK-NEXT:   end_try                   # label5:
 # CHECK-NEXT:   end_block                 # label4:
 # CHECK-NEXT:   rethrow   0               # to caller
 # CHECK-NEXT:   end_try                   # label3:
 # CHECK-NEXT:   end_try                   # label0:
 # CHECK-NEXT:   end_function
 

llvm/test/MC/WebAssembly/basic-assembly-errors.s

 test0:
     .functype   test0 () -> ()
 # CHECK: Block construct type mismatch, expected: end_function, instead got: end_loop
     end_loop
     block
 # CHECK: Block construct type mismatch, expected: end_block, instead got: end_if
     end_if
     try
+# CHECK: Block construct type mismatch, expected: end_try/delegate, instead got: end_block
+    end_block
     loop
-# CHECK: Block construct type mismatch, expected: end_loop, instead got: end_function
+    try
+    catch_all
+    catch_all
+# CHECK: error: Block construct type mismatch, expected: end_try, instead got: catch_all
+    end
+# CHECK: Block construct type mismatch, expected: end_try, instead got: end_function
+# CHECK: error: Unmatched block construct(s) at function end: catch_all
 # CHECK: error: Unmatched block construct(s) at function end: loop
 # CHECK: error: Unmatched block construct(s) at function end: try
 # CHECK: error: Unmatched block construct(s) at function end: block
 # CHECK: error: Unmatched block construct(s) at function end: function
     end_function