[RISCV]Add more pattern for fma ins

[wf520gg]

Summary

Consider the following test cases:

double fma_1(double rs1, double rs2, double rs3)
{

return  -(rs1 * rs2) - rs3;

}
double fma_2(double rs1, double rs2, double rs3)
{

return  -(rs1 * rs2) + rs3;

}
The compiled assembly code with command --target=riscv64-unknown-elf
-march=rv64g is:
fma_1:
fneg.d ft0, fa0
fmul.d ft0, ft0, fa1
fsub.d fa0, ft0, fa2
ret
fma_2:
fmul.d ft0, fa0, fa1
fsub.d fa0, fa2, ft0
ret
Compare with the gcc compiled result:
fma_1:
fnmadd.d fa0,fa0,fa1,fa2
fma_2:
fnmsub.d fa0,fa0,fa1,fa2
So I add new patterns for these two scenarios.

[craig.topper]

lldb/include/lldb/Target/Target.h

416

Unrelated?

[craig.topper]

These transforms are not valid without the contract fast math flag

[craig.topper]

I posted https://reviews.llvm.org/D144447 to get these in the frontend.

lldb/include/lldb/Target/Target.h

#endif
   }
 
   const char *GetPoundLineFilePath() const {
     return (m_pound_line_file.empty() ? nullptr : m_pound_line_file.c_str());
   }
 
   uint32_t GetPoundLineLine() const { return m_pound_line_line; }
 
-  void SetResultIsInternal(bool b) { m_result_is_internal = b; }
+  void SetSuppressPersistentResult(bool b) { m_suppress_persistent_result = b; }
 
-  bool GetResultIsInternal() const { return m_result_is_internal; }
+  bool GetSuppressPersistentResult() const {
+    return m_suppress_persistent_result;
+  }
 
   void SetAutoApplyFixIts(bool b) { m_auto_apply_fixits = b; }
 
   bool GetAutoApplyFixIts() const { return m_auto_apply_fixits; }
 
   void SetRetriesWithFixIts(uint64_t number_of_retries) {
     m_retries_with_fixits = number_of_retries;
   }
private:
   bool m_keep_in_memory = false;
   bool m_try_others = true;
   bool m_stop_others = true;
   bool m_debug = false;
   bool m_trap_exceptions = true;
   bool m_repl = false;
   bool m_generate_debug_info = false;
   bool m_ansi_color_errors = false;
-  bool m_result_is_internal = false;
+  bool m_suppress_persistent_result = false;
   bool m_auto_apply_fixits = true;
   uint64_t m_retries_with_fixits = 1;
   /// True if the executed code should be treated as utility code that is only
   /// used by LLDB internally.
   bool m_running_utility_expression = false;
 
   lldb::DynamicValueType m_use_dynamic = lldb::eNoDynamicValues;
   Timeout<std::micro> m_timeout = default_timeout;

lldb/source/API/SBExpressionOptions.cpp

void SBExpressionOptions::SetGenerateDebugInfo(bool b) {
   LLDB_INSTRUMENT_VA(this, b);
 
   return m_opaque_up->SetGenerateDebugInfo(b);
 }
 
 bool SBExpressionOptions::GetSuppressPersistentResult() {
   LLDB_INSTRUMENT_VA(this);
 
-  return m_opaque_up->GetResultIsInternal();
+  return m_opaque_up->GetSuppressPersistentResult();
 }
 
 void SBExpressionOptions::SetSuppressPersistentResult(bool b) {
   LLDB_INSTRUMENT_VA(this, b);
 
-  return m_opaque_up->SetResultIsInternal(b);
+  return m_opaque_up->SetSuppressPersistentResult(b);
 }
 
 const char *SBExpressionOptions::GetPrefix() const {
   LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetPrefix();
 }
 

lldb/source/Breakpoint/BreakpointLocation.cpp

bool BreakpointLocation::ConditionSaysStop(ExecutionContext &exe_ctx,
   // we'll hook the constructor errors up to the debugger's Async I/O.
 
   ValueObjectSP result_value_sp;
 
   EvaluateExpressionOptions options;
   options.SetUnwindOnError(true);
   options.SetIgnoreBreakpoints(true);
   options.SetTryAllThreads(true);
-  options.SetResultIsInternal(
+  options.SetSuppressPersistentResult(
       true); // Don't generate a user variable for condition expressions.
 
   Status expr_error;
 
   diagnostics.Clear();
 
   ExpressionVariableSP result_variable_sp;
 

lldb/source/Commands/CommandObjectExpression.cpp

 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandOptionArgumentTable.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
+#include "lldb/lldb-private-enumerations.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 CommandObjectExpression::CommandOptions::CommandOptions() = default;
 
 CommandObjectExpression::CommandOptions::~CommandOptions() = default;
 
if (pointee.IsVoidType())
     return Status("as it refers to a pointer to void");
   return Status();
 }
 
 EvaluateExpressionOptions
 CommandObjectExpression::GetEvalOptions(const Target &target) {
   EvaluateExpressionOptions options;
   options.SetCoerceToId(m_varobj_options.use_objc);
+  if (m_command_options.m_verbosity ==
+      eLanguageRuntimeDescriptionDisplayVerbosityCompact)
+    options.SetSuppressPersistentResult(m_varobj_options.use_objc);
   options.SetUnwindOnError(m_command_options.unwind_on_error);
   options.SetIgnoreBreakpoints(m_command_options.ignore_breakpoints);
   options.SetKeepInMemory(true);
   options.SetUseDynamic(m_varobj_options.use_dynamic);
   options.SetTryAllThreads(m_command_options.try_all_threads);
   options.SetDebug(m_command_options.debug);
   options.SetLanguage(m_command_options.language);
   options.SetExecutionPolicy(

lldb/source/Expression/UserExpression.cpp

 UserExpression::Execute(DiagnosticManager &diagnostic_manager,
                         ExecutionContext &exe_ctx,
                         const EvaluateExpressionOptions &options,
                         lldb::UserExpressionSP &shared_ptr_to_me,
                         lldb::ExpressionVariableSP &result_var) {
   lldb::ExpressionResults expr_result = DoExecute(
       diagnostic_manager, exe_ctx, options, shared_ptr_to_me, result_var);
   Target *target = exe_ctx.GetTargetPtr();
-  if (options.GetResultIsInternal() && result_var && target) {
+  if (options.GetSuppressPersistentResult() && result_var && target) {
     if (auto *persistent_state =
             target->GetPersistentExpressionStateForLanguage(m_language))
       persistent_state->RemovePersistentVariable(result_var);
   }
   return expr_result;
 }

lldb/test/API/commands/expression/po_persistent_result/Makefile

+OBJC_SOURCES := main.m
+
+include Makefile.rules

lldb/test/API/commands/expression/po_persistent_result/TestPoPersistentResult.py

+"""
+Test behavior of `po` and persistent results.
+"""
+
+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.decorators import *
+from lldbsuite.test import lldbutil
+
+
+class TestCase(TestBase):
+    def setUp(self):
+        TestBase.setUp(self)
+        self.build()
+        lldbutil.run_to_source_breakpoint(self, "break here", lldb.SBFileSpec("main.m"))
+
+    @skipUnlessDarwin
+    def test_po_does_not_print_persistent_result(self):
+        """Test `po` doesn't advertise a persistent result variable."""
+        self.expect("po obj", matching=False, substrs=["$0 = "])
+
+    @skipUnlessDarwin
+    def test_po_does_not_keep_persistent_result(self):
+        """Test `po` doesn't leak a persistent result variable."""
+        self.expect("po obj")
+        # Verify `po` used a temporary persistent result. In other words, there
+        # should be no $0 at this point.
+        self.expect("expression $0", error=True)
+        self.expect("expression obj", substrs=["$0 = "])
+
+    @skipUnlessDarwin
+    def test_expression_description_verbosity(self):
+        """Test printing object description _and_ opt-in to persistent results."""
+        self.expect("expression -O -vfull -- obj", substrs=["$0 = "])
+        self.expect("expression $0", substrs=["$0 = "])

lldb/test/API/commands/expression/po_persistent_result/main.m

+#import <objc/NSObject.h>
+
+int main() {
+  NSObject *obj = [NSObject new];
+  return 0; // break here
+}

llvm/lib/Target/RISCV/RISCVInstrInfoD.td

 // fmsub: rs1 * rs2 - rs3
 def : Pat<(any_fma FPR64:$rs1, FPR64:$rs2, (fneg FPR64:$rs3)),
           (FMSUB_D FPR64:$rs1, FPR64:$rs2, FPR64:$rs3, 0b111)>;
 
 // fnmsub: -rs1 * rs2 + rs3
 def : Pat<(any_fma (fneg FPR64:$rs1), FPR64:$rs2, FPR64:$rs3),
           (FNMSUB_D FPR64:$rs1, FPR64:$rs2, FPR64:$rs3, 0b111)>;
 
+//fnmsub: - (rs1 * rs2) + rs3
+def : Pat<(fsub FPR64:$rs3 , (fmul FPR64:$rs1, FPR64:$rs2)),
+          (FNMSUB_D   FPR64:$rs1,  FPR64:$rs2,  FPR64:$rs3, 0b111)>;
+
 // fnmadd: -rs1 * rs2 - rs3
 def : Pat<(any_fma (fneg FPR64:$rs1), FPR64:$rs2, (fneg FPR64:$rs3)),
           (FNMADD_D FPR64:$rs1, FPR64:$rs2, FPR64:$rs3, 0b111)>;
 
 // fnmadd: -(rs1 * rs2 + rs3) (the nsz flag on the FMA)
 def : Pat<(fneg (any_fma_nsz FPR64:$rs1, FPR64:$rs2, FPR64:$rs3)),
           (FNMADD_D FPR64:$rs1, FPR64:$rs2, FPR64:$rs3, 0b111)>;
 
+// fnmadd: - (rs1 * rs2) - rs3
+def : Pat<(fsub (fmul FPR64:$rs2,(fneg FPR64:$rs1)) , FPR64:$rs3),
+          (FNMADD_D FPR64:$rs1, FPR64:$rs2, FPR64:$rs3, 0b111)>;
+
 // The ratified 20191213 ISA spec defines fmin and fmax in a way that matches
 // LLVM's fminnum and fmaxnum.
 // <https://github.com/riscv/riscv-isa-manual/commit/cd20cee7efd9bac7c5aa127ec3b451749d2b3cce>.
 def : PatFprFpr<fminnum, FMIN_D, FPR64>;
 def : PatFprFpr<fmaxnum, FMAX_D, FPR64>;
 
 /// Setcc
 // FIXME: SETEQ/SETLT/SETLE imply nonans, can we pick better instructions for

llvm/lib/Target/RISCV/RISCVInstrInfoF.td

 // fmsub: rs1 * rs2 - rs3
 def : Pat<(any_fma FPR32:$rs1, FPR32:$rs2, (fneg FPR32:$rs3)),
           (FMSUB_S FPR32:$rs1, FPR32:$rs2, FPR32:$rs3, 0b111)>;
 
 // fnmsub: -rs1 * rs2 + rs3
 def : Pat<(any_fma (fneg FPR32:$rs1), FPR32:$rs2, FPR32:$rs3),
           (FNMSUB_S FPR32:$rs1, FPR32:$rs2, FPR32:$rs3, 0b111)>;
 
+// fnmsub: -(rs1 * rs2) + rs3
+def : Pat<(fsub FPR32:$rs3,(fmul FPR32:$rs1, FPR32:$rs2)),
+          (FNMSUB_S  FPR32:$rs1,  FPR32:$rs2,  FPR32:$rs3, 0b111)>;
+
 // fnmadd: -rs1 * rs2 - rs3
 def : Pat<(any_fma (fneg FPR32:$rs1), FPR32:$rs2, (fneg FPR32:$rs3)),
           (FNMADD_S FPR32:$rs1, FPR32:$rs2, FPR32:$rs3, 0b111)>;
 
 // fnmadd: -(rs1 * rs2 + rs3) (the nsz flag on the FMA)
 def : Pat<(fneg (any_fma_nsz FPR32:$rs1, FPR32:$rs2, FPR32:$rs3)),
           (FNMADD_S FPR32:$rs1, FPR32:$rs2, FPR32:$rs3, 0b111)>;
 
+// fnmadd: - (rs1 * rs2) - rs3
+def : Pat<(fsub (fmul FPR32:$rs2,(fneg FPR32:$rs1)) , FPR32:$rs3),
+          (FNMADD_S FPR32:$rs1, FPR32:$rs2, FPR32:$rs3, 0b111)>;
+
 // The ratified 20191213 ISA spec defines fmin and fmax in a way that matches
 // LLVM's fminnum and fmaxnum
 // <https://github.com/riscv/riscv-isa-manual/commit/cd20cee7efd9bac7c5aa127ec3b451749d2b3cce>.
 def : PatFprFpr<fminnum, FMIN_S, FPR32>;
 def : PatFprFpr<fmaxnum, FMAX_S, FPR32>;
 
 /// Setcc
 // FIXME: SETEQ/SETLT/SETLE imply nonans, can we pick better instructions for

llvm/test/CodeGen/RISCV/double-arith.ll

 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 ; RV64I-NEXT:    addi sp, sp, 16
 ; RV64I-NEXT:    ret
   %1 = call double @llvm.fma.f64(double %a, double %b, double %c)
   %neg = fneg double %1
   ret double %neg
 }
 
+define double @fnmadd_d_4(double %a, double %b, double %c) nounwind {
+; RV32IFD-LABEL: fnmadd_d_4:
+; RV32IFD:       # %bb.0:
+; RV32IFD-NEXT:    fcvt.d.w ft0, zero
+; RV32IFD-NEXT:    fadd.d ft0, fa0, ft0
+; RV32IFD-NEXT:    fnmadd.d fa0, ft0, fa1, fa2
+; RV32IFD-NEXT:    ret
+;
+; RV64IFD-LABEL: fnmadd_d_4:
+; RV64IFD:       # %bb.0:
+; RV64IFD-NEXT:    fmv.d.x ft0, zero
+; RV64IFD-NEXT:    fadd.d ft0, fa0, ft0
+; RV64IFD-NEXT:    fnmadd.d fa0, ft0, fa1, fa2
+; RV64IFD-NEXT:    ret
+  %a_ = fadd double 0.0, %a
+  %nega = fsub double -0.0, %a_
+  %fmul = fmul double %nega, %b
+  %sub = fsub double %fmul, %c
+  ret double %sub
+}
 
 define double @fnmadd_nsz(double %a, double %b, double %c) nounwind {
 ; CHECKIFD-LABEL: fnmadd_nsz:
 ; CHECKIFD:       # %bb.0:
 ; CHECKIFD-NEXT:    fnmadd.d fa0, fa0, fa1, fa2
 ; CHECKIFD-NEXT:    ret
 ;
 ; RV32I-LABEL: fnmadd_nsz:

 ; RV64I-NEXT:    addi sp, sp, 32
 ; RV64I-NEXT:    ret
   %b_ = fadd double 0.0, %b
   %negb = fsub double -0.0, %b_
   %1 = call double @llvm.fma.f64(double %a, double %negb, double %c)
   ret double %1
 }
 
+define double @fnmsub_d_3(double %a, double %b, double %c) nounwind {
+; CHECKIFD-LABEL: fnmsub_d_3:
+; CHECKIFD:       # %bb.0:
+; CHECKIFD-NEXT:    fnmsub.d fa0, fa0, fa1, fa2
+; CHECKIFD-NEXT:    ret
+  %1 = fmul double %a, %b
+  %add = fsub double %c, %1
+  ret double %add
+}
+
 define double @fmadd_d_contract(double %a, double %b, double %c) nounwind {
 ; CHECKIFD-LABEL: fmadd_d_contract:
 ; CHECKIFD:       # %bb.0:
 ; CHECKIFD-NEXT:    fmadd.d fa0, fa0, fa1, fa2
 ; CHECKIFD-NEXT:    ret
 ;
 ; RV32I-LABEL: fmadd_d_contract:
 ; RV32I:       # %bb.0:

llvm/test/CodeGen/RISCV/float-arith.ll

 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 ; RV64I-NEXT:    addi sp, sp, 16
 ; RV64I-NEXT:    ret
   %1 = call float @llvm.fma.f32(float %a, float %b, float %c)
   %neg = fneg float %1
   ret float %neg
 }
 
+define float @fnmadd_s_4(float %a, float %b, float %c) nounwind {
+; RV32IFD-LABEL: fnmadd_s_4:
+; RV32IFD:       # %bb.0:
+; RV32IFD-NEXT:    fcvt.s.w ft0, zero
+; RV32IFD-NEXT:    fadd.s ft0, fa0, ft0
+; RV32IFD-NEXT:    fnmadd.s fa0, ft0, fa1, fa2
+; RV32IFD-NEXT:    ret
+;
+; RV64IFD-LABEL: fnmadd_s_4:
+; RV64IFD:       # %bb.0:
+; RV64IFD-NEXT:    fmv.s.x ft0, zero
+; RV64IFD-NEXT:    fadd.s ft0, fa0, ft0
+; RV64IFD-NEXT:    fnmadd.s fa0, ft0, fa1, fa2
+; RV64IFD-NEXT:    ret
+  %a_ = fadd float 0.0, %a
+  %nega = fsub float -0.0, %a_
+  %fmul = fmul float %nega, %b
+  %sub = fsub float %fmul, %c
+  ret float %sub
+}
+
 define float @fnmadd_nsz(float %a, float %b, float %c) nounwind {
 ; RV32IF-LABEL: fnmadd_nsz:
 ; RV32IF:       # %bb.0:
 ; RV32IF-NEXT:    fnmadd.s fa0, fa0, fa1, fa2
 ; RV32IF-NEXT:    ret
 ;
 ; RV64IF-LABEL: fnmadd_nsz:
 ; RV64IF:       # %bb.0:

 ; RV64I-NEXT:    addi sp, sp, 32
 ; RV64I-NEXT:    ret
   %b_ = fadd float 0.0, %b
   %negb = fsub float -0.0, %b_
   %1 = call float @llvm.fma.f32(float %a, float %negb, float %c)
   ret float %1
 }
 
+define float @fnmsub_s_3(float %a, float %b, float %c) nounwind {
+; CHECKIFD-LABEL: fnmsub_s_3:
+; CHECKIFD:       # %bb.0:
+; CHECKIFD-NEXT:    fnmsub.s fa0, fa0, fa1, fa2
+; CHECKIFD-NEXT:    ret
+  %1 = fmul float %a, %b
+  %add = fsub float %c, %1
+  ret float %add
+}
+
 define float @fmadd_s_contract(float %a, float %b, float %c) nounwind {
 ; CHECKIF-LABEL: fmadd_s_contract:
 ; CHECKIF:       # %bb.0:
 ; CHECKIF-NEXT:    fmadd.s fa0, fa0, fa1, fa2
 ; CHECKIF-NEXT:    ret
 ;
 ; RV32I-LABEL: fmadd_s_contract:
 ; RV32I:       # %bb.0: