[mlir] Adapted standard Alloc and Alloca ops to use different side-effect resources.

[dfki-mako]

Summary

The current standard Alloca node is not annotated with the MemEffect<Alloc> trait. This CL updates the Alloc and Alloca memory-effect annotations using the latest Resource objects. Alloca nodes will use a newly defined AutomaticAllocationScopeResource to distinguish between Alloc and Alloca memory effects.

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

 class ComplexFloatArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
     ArithmeticOp<mnemonic, traits>,
     Arguments<(ins Complex<AnyFloat>:$lhs, Complex<AnyFloat>:$rhs)>;
 
 // Base class for memref allocating ops: alloca and alloc.
 //
 //   %0 = alloclike(%m)[%s] : memref<8x?xf32, (d0, d1)[s0] -> ((d0 + s0), d1)>
 //
-class AllocLikeOp<string mnemonic, list<OpTrait> traits = []> :
-    Std_Op<mnemonic, !listconcat(traits, [MemoryEffects<[MemAlloc]>])> {
+class AllocLikeOp<string mnemonic,
+                  Resource resource,
+                  list<OpTrait> traits = []> :
+    Std_Op<mnemonic, !listconcat([MemoryEffects<[MemAlloc<resource>]>], traits)> {
 
   let arguments = (ins Variadic<Index>:$value,
                    Confined<OptionalAttr<I64Attr>, [IntMinValue<0>]>:$alignment);
-  let results = (outs Res<AnyMemRef, "", [MemAlloc]>);
+  let results = (outs Res<AnyMemRef, "", [MemAlloc<resource>]>);
 
   let builders = [OpBuilder<
     "OpBuilder &builder, OperationState &result, MemRefType memrefType", [{
        result.types.push_back(memrefType);
      }]>,
     OpBuilder<
     "OpBuilder &builder, OperationState &result, MemRefType memrefType, " #
     "ValueRange operands, IntegerAttr alignment = IntegerAttr()", [{
def AddIOp : IntArithmeticOp<"addi", [Commutative]> {
   }];
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // AllocOp
 //===----------------------------------------------------------------------===//
 
-def AllocOp : AllocLikeOp<"alloc"> {
+def AllocOp : AllocLikeOp<"alloc", DefaultResource> {
   let summary = "memory allocation operation";
   let description = [{
     The `alloc` operation allocates a region of memory, as specified by its
     memref type.
 
     Example:
 
     ```mlir
let description = [{
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // AllocaOp
 //===----------------------------------------------------------------------===//
 
-def AllocaOp : AllocLikeOp<"alloca"> {
+def AllocaOp : AllocLikeOp<"alloca", AutomaticAllocationScopeResource> {
   let summary = "stack memory allocation operation";
   let description = [{
     The `alloca` operation allocates memory on the stack, to be automatically
     released when control transfers back from the region of its closest
     surrounding operation with an
     [`AutomaticAllocationScope`](../Traits.md#automaticallocationscope) trait.
     The amount of memory allocated is specified by its memref and additional
     operands. For example:

mlir/include/mlir/Interfaces/SideEffectInterfaces.td

 
 // An intrinsic resource that lives in the ::mlir::SideEffects namespace.
 class IntrinsicResource<string resourceName> :
   Resource<!strconcat("::mlir::SideEffects::", resourceName)> {
 }
 
 // A link to the DefaultResource class.
 def DefaultResource : IntrinsicResource<"DefaultResource">;
+// A link to the AutomaticAllocationScopeResource class.
+def AutomaticAllocationScopeResource :
+  IntrinsicResource<"AutomaticAllocationScopeResource">;
 
 //===----------------------------------------------------------------------===//
 // EffectOpInterface
 //===----------------------------------------------------------------------===//
 
 // A base interface used to query information about the side effects applied to
 // an operation. This template class takes the name of the derived interface
 // class, as well as the name of the base effect class.

mlir/include/mlir/Interfaces/SideEffects.h

private:
   TypeID id;
 };
 
 /// A conservative default resource kind.
 struct DefaultResource : public Resource::Base<DefaultResource> {
   StringRef getName() final { return "<Default>"; }
 };
 
+/// An automatic allocation-scope resource that is valid in the context of a
+/// parent AutomaticAllocationScope trait.
+struct AutomaticAllocationScopeResource
+    : public Resource::Base<AutomaticAllocationScopeResource> {
+  StringRef getName() final { return "AutomaticAllocationScope"; }
+};
+
 /// This class represents a specific instance of an effect. It contains the
 /// effect being applied, a resource that corresponds to where the effect is
 /// applied, and an optional value(either operand, result, or region entry
 /// argument) that the effect is applied to.
 template <typename EffectT> class EffectInstance {
 public:
   EffectInstance(EffectT *effect, Resource *resource = DefaultResource::get())
       : effect(effect), resource(resource) {}