[NFC][mlir] Adding more operators to EDSC TemplatedIndexedValue

[kernhanda]

Summary

This change adds some missing arithmetic and logical operators to TemplatedIndexedValue for EDSC usage.

[ftynse]

mlir/include/mlir/EDSC/Builders.h

602

Could we have some block comments here? In particular, separating the two groups of operators (taking ValueHandle and taking TemplatedIndexedValue).

[kernhanda]

Added comments

mlir/include/mlir/Dialect/AffineOps/EDSC/Builders.h

 ValueHandle operator!=(ValueHandle lhs, ValueHandle rhs);
 ValueHandle operator<(ValueHandle lhs, ValueHandle rhs);
 ValueHandle operator<=(ValueHandle lhs, ValueHandle rhs);
 ValueHandle operator>(ValueHandle lhs, ValueHandle rhs);
 ValueHandle operator>=(ValueHandle lhs, ValueHandle rhs);
 
 } // namespace op
 
-/// Operator overloadings.
+/// Arithmetic operator overloadings.
 template <typename Load, typename Store>
 ValueHandle TemplatedIndexedValue<Load, Store>::operator+(ValueHandle e) {
   using op::operator+;
   return static_cast<ValueHandle>(*this) + e;
 }
 template <typename Load, typename Store>
 ValueHandle TemplatedIndexedValue<Load, Store>::operator-(ValueHandle e) {
   using op::operator-;
   return static_cast<ValueHandle>(*this) - e;
 }
 template <typename Load, typename Store>
 ValueHandle TemplatedIndexedValue<Load, Store>::operator*(ValueHandle e) {
   using op::operator*;
   return static_cast<ValueHandle>(*this) * e;
 }
 template <typename Load, typename Store>
 ValueHandle TemplatedIndexedValue<Load, Store>::operator/(ValueHandle e) {
   using op::operator/;
   return static_cast<ValueHandle>(*this) / e;
 }
+template <typename Load, typename Store>
+ValueHandle TemplatedIndexedValue<Load, Store>::operator%(ValueHandle e) {
+  using op::operator%;
+  return static_cast<ValueHandle>(*this) % e;
+}
+template <typename Load, typename Store>
+ValueHandle TemplatedIndexedValue<Load, Store>::operator^(ValueHandle e) {
+  using op::operator^;
+  return static_cast<ValueHandle>(*this) ^ e;
+}
 
+/// Assignment-arithmetic operator overloadings.
 template <typename Load, typename Store>
 OperationHandle TemplatedIndexedValue<Load, Store>::operator+=(ValueHandle e) {
   using op::operator+;
   return Store(*this + e, getBase(), {indices.begin(), indices.end()});
 }
 template <typename Load, typename Store>
 OperationHandle TemplatedIndexedValue<Load, Store>::operator-=(ValueHandle e) {
   using op::operator-;
   return Store(*this - e, getBase(), {indices.begin(), indices.end()});
 }
 template <typename Load, typename Store>
 OperationHandle TemplatedIndexedValue<Load, Store>::operator*=(ValueHandle e) {
   using op::operator*;
   return Store(*this * e, getBase(), {indices.begin(), indices.end()});
 }
 template <typename Load, typename Store>
 OperationHandle TemplatedIndexedValue<Load, Store>::operator/=(ValueHandle e) {
   using op::operator/;
   return Store(*this / e, getBase(), {indices.begin(), indices.end()});
 }
+template <typename Load, typename Store>
+OperationHandle TemplatedIndexedValue<Load, Store>::operator%=(ValueHandle e) {
+  using op::operator%;
+  return Store(*this % e, getBase(), {indices.begin(), indices.end()});
+}
+template <typename Load, typename Store>
+OperationHandle TemplatedIndexedValue<Load, Store>::operator^=(ValueHandle e) {
+  using op::operator^;
+  return Store(*this ^ e, getBase(), {indices.begin(), indices.end()});
+}
+
+/// Logical operator overloadings.
+template <typename Load, typename Store>
+ValueHandle TemplatedIndexedValue<Load, Store>::operator&&(ValueHandle e) {
+  using op::operator&&;
+  return static_cast<ValueHandle>(*this) && e;
+}
+template <typename Load, typename Store>
+ValueHandle TemplatedIndexedValue<Load, Store>::operator||(ValueHandle e) {
+  using op::operator||;
+  return static_cast<ValueHandle>(*this) || e;
+}
+
+/// Comparison operator overloadings.
+template <typename Load, typename Store>
+ValueHandle TemplatedIndexedValue<Load, Store>::operator==(ValueHandle e) {
+  using op::operator==;
+  return static_cast<ValueHandle>(*this) == e;
+}
+template <typename Load, typename Store>
+ValueHandle TemplatedIndexedValue<Load, Store>::operator!=(ValueHandle e) {
+  using op::operator!=;
+  return static_cast<ValueHandle>(*this) != e;
+}
+template <typename Load, typename Store>
+ValueHandle TemplatedIndexedValue<Load, Store>::operator<(ValueHandle e) {
+  using op::operator<;
+  return static_cast<ValueHandle>(*this) < e;
+}
+template <typename Load, typename Store>
+ValueHandle TemplatedIndexedValue<Load, Store>::operator<=(ValueHandle e) {
+  using op::operator<=;
+  return static_cast<ValueHandle>(*this) <= e;
+}
+template <typename Load, typename Store>
+ValueHandle TemplatedIndexedValue<Load, Store>::operator>(ValueHandle e) {
+  using op::operator>;
+  return static_cast<ValueHandle>(*this) > e;
+}
+template <typename Load, typename Store>
+ValueHandle TemplatedIndexedValue<Load, Store>::operator>=(ValueHandle e) {
+  using op::operator>=;
+  return static_cast<ValueHandle>(*this) >= e;
+}
 
 } // namespace edsc
 } // namespace mlir
 
 #endif // MLIR_DIALECT_AFFINEOPS_EDSC_BUILDERS_H_

mlir/include/mlir/EDSC/Builders.h

public:
 
   /// Emits a `load` when converting to a Value.
   Value operator*(void)const {
     return Load(getBase(), {indices.begin(), indices.end()}).getValue();
   }
 
   ValueHandle getBase() const { return base; }
 
-  /// Operator overloadings.
+  /// Arithmetic operator overloadings.
   ValueHandle operator+(ValueHandle e);
   ValueHandle operator-(ValueHandle e);
   ValueHandle operator*(ValueHandle e);
   ValueHandle operator/(ValueHandle e);
-  OperationHandle operator+=(ValueHandle e);
-  OperationHandle operator-=(ValueHandle e);
-  OperationHandle operator*=(ValueHandle e);
-  OperationHandle operator/=(ValueHandle e);
+  ValueHandle operator%(ValueHandle e);
+  ValueHandle operator^(ValueHandle e);
   ValueHandle operator+(TemplatedIndexedValue e) {
     return *this + static_cast<ValueHandle>(e);
   }
   ValueHandle operator-(TemplatedIndexedValue e) {
     return *this - static_cast<ValueHandle>(e);
   }
   ValueHandle operator*(TemplatedIndexedValue e) {
     return *this * static_cast<ValueHandle>(e);
   }
   ValueHandle operator/(TemplatedIndexedValue e) {
     return *this / static_cast<ValueHandle>(e);
   }
+  ValueHandle operator%(TemplatedIndexedValue e) {
+    return *this % static_cast<ValueHandle>(e);
+  }
+  ValueHandle operator^(TemplatedIndexedValue e) {
+    return *this ^ static_cast<ValueHandle>(e);
+  }
+
+  /// Assignment-arithmetic operator overloadings.
+  OperationHandle operator+=(ValueHandle e);
+  OperationHandle operator-=(ValueHandle e);
+  OperationHandle operator*=(ValueHandle e);
+  OperationHandle operator/=(ValueHandle e);
+  OperationHandle operator%=(ValueHandle e);
+  OperationHandle operator^=(ValueHandle e);
   OperationHandle operator+=(TemplatedIndexedValue e) {
     return this->operator+=(static_cast<ValueHandle>(e));
   }
   OperationHandle operator-=(TemplatedIndexedValue e) {
     return this->operator-=(static_cast<ValueHandle>(e));
   }
   OperationHandle operator*=(TemplatedIndexedValue e) {
     return this->operator*=(static_cast<ValueHandle>(e));
   }
   OperationHandle operator/=(TemplatedIndexedValue e) {
     return this->operator/=(static_cast<ValueHandle>(e));
   }
+  OperationHandle operator%=(TemplatedIndexedValue e) {
+    return this->operator%=(static_cast<ValueHandle>(e));
+  }
+  OperationHandle operator^=(TemplatedIndexedValue e) {
+    return this->operator^=(static_cast<ValueHandle>(e));
+  }
+
+  /// Logical operator overloadings.
+  ValueHandle operator&&(ValueHandle e);
+  ValueHandle operator||(ValueHandle e);
+  ValueHandle operator&&(TemplatedIndexedValue e) {
+    return *this && static_cast<ValueHandle>(e);
+  }
+  ValueHandle operator||(TemplatedIndexedValue e) {
+    return *this || static_cast<ValueHandle>(e);
+  }
+
+  /// Comparison operator overloadings.
+  ValueHandle operator==(ValueHandle e);
+  ValueHandle operator!=(ValueHandle e);
+  ValueHandle operator<(ValueHandle e);
+  ValueHandle operator<=(ValueHandle e);
+  ValueHandle operator>(ValueHandle e);
+  ValueHandle operator>=(ValueHandle e);
+  ValueHandle operator==(TemplatedIndexedValue e) {
+    return *this == static_cast<ValueHandle>(e);
+  }
+  ValueHandle operator!=(TemplatedIndexedValue e) {
+    return *this != static_cast<ValueHandle>(e);
+  }
+  ValueHandle operator<(TemplatedIndexedValue e) {
+    return *this < static_cast<ValueHandle>(e);
+  }
+  ValueHandle operator<=(TemplatedIndexedValue e) {
+    return *this <= static_cast<ValueHandle>(e);
+  }
+  ValueHandle operator>(TemplatedIndexedValue e) {
+    return *this > static_cast<ValueHandle>(e);
+  }
+  ValueHandle operator>=(TemplatedIndexedValue e) {
+    return *this >= static_cast<ValueHandle>(e);
+  }
 
 private:
   TemplatedIndexedValue(ValueHandle base, ArrayRef<ValueHandle> indices)
       : base(base), indices(indices.begin(), indices.end()) {}
 
   TemplatedIndexedValue &append() { return *this; }
 
   template <typename T, typename... Args>