This is an archive of the discontinued LLVM Phabricator instance.

Differential D74686

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

Authored by kernhanda on Feb 16 2020, 2:25 AM.

Details

Reviewers
nicolasvasilache
ftynse
mehdi_amini
Commits
rGd0b09f89e0ed: [NFC][mlir] Adding more operators to EDSC TemplatedIndexedValue
Summary

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

Diff Detail

Event Timeline

kernhanda created this revision.Feb 16 2020, 2:25 AM
Herald added a project: Restricted Project. · View Herald TranscriptFeb 16 2020, 2:25 AM
Herald added subscribers: llvm-commits, Joonsoo, liufengdb and 9 others. · View Herald Transcript
Harbormaster failed remote builds in B46594: Diff 244860!Feb 16 2020, 2:39 AM
ftynse added inline comments.Feb 17 2020, 12:55 AM
mlir/include/mlir/EDSC/Builders.h
600

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

kernhanda updated this revision to Diff 245317.Feb 18 2020, 7:38 PM

Added comments

kernhanda marked an inline comment as done.Feb 18 2020, 7:38 PM
ftynse accepted this revision.Feb 21 2020, 4:24 AM
This revision is now accepted and ready to land.Feb 21 2020, 4:24 AM
Closed by commit rGd0b09f89e0ed: [NFC][mlir] Adding more operators to EDSC TemplatedIndexedValue (authored by kernhanda, committed by ftynse). · Explain WhyFeb 21 2020, 4:35 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
mlir/
include/
mlir/
Dialect/
AffineOps/
EDSC/
62 lines
EDSC/
50 lines

Diff 244860

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

Show First 20 Lines • Show All 107 Lines • ▼ Show 20 LinesValueHandle TemplatedIndexedValue<Load, Store>::operator*(ValueHandle e) {
using op::operator*; using op::operator*;
return static_cast<ValueHandle>(*this) * e; return static_cast<ValueHandle>(*this) * e;
} }
template <typename Load, typename Store> template <typename Load, typename Store>
ValueHandle TemplatedIndexedValue<Load, Store>::operator/(ValueHandle e) { ValueHandle TemplatedIndexedValue<Load, Store>::operator/(ValueHandle e) {
using op::operator/; using op::operator/;
return static_cast<ValueHandle>(*this) / e; 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> template <typename Load, typename Store>
OperationHandle TemplatedIndexedValue<Load, Store>::operator+=(ValueHandle e) { OperationHandle TemplatedIndexedValue<Load, Store>::operator+=(ValueHandle e) {
using op::operator+; using op::operator+;
return Store(*this + e, getBase(), {indices.begin(), indices.end()}); return Store(*this + e, getBase(), {indices.begin(), indices.end()});
} }
template <typename Load, typename Store> template <typename Load, typename Store>
OperationHandle TemplatedIndexedValue<Load, Store>::operator-=(ValueHandle e) { OperationHandle TemplatedIndexedValue<Load, Store>::operator-=(ValueHandle e) {
using op::operator-; using op::operator-;
return Store(*this - e, getBase(), {indices.begin(), indices.end()}); return Store(*this - e, getBase(), {indices.begin(), indices.end()});
} }
template <typename Load, typename Store> template <typename Load, typename Store>
OperationHandle TemplatedIndexedValue<Load, Store>::operator*=(ValueHandle e) { OperationHandle TemplatedIndexedValue<Load, Store>::operator*=(ValueHandle e) {
using op::operator*; using op::operator*;
return Store(*this * e, getBase(), {indices.begin(), indices.end()}); return Store(*this * e, getBase(), {indices.begin(), indices.end()});
} }
template <typename Load, typename Store> template <typename Load, typename Store>
OperationHandle TemplatedIndexedValue<Load, Store>::operator/=(ValueHandle e) { OperationHandle TemplatedIndexedValue<Load, Store>::operator/=(ValueHandle e) {
using op::operator/; using op::operator/;
return Store(*this / e, getBase(), {indices.begin(), indices.end()}); 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>
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;
}
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 edsc
} // namespace mlir } // namespace mlir
#endif // MLIR_DIALECT_AFFINEOPS_EDSC_BUILDERS_H_ #endif // MLIR_DIALECT_AFFINEOPS_EDSC_BUILDERS_H_

mlir/include/mlir/EDSC/Builders.h

Show First 20 Lines • Show All 537 Lines • ▼ Show 20 Linespublic:
ValueHandle getBase() const { return base; } ValueHandle getBase() const { return base; }
/// Operator overloadings. /// 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/(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);
OperationHandle operator*=(ValueHandle e); OperationHandle operator*=(ValueHandle e);
OperationHandle operator/=(ValueHandle e); OperationHandle operator/=(ValueHandle e);
OperationHandle operator%=(ValueHandle e);
OperationHandle operator^=(ValueHandle e);
ValueHandle operator+(TemplatedIndexedValue e) { ValueHandle operator+(TemplatedIndexedValue e) {
return *this + static_cast<ValueHandle>(e); return *this + static_cast<ValueHandle>(e);
} }
ValueHandle operator-(TemplatedIndexedValue e) { ValueHandle operator-(TemplatedIndexedValue e) {
return *this - static_cast<ValueHandle>(e); return *this - static_cast<ValueHandle>(e);
} }
ValueHandle operator*(TemplatedIndexedValue e) { ValueHandle operator*(TemplatedIndexedValue e) {
return *this * static_cast<ValueHandle>(e); return *this * static_cast<ValueHandle>(e);
} }
ValueHandle operator/(TemplatedIndexedValue e) { ValueHandle operator/(TemplatedIndexedValue e) {
return *this / static_cast<ValueHandle>(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);
}
OperationHandle operator+=(TemplatedIndexedValue e) { OperationHandle operator+=(TemplatedIndexedValue e) {
return this->operator+=(static_cast<ValueHandle>(e)); return this->operator+=(static_cast<ValueHandle>(e));
} }
OperationHandle operator-=(TemplatedIndexedValue e) { OperationHandle operator-=(TemplatedIndexedValue e) {
return this->operator-=(static_cast<ValueHandle>(e)); return this->operator-=(static_cast<ValueHandle>(e));
} }
OperationHandle operator*=(TemplatedIndexedValue e) { OperationHandle operator*=(TemplatedIndexedValue e) {
return this->operator*=(static_cast<ValueHandle>(e)); return this->operator*=(static_cast<ValueHandle>(e));
} }
OperationHandle operator/=(TemplatedIndexedValue e) { OperationHandle operator/=(TemplatedIndexedValue e) {
return this->operator/=(static_cast<ValueHandle>(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));
}
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==(ValueHandle e);
ftynseUnsubmitted
Done
ReplyInline Actions

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

ftynse: Could we have some block comments here? In particular, separating the two groups of operators…
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: private:
TemplatedIndexedValue(ValueHandle base, ArrayRef<ValueHandle> indices) TemplatedIndexedValue(ValueHandle base, ArrayRef<ValueHandle> indices)
: base(base), indices(indices.begin(), indices.end()) {} : base(base), indices(indices.begin(), indices.end()) {}
TemplatedIndexedValue &append() { return *this; } TemplatedIndexedValue &append() { return *this; }
template <typename T, typename... Args> template <typename T, typename... Args>
Show All 13 Lines