[llvm] [DAG][NFC] Remove unnecessary default arguments (PR #100737)

[via llvm-commits]

llvmbot wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-llvm-selectiondag

Author: Michael Maitland (michaelmaitland)

<details>
<summary>Changes</summary>



---
Full diff: https://github.com/llvm/llvm-project/pull/100737.diff


1 Files Affected:

- (modified) llvm/include/llvm/CodeGen/SDPatternMatch.h (+28-28) 


``````````diff
diff --git a/llvm/include/llvm/CodeGen/SDPatternMatch.h b/llvm/include/llvm/CodeGen/SDPatternMatch.h
index a905c85f56b66..1992046ccadb2 100644
--- a/llvm/include/llvm/CodeGen/SDPatternMatch.h
+++ b/llvm/include/llvm/CodeGen/SDPatternMatch.h
@@ -477,9 +477,9 @@ struct TernaryOpc_match {
 };
 
 template <typename T0_P, typename T1_P, typename T2_P>
-inline TernaryOpc_match<T0_P, T1_P, T2_P, false, false>
+inline TernaryOpc_match<T0_P, T1_P, T2_P>
 m_SetCC(const T0_P &LHS, const T1_P &RHS, const T2_P &CC) {
-  return TernaryOpc_match<T0_P, T1_P, T2_P, false, false>(ISD::SETCC, LHS, RHS,
+  return TernaryOpc_match<T0_P, T1_P, T2_P>(ISD::SETCC, LHS, RHS,
                                                           CC);
 }
 
@@ -517,9 +517,9 @@ struct BinaryOpc_match {
 };
 
 template <typename LHS, typename RHS>
-inline BinaryOpc_match<LHS, RHS, false> m_BinOp(unsigned Opc, const LHS &L,
+inline BinaryOpc_match<LHS, RHS> m_BinOp(unsigned Opc, const LHS &L,
                                                 const RHS &R) {
-  return BinaryOpc_match<LHS, RHS, false>(Opc, L, R);
+  return BinaryOpc_match<LHS, RHS>(Opc, L, R);
 }
 template <typename LHS, typename RHS>
 inline BinaryOpc_match<LHS, RHS, true> m_c_BinOp(unsigned Opc, const LHS &L,
@@ -545,13 +545,13 @@ inline BinaryOpc_match<LHS, RHS, true> m_Add(const LHS &L, const RHS &R) {
 }
 
 template <typename LHS, typename RHS>
-inline BinaryOpc_match<LHS, RHS, false> m_Sub(const LHS &L, const RHS &R) {
-  return BinaryOpc_match<LHS, RHS, false>(ISD::SUB, L, R);
+inline BinaryOpc_match<LHS, RHS> m_Sub(const LHS &L, const RHS &R) {
+  return BinaryOpc_match<LHS, RHS>(ISD::SUB, L, R);
 }
 
 template <typename LHS, typename RHS>
-inline BinaryOpc_match<LHS, RHS, true> m_Mul(const LHS &L, const RHS &R) {
-  return BinaryOpc_match<LHS, RHS, true>(ISD::MUL, L, R);
+inline BinaryOpc_match<LHS, RHS> m_Mul(const LHS &L, const RHS &R) {
+  return BinaryOpc_match<LHS, RHS>(ISD::MUL, L, R);
 }
 
 template <typename LHS, typename RHS>
@@ -590,35 +590,35 @@ inline BinaryOpc_match<LHS, RHS, true> m_UMax(const LHS &L, const RHS &R) {
 }
 
 template <typename LHS, typename RHS>
-inline BinaryOpc_match<LHS, RHS, false> m_UDiv(const LHS &L, const RHS &R) {
-  return BinaryOpc_match<LHS, RHS, false>(ISD::UDIV, L, R);
+inline BinaryOpc_match<LHS, RHS> m_UDiv(const LHS &L, const RHS &R) {
+  return BinaryOpc_match<LHS, RHS>(ISD::UDIV, L, R);
 }
 template <typename LHS, typename RHS>
-inline BinaryOpc_match<LHS, RHS, false> m_SDiv(const LHS &L, const RHS &R) {
-  return BinaryOpc_match<LHS, RHS, false>(ISD::SDIV, L, R);
+inline BinaryOpc_match<LHS, RHS> m_SDiv(const LHS &L, const RHS &R) {
+  return BinaryOpc_match<LHS, RHS>(ISD::SDIV, L, R);
 }
 
 template <typename LHS, typename RHS>
-inline BinaryOpc_match<LHS, RHS, false> m_URem(const LHS &L, const RHS &R) {
-  return BinaryOpc_match<LHS, RHS, false>(ISD::UREM, L, R);
+inline BinaryOpc_match<LHS, RHS> m_URem(const LHS &L, const RHS &R) {
+  return BinaryOpc_match<LHS, RHS>(ISD::UREM, L, R);
 }
 template <typename LHS, typename RHS>
-inline BinaryOpc_match<LHS, RHS, false> m_SRem(const LHS &L, const RHS &R) {
-  return BinaryOpc_match<LHS, RHS, false>(ISD::SREM, L, R);
+inline BinaryOpc_match<LHS, RHS> m_SRem(const LHS &L, const RHS &R) {
+  return BinaryOpc_match<LHS, RHS>(ISD::SREM, L, R);
 }
 
 template <typename LHS, typename RHS>
-inline BinaryOpc_match<LHS, RHS, false> m_Shl(const LHS &L, const RHS &R) {
-  return BinaryOpc_match<LHS, RHS, false>(ISD::SHL, L, R);
+inline BinaryOpc_match<LHS, RHS> m_Shl(const LHS &L, const RHS &R) {
+  return BinaryOpc_match<LHS, RHS>(ISD::SHL, L, R);
 }
 
 template <typename LHS, typename RHS>
-inline BinaryOpc_match<LHS, RHS, false> m_Sra(const LHS &L, const RHS &R) {
-  return BinaryOpc_match<LHS, RHS, false>(ISD::SRA, L, R);
+inline BinaryOpc_match<LHS, RHS> m_Sra(const LHS &L, const RHS &R) {
+  return BinaryOpc_match<LHS, RHS>(ISD::SRA, L, R);
 }
 template <typename LHS, typename RHS>
-inline BinaryOpc_match<LHS, RHS, false> m_Srl(const LHS &L, const RHS &R) {
-  return BinaryOpc_match<LHS, RHS, false>(ISD::SRL, L, R);
+inline BinaryOpc_match<LHS, RHS> m_Srl(const LHS &L, const RHS &R) {
+  return BinaryOpc_match<LHS, RHS>(ISD::SRL, L, R);
 }
 
 template <typename LHS, typename RHS>
@@ -627,8 +627,8 @@ inline BinaryOpc_match<LHS, RHS, true> m_FAdd(const LHS &L, const RHS &R) {
 }
 
 template <typename LHS, typename RHS>
-inline BinaryOpc_match<LHS, RHS, false> m_FSub(const LHS &L, const RHS &R) {
-  return BinaryOpc_match<LHS, RHS, false>(ISD::FSUB, L, R);
+inline BinaryOpc_match<LHS, RHS> m_FSub(const LHS &L, const RHS &R) {
+  return BinaryOpc_match<LHS, RHS>(ISD::FSUB, L, R);
 }
 
 template <typename LHS, typename RHS>
@@ -637,13 +637,13 @@ inline BinaryOpc_match<LHS, RHS, true> m_FMul(const LHS &L, const RHS &R) {
 }
 
 template <typename LHS, typename RHS>
-inline BinaryOpc_match<LHS, RHS, false> m_FDiv(const LHS &L, const RHS &R) {
-  return BinaryOpc_match<LHS, RHS, false>(ISD::FDIV, L, R);
+inline BinaryOpc_match<LHS, RHS> m_FDiv(const LHS &L, const RHS &R) {
+  return BinaryOpc_match<LHS, RHS>(ISD::FDIV, L, R);
 }
 
 template <typename LHS, typename RHS>
-inline BinaryOpc_match<LHS, RHS, false> m_FRem(const LHS &L, const RHS &R) {
-  return BinaryOpc_match<LHS, RHS, false>(ISD::FREM, L, R);
+inline BinaryOpc_match<LHS, RHS> m_FRem(const LHS &L, const RHS &R) {
+  return BinaryOpc_match<LHS, RHS>(ISD::FREM, L, R);
 }
 
 // === Unary operations ===

``````````

</details>


https://github.com/llvm/llvm-project/pull/100737