TryOp & Catchers Parsers and printers

Author: AmrDeveloper

clang/include/clang/CIR/Dialect/IR/CIRAttrConstraints.td

@@ -38,14 +38,32 @@ def CIR_AnyIntOrFloatAttr : AnyAttrOf<[CIR_AnyIntAttr, CIR_AnyFPAttr],
   string cppType = "::mlir::TypedAttr";
 }
 
+//===----------------------------------------------------------------------===//
+// Exceptions constraints
+//===----------------------------------------------------------------------===//
+
+def CIR_AnyCatchAllAttr
+    : CIR_AttrConstraint<"::cir::CatchAllAttr", "catch all attribute">;
+
+def CIR_AnyUnwindAttr
+    : CIR_AttrConstraint<"::cir::UnwindAttr", "unwind attribute">;
+
 //===----------------------------------------------------------------------===//
 // GlobalViewAttr constraints
 //===----------------------------------------------------------------------===//
 
-def CIR_AnyGlobalViewAttr : CIR_AttrConstraint<"::cir::GlobalViewAttr", "GlobalView attribute">;
+def CIR_AnyGlobalViewAttr
+    : CIR_AttrConstraint<"::cir::GlobalViewAttr", "GlobalView attribute">;
 
-def CIR_AnyIntOrGlobalViewAttr : AnyAttrOf<[CIR_AnyIntAttr, CIR_AnyGlobalViewAttr],
-    "integer or global view attribute"> {
+def CIR_AnyIntOrGlobalViewAttr
+    : AnyAttrOf<[CIR_AnyIntAttr, CIR_AnyGlobalViewAttr],
+                "integer or global view attribute"> {
+  string cppType = "::mlir::TypedAttr";
+}
+
+def CIR_AnyGlobalViewOrCatchAllOrUnwindAttr
+    : AnyAttrOf<[CIR_AnyGlobalViewAttr, CIR_AnyCatchAllAttr, CIR_AnyUnwindAttr],
+                "catch all or unwind or global view attribute"> {
   string cppType = "::mlir::TypedAttr";
 }
 
@@ -61,4 +79,8 @@ def CIR_IntOrGlobalViewArrayAttr : TypedArrayAttrBase<CIR_AnyIntOrGlobalViewAttr
   string cppType = "::mlir::ArrayAttr";
 }
 
-#endif // CLANG_CIR_DIALECT_IR_CIRATTRCONSTRAINTS_TD
+def CIR_GlobalViewOrCatchAllOrUnwindArrayAttr
+    : TypedArrayAttrBase<CIR_AnyGlobalViewOrCatchAllOrUnwindAttr,
+                         "catch all or unwind or global view array attribute">;
+
+#endif // CLANG_CIR_DIALECT_IR_CIRATTRCONSTRAINTS_TD

clang/include/clang/CIR/Dialect/IR/CIRAttrs.td

@@ -969,18 +969,18 @@ def CIR_TypeInfoAttr : CIR_Attr<"TypeInfo", "typeinfo", [TypedAttrInterface]> {
 }
 
 //===----------------------------------------------------------------------===//
-// CatchAllAttr & CatchUnwindAttr
+// CatchAllAttr & UnwindAttr
 //===----------------------------------------------------------------------===//
 
-// Represents the unwind region where unwind continues or
-// the program std::terminate's.
-def CIR_CatchUnwindAttr : CIR_UnitAttr<"CatchUnwind", "unwind"> {
-  let storageType = [{ CatchUnwind }];
-}
-
 // Represents the catch_all region.
 def CIR_CatchAllAttr : CIR_UnitAttr<"CatchAll", "all"> {
   let storageType = [{ CatchAllAttr }];
 }
 
+// Represents the unwind region where unwind continues or
+// the program std::terminate's.
+def CIR_UnwindAttr : CIR_UnitAttr<"Unwind", "unwind"> {
+  let storageType = [{ CatchUnwind }];
+}
+
 #endif // CLANG_CIR_DIALECT_IR_CIRATTRS_TD

clang/include/clang/CIR/Dialect/IR/CIROps.td

@@ -4363,10 +4363,16 @@ def CIR_TryOp : CIR_Op<"try",[
     ```
   }];
 
-  let arguments = (ins UnitAttr:$synthetic, UnitAttr:$cleanup,
-                       OptionalAttr<ArrayAttr>:$catch_types);
-  let regions = (region AnyRegion:$try_region,
-                        VariadicRegion<AnyRegion>:$catch_regions);
+  let arguments = (ins
+    UnitAttr:$synthetic,
+    UnitAttr:$cleanup,
+    CIR_GlobalViewOrCatchAllOrUnwindArrayAttr:$catch_types
+  );
+
+  let regions = (region
+    AnyRegion:$try_region,
+    VariadicRegion<MinSizedRegion<1>>:$catch_regions
+  );
 
   let assemblyFormat = [{
     (`synthetic` $synthetic^)?
@@ -4376,7 +4382,6 @@ def CIR_TryOp : CIR_Op<"try",[
     attr-dict
   }];
 
-  // Everything already covered elsewhere.
   let builders = [
     OpBuilder<(ins
       "llvm::function_ref<void(mlir::OpBuilder &, "
@@ -4390,7 +4395,7 @@ def CIR_TryOp : CIR_Op<"try",[
       OpBuilder::InsertionGuard guard($_builder);
 
       // Try body region
-      Region *tryBodyRegion = $_state.addRegion();
+      mlir::Region *tryBodyRegion = $_state.addRegion();
 
       // Create try body region and set insertion point
       $_builder.createBlock(tryBodyRegion);

clang/lib/CIR/Dialect/IR/CIRDialect.cpp

@@ -2919,113 +2919,117 @@ LogicalResult cir::TypeInfoAttr::verify(
 //===----------------------------------------------------------------------===//
 
 void cir::TryOp::getSuccessorRegions(
-    mlir::RegionBranchPoint point, SmallVectorImpl<RegionSuccessor> &regions) {
-  // If any index all the underlying regions branch back to the parent
-  // operation.
+    mlir::RegionBranchPoint point,
+    llvm::SmallVectorImpl<mlir::RegionSuccessor> &regions) {
+  // The `try` and the `catchers` region branch back to the parent operation.
   if (!point.isParent()) {
-    regions.push_back(RegionSuccessor());
+    regions.push_back(mlir::RegionSuccessor());
     return;
   }
 
-  // If the condition isn't constant, both regions may be executed.
-  regions.push_back(RegionSuccessor(&getTryRegion()));
+  regions.push_back(mlir::RegionSuccessor(&getTryRegion()));
 
-  // FIXME: optimize, ideas include:
-  // - If we know a target function never throws a specific type, we can
-  //   remove the catch handler.
-  for (mlir::Region &r : this->getCatchRegions())
-    regions.push_back(RegionSuccessor(&r));
+  // TODO(CIR): If we know a target function never throws a specific type, we
+  // can remove the catch handler.
+  for (mlir::Region &region : this->getCatchRegions())
+    regions.push_back(mlir::RegionSuccessor(&region));
 }
 
-static void printCatchRegions(OpAsmPrinter &printer, cir::TryOp op,
-                              mlir::MutableArrayRef<::mlir::Region> regions,
+static void printCatchRegions(mlir::OpAsmPrinter &printer, cir::TryOp op,
+                              mlir::MutableArrayRef<mlir::Region> regions,
                               mlir::ArrayAttr catchersAttr) {
   if (!catchersAttr)
     return;
 
-  int currCatchIdx = 0;
-  printer << "catch [";
-  llvm::interleaveComma(catchersAttr, printer, [&](const Attribute &a) {
-    if (mlir::isa<cir::CatchUnwindAttr>(a)) {
-      printer.printAttribute(a);
+  for (const auto [catcherIdx, catcherAttr] : llvm::enumerate(catchersAttr)) {
+    if (catcherIdx)
       printer << " ";
-    } else if (!a) {
-      printer << "all";
+
+    if (mlir::isa<cir::CatchAllAttr>(catcherAttr)) {
+      printer << "catch all ";
+    } else if (mlir::isa<cir::UnwindAttr>(catcherAttr)) {
+      printer << "unwind ";
     } else {
-      printer << "type ";
-      printer.printAttribute(a);
-      printer << " ";
+      printer << "catch [type ";
+      printer.printAttribute(catcherAttr);
+      printer << "] ";
     }
-    printer.printRegion(regions[currCatchIdx], /*printEntryBLockArgs=*/false,
-                        /*printBlockTerminators=*/true);
-    currCatchIdx++;
-  });
 
-  printer << "]";
+    printer.printRegion(regions[catcherIdx], /*printEntryBLockArgs=*/false,
+                        /*printBlockTerminators=*/true);
+  }
 }
 
-static ParseResult parseCatchRegions(
-    OpAsmParser &parser,
-    llvm::SmallVectorImpl<std::unique_ptr<::mlir::Region>> &regions,
-    ::mlir::ArrayAttr &catchersAttr) {
-  if (parser.parseKeyword("catch").failed())
-    return parser.emitError(parser.getCurrentLocation(),
-                            "expected 'catch' keyword here");
+static mlir::ParseResult
+parseCatchRegions(mlir::OpAsmParser &parser,
+                  llvm::SmallVectorImpl<std::unique_ptr<mlir::Region>> &regions,
+                  mlir::ArrayAttr &catchersAttr) {
 
-  auto parseAndCheckRegion = [&]() -> ParseResult {
-    // Parse region attached to catch
-    regions.emplace_back(new Region);
-    Region &currRegion = *regions.back();
-    SMLoc parserLoc = parser.getCurrentLocation();
+  auto parseCheckedCatcherRegion = [&]() -> mlir::ParseResult {
+    regions.emplace_back(new mlir::Region);
+
+    mlir::Region &currRegion = *regions.back();
+    mlir::SMLoc regionLoc = parser.getCurrentLocation();
     if (parser.parseRegion(currRegion)) {
       regions.clear();
       return failure();
     }
 
-    if (currRegion.empty()) {
-      return parser.emitError(parser.getCurrentLocation(),
-                              "catch region shall not be empty");
-    }
-
-    if (!(currRegion.back().mightHaveTerminator() &&
-          currRegion.back().getTerminator()))
+    if (!currRegion.empty() && !(currRegion.back().mightHaveTerminator() &&
+                                 currRegion.back().getTerminator()))
       return parser.emitError(
-          parserLoc, "blocks are expected to be explicitly terminated");
+          regionLoc, "blocks are expected to be explicitly terminated");
 
     return success();
   };
 
-  llvm::SmallVector<mlir::Attribute, 4> catchList;
-  auto parseCatchEntry = [&]() -> ParseResult {
-    mlir::Attribute exceptionTypeInfo;
+  bool hasCatchAll = false;
+  llvm::SmallVector<mlir::Attribute, 4> catcherAttrs;
+  while (parser.parseOptionalKeyword("catch").succeeded()) {
+    bool hasLSquare = parser.parseOptionalLSquare().succeeded();
 
-    if (parser.parseOptionalAttribute(exceptionTypeInfo).has_value()) {
-      catchList.push_back(exceptionTypeInfo);
-    } else {
-      ::llvm::StringRef attrStr;
-      if (parser.parseOptionalKeyword(&attrStr, {"all"}).succeeded()) {
-        // "all" keyword found, exceptionTypeInfo remains null
-      } else if (parser.parseOptionalKeyword("type").succeeded()) {
-        if (parser.parseAttribute(exceptionTypeInfo).failed())
-          return parser.emitError(parser.getCurrentLocation(),
-                                  "expected valid RTTI info attribute");
-      } else {
+    llvm::StringRef attrStr;
+    if (parser.parseOptionalKeyword(&attrStr, {"all", "type"}).failed())
+      return parser.emitError(parser.getCurrentLocation(),
+                              "expected 'all' or 'type' keyword");
+
+    bool isCatchAll = attrStr == "all";
+    if (isCatchAll) {
+      if (hasCatchAll)
         return parser.emitError(parser.getCurrentLocation(),
-                                "expected attribute, 'all', or 'type' keyword");
-      }
-      catchList.push_back(exceptionTypeInfo);
+                                "can't have more than one catch all");
+      hasCatchAll = true;
     }
-    return parseAndCheckRegion();
-  };
 
-  if (parser
-          .parseCommaSeparatedList(OpAsmParser::Delimiter::Square,
-                                   parseCatchEntry, " in catch list")
-          .failed())
-    return failure();
+    mlir::Attribute exceptionRTTIAttr;
+    if (!isCatchAll && parser.parseAttribute(exceptionRTTIAttr).failed())
+      return parser.emitError(parser.getCurrentLocation(),
+                              "expected valid RTTI info attribute");
 
-  catchersAttr = parser.getBuilder().getArrayAttr(catchList);
-  return ::mlir::success();
+    catcherAttrs.push_back(isCatchAll
+                               ? cir::CatchAllAttr::get(parser.getContext())
+                               : exceptionRTTIAttr);
+
+    if (hasLSquare && isCatchAll)
+      return parser.emitError(parser.getCurrentLocation(),
+                              "catch all dosen't need RTTI info attribute");
+
+    if (hasLSquare && parser.parseRSquare().failed())
+      return parser.emitError(parser.getCurrentLocation(),
+                              "expected `]` after RTTI info attribute");
+
+    if (parseCheckedCatcherRegion().failed())
+      return mlir::failure();
+  }
+
+  if (parser.parseOptionalKeyword("unwind").succeeded()) {
+    catcherAttrs.push_back(cir::UnwindAttr::get(parser.getContext()));
+    if (parseCheckedCatcherRegion().failed())
+      return mlir::failure();
+  }
+
+  catchersAttr = parser.getBuilder().getArrayAttr(catcherAttrs);
+  return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//