[llvm] 6b6abf0 - [DAG][NFC] Remove unnecessary default arguments (#100737)

[via llvm-commits]

Author: Michael Maitland
Date: 2024-08-07T09:00:32-04:00
New Revision: 6b6abf0556d73ba55526cf084f81246d8aa4d56b

URL: https://github.com/llvm/llvm-project/commit/6b6abf0556d73ba55526cf084f81246d8aa4d56b
DIFF: https://github.com/llvm/llvm-project/commit/6b6abf0556d73ba55526cf084f81246d8aa4d56b.diff

LOG: [DAG][NFC] Remove unnecessary default arguments (#100737)

Added: 
    

Modified: 
    llvm/include/llvm/CodeGen/SDPatternMatch.h

Removed: 
    


################################################################################
diff  --git a/llvm/include/llvm/CodeGen/SDPatternMatch.h b/llvm/include/llvm/CodeGen/SDPatternMatch.h
index ad1c5415055c2..96ece1559bc43 100644
--- a/llvm/include/llvm/CodeGen/SDPatternMatch.h
+++ b/llvm/include/llvm/CodeGen/SDPatternMatch.h
@@ -477,10 +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,
-                                                          CC);
+  return TernaryOpc_match<T0_P, T1_P, T2_P>(ISD::SETCC, LHS, RHS, CC);
 }
 
 template <typename T0_P, typename T1_P, typename T2_P>
@@ -529,9 +528,9 @@ struct BinaryOpc_match {
 };
 
 template <typename LHS, typename RHS>
-inline BinaryOpc_match<LHS, RHS, false> m_BinOp(unsigned Opc, const LHS &L,
-                                                const RHS &R) {
-  return BinaryOpc_match<LHS, RHS, false>(Opc, L, R);
+inline BinaryOpc_match<LHS, RHS> m_BinOp(unsigned Opc, const LHS &L,
+                                         const RHS &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,
@@ -557,8 +556,8 @@ 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>
@@ -602,35 +601,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>
@@ -639,8 +638,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>
@@ -649,13 +648,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 ===