Revert "[CIR] Upstream simple function bodies (llvm#127674)"

This reverts commit f8bdbed.

Author: lanza

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

@@ -11,8 +11,8 @@
 ///
 //===----------------------------------------------------------------------===//
 
-#ifndef CLANG_CIR_DIALECT_IR_CIROPS_TD
-#define CLANG_CIR_DIALECT_IR_CIROPS_TD
+#ifndef LLVM_CLANG_CIR_DIALECT_IR_CIROPS
+#define LLVM_CLANG_CIR_DIALECT_IR_CIROPS
 
 include "clang/CIR/Dialect/IR/CIRDialect.td"
 include "clang/CIR/Dialect/IR/CIRTypes.td"
@@ -115,165 +115,6 @@ def ConstantOp : CIR_Op<"const",
   let hasFolder = 1;
 }
 
-//===----------------------------------------------------------------------===//
-// ReturnOp
-//===----------------------------------------------------------------------===//
-
-def ReturnOp : CIR_Op<"return", [ParentOneOf<["FuncOp", "ScopeOp"]>,
-                                 Terminator]> {
-  let summary = "Return from function";
-  let description = [{
-    The "return" operation represents a return operation within a function.
-    The operation takes an optional operand and produces no results.
-    The operand type must match the signature of the function that contains
-    the operation.
-
-    ```mlir
-      func @foo() -> i32 {
-        ...
-        cir.return %0 : i32
-      }
-    ```
-  }];
-
-  // The return operation takes an optional input operand to return. This
-  // value must match the return type of the enclosing function.
-  let arguments = (ins Variadic<CIR_AnyType>:$input);
-
-  // The return operation only emits the input in the format if it is present.
-  let assemblyFormat = "($input^ `:` type($input))? attr-dict ";
-
-  // Allow building a ReturnOp with no return operand.
-  let builders = [
-    OpBuilder<(ins), [{ build($_builder, $_state, std::nullopt); }]>
-  ];
-
-  // Provide extra utility definitions on the c++ operation class definition.
-  let extraClassDeclaration = [{
-    bool hasOperand() { return getNumOperands() != 0; }
-  }];
-
-  let hasVerifier = 1;
-}
-
-//===----------------------------------------------------------------------===//
-// YieldOp
-//===----------------------------------------------------------------------===//
-
-def YieldOp : CIR_Op<"yield", [ReturnLike, Terminator,
-                               ParentOneOf<["ScopeOp"]>]> {
-  let summary = "Represents the default branching behaviour of a region";
-  let description = [{
-    The `cir.yield` operation terminates regions on different CIR operations,
-    and it is used to represent the default branching behaviour of a region.
-    Said branching behaviour is determinted by the parent operation. For
-    example, a yield in a `switch-case` region implies a fallthrough, while
-    a yield in a `cir.if` region implies a branch to the exit block, and so
-    on.
-
-    In some cases, it might yield an SSA value and the semantics of how the
-    values are yielded is defined by the parent operation. For example, a
-    `cir.ternary` operation yields a value from one of its regions.
-
-    As a general rule, `cir.yield` must be explicitly used whenever a region has
-    more than one block and no terminator, or within `cir.switch` regions not
-    `cir.return` terminated.
-
-    Examples:
-    ```mlir
-    cir.if %4 {
-      ...
-      cir.yield
-    }
-
-    cir.switch (%5) [
-      case (equal, 3) {
-        ...
-        cir.yield
-      }, ...
-    ]
-
-    cir.scope {
-      ...
-      cir.yield
-    }
-
-    %x = cir.scope {
-      ...
-      cir.yield %val
-    }
-
-    %y = cir.ternary {
-      ...
-      cir.yield %val : i32
-    } : i32
-    ```
-  }];
-
-  let arguments = (ins Variadic<CIR_AnyType>:$args);
-  let assemblyFormat = "($args^ `:` type($args))? attr-dict";
-  let builders = [
-    OpBuilder<(ins), [{ /* nothing to do */ }]>,
-  ];
-}
-
-//===----------------------------------------------------------------------===//
-// ScopeOp
-//===----------------------------------------------------------------------===//
-
-def ScopeOp : CIR_Op<"scope", [
-       DeclareOpInterfaceMethods<RegionBranchOpInterface>,
-       RecursivelySpeculatable, AutomaticAllocationScope, NoRegionArguments]> {
-  let summary = "Represents a C/C++ scope";
-  let description = [{
-    `cir.scope` contains one region and defines a strict "scope" for all new
-    values produced within its blocks.
-
-    The region can contain an arbitrary number of blocks but usually defaults
-    to one and can optionally return a value (useful for representing values
-    coming out of C++ full-expressions) via `cir.yield`:
-
-
-    ```mlir
-    %rvalue = cir.scope {
-      ...
-      cir.yield %value
-    }
-    ```
-
-    The blocks can be terminated by `cir.yield`, `cir.return` or `cir.throw`.
-    If `cir.scope` yields no value, the `cir.yield` can be left out, and
-    will be inserted implicitly.
-  }];
-
-  let results = (outs Optional<CIR_AnyType>:$results);
-  let regions = (region AnyRegion:$scopeRegion);
-
-  let hasVerifier = 1;
-  let skipDefaultBuilders = 1;
-  let assemblyFormat = [{
-    custom<OmittedTerminatorRegion>($scopeRegion) (`:` type($results)^)? attr-dict
-  }];
-
-  let extraClassDeclaration = [{
-    /// Determine whether the scope is empty, meaning it contains a single block
-    /// terminated by a cir.yield.
-    bool isEmpty() {
-      auto &entry = getRegion().front();
-      return getRegion().hasOneBlock() &&
-        llvm::isa<YieldOp>(entry.front());
-      }
-    }];
-
-  let builders = [
-    // Scopes for yielding values.
-    OpBuilder<(ins
-              "llvm::function_ref<void(mlir::OpBuilder &, mlir::Type &, mlir::Location)>":$scopeBuilder)>,
-    // Scopes without yielding values.
-    OpBuilder<(ins "llvm::function_ref<void(mlir::OpBuilder &, mlir::Location)>":$scopeBuilder)>
-  ];
-}
-
 //===----------------------------------------------------------------------===//
 // GlobalOp
 //===----------------------------------------------------------------------===//
@@ -317,86 +158,25 @@ def GlobalOp : CIR_Op<"global"> {
 // FuncOp
 //===----------------------------------------------------------------------===//
 
-// TODO(CIR): FuncOp is still a tiny shell of what it will become.  Many more
-// properties and attributes will be added as upstreaming continues.
+// TODO(CIR): For starters, cir.func has only name, nothing else.  The other
+// properties of a function will be added over time as more of ClangIR is
+// upstreamed.
 
-def FuncOp : CIR_Op<"func", [
-  AutomaticAllocationScope, CallableOpInterface, FunctionOpInterface,
-  IsolatedFromAbove
-]> {
+def FuncOp : CIR_Op<"func"> {
   let summary = "Declare or define a function";
   let description = [{
     The `cir.func` operation defines a function, similar to the `mlir::FuncOp`
     built-in.
   }];
 
-  let arguments = (ins SymbolNameAttr:$sym_name,
-                       TypeAttrOf<CIR_FuncType>:$function_type,
-                       OptionalAttr<DictArrayAttr>:$arg_attrs,
-                       OptionalAttr<DictArrayAttr>:$res_attrs);
-
-  let regions = (region AnyRegion:$body);
+  let arguments = (ins SymbolNameAttr:$sym_name);
 
   let skipDefaultBuilders = 1;
 
-  let builders = [OpBuilder<(ins "llvm::StringRef":$sym_name,
-                                 "FuncType":$type)>];
-
-  let extraClassDeclaration = [{
-    /// Returns the region on the current operation that is callable. This may
-    /// return null in the case of an external callable object, e.g. an external
-    /// function.
-    ::mlir::Region *getCallableRegion();
-
-    /// Returns the results types that the callable region produces when
-    /// executed.
-    llvm::ArrayRef<mlir::Type> getCallableResults() {
-      return getFunctionType().getReturnTypes();
-    }
-
-    /// Returns the argument types of this function.
-    llvm::ArrayRef<mlir::Type> getArgumentTypes() {
-       return getFunctionType().getInputs();
-    }
-
-    /// Returns 0 or 1 result type of this function (0 in the case of a function
-    /// returing void)
-    llvm::ArrayRef<mlir::Type> getResultTypes() {
-       return getFunctionType().getReturnTypes();
-    }
-
-    /// Hook for OpTrait::FunctionOpInterfaceTrait, called after verifying that
-    /// the 'type' attribute is present and checks if it holds a function type.
-    /// Ensures getType, getNumFuncArguments, and getNumFuncResults can be
-    /// called safely.
-    llvm::LogicalResult verifyType();
-
-    //===------------------------------------------------------------------===//
-    // SymbolOpInterface Methods
-    //===------------------------------------------------------------------===//
-
-    bool isDeclaration();
-  }];
+  let builders = [OpBuilder<(ins "llvm::StringRef":$sym_name)>];
 
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
 }
 
-//===----------------------------------------------------------------------===//
-// TrapOp
-//===----------------------------------------------------------------------===//
-
-def TrapOp : CIR_Op<"trap", [Terminator]> {
-  let summary = "Exit the program abnormally";
-  let description = [{
-    The cir.trap operation causes the program to exit abnormally. The
-    implementations may implement this operation with different mechanisms. For
-    example, an implementation may implement this operation by calling abort,
-    while another implementation may implement this operation by executing an
-    illegal instruction.
-  }];
-
-  let assemblyFormat = "attr-dict";
-}
-
-#endif // CLANG_CIR_DIALECT_IR_CIROPS_TD
+#endif // LLVM_CLANG_CIR_DIALECT_IR_CIROPS