[Sparc][LEON] Fixes an erratum on UT699 LEON 3 processor changing rounding mode

[lero_chris]

Summary

Changing rounding mode will not work on UT699 processors. This pass will detect the relevant call to fesetround, and issue a user warning that this has happened.

[dcederman]

lib/Target/Sparc/LeonFeatures.td

75

There is a trailing whitespace here.

lib/Target/Sparc/LeonPasses.cpp

413

I do not think there is a reason to remove the call, a warning should be enough for what you are trying to achieve. If the program was written to use a special rounding mode then dropping the call would introduce strange errors, so it is better to leave that to the user. Also, what happens if the user is checking the return value of the function? It seems better to just warn, and leave it to the user to remove the call at the C level.

test/CodeGen/SPARC/LeonPreventRoundChangePassUT.ll

2 ↗

(On Diff #71639)

Is there a reason optimizations are disabled?

25–53 ↗

(On Diff #71639)

This seems very complex for a test that only checks if a call instruction has been remove or not.

[lero_chris]

Per comments in review, converted this to detect a rounding change only. It issues an error with a message that this is an erratum on the processor that the user will need to handle in a source code change. The unit test tests that the error message is produced.

[dcederman]

Now it looks good to me.

I've noticed that some of the source files you have committed previously have accidentally been marked as executable. Perhaps you could change that for the files touched in this patch?

lib/Target/Sparc/LeonPasses.cpp

319

Modified is always false now, so you could return false directly to make it clearer that the pass does not change anything.

[lero_chris]

Closed. May make small change as per last comment in a subsequent check-in.

lib/Target/Sparc/LeonFeatures.td

 
 def ReplaceFMULS : SubtargetFeature<
   "replacefmuls",
   "ReplaceFMULS",
   "true",
   "LEON erratum fix: Replace FMULS instruction with FMULD and relevant conversion instructions" 
 >;
 
+def DetectRoundChange : SubtargetFeature<
+  "detectroundchange",
+  "DetectRoundChange",
+  "true",
+  "LEON3 erratum detection: Detects any rounding mode change "
+  "request: use only the round-to-nearest rounding mode"
+>;
+
 def FixAllFDIVSQRT : SubtargetFeature<
   "fixallfdivsqrt",
   "FixAllFDIVSQRT",
   "true",
   "LEON erratum fix: Fix FDIVS/FDIVD/FSQRTS/FSQRTD instructions with NOPs and floating-point store" 
 >;

lib/Target/Sparc/LeonPasses.h

public:
 
   StringRef getPassName() const override {
     return "ReplaceFMULS: Erratum Fix LBR32: replace FMULS instruction with a "
            "routine using conversions/double precision operations to replace "
            "FMULS";
   }
 };
 
+class LLVM_LIBRARY_VISIBILITY DetectRoundChange
+    : public LEONMachineFunctionPass {
+public:
+  static char ID;
+
+  DetectRoundChange(TargetMachine &tm);
+  bool runOnMachineFunction(MachineFunction &MF) override;
+
+  StringRef getPassName() const override {
+    return "DetectRoundChange: Leon erratum detection: detect any rounding "
+           "mode change request: use only the round-to-nearest rounding mode";
+  }
+};
+
 class LLVM_LIBRARY_VISIBILITY FixAllFDIVSQRT : public LEONMachineFunctionPass {
 public:
   static char ID;
 
   FixAllFDIVSQRT(TargetMachine &tm);
   bool runOnMachineFunction(MachineFunction &MF) override;
 
   StringRef getPassName() const override {
     return "FixAllFDIVSQRT: Erratum Fix LBR34: fix FDIVS/FDIVD/FSQRTS/FSQRTD "
            "instructions with NOPs and floating-point store";
   }
 };
 } // namespace llvm
 
 #endif // LLVM_LIB_TARGET_SPARC_LEON_PASSES_H

lib/Target/Sparc/LeonPasses.cpp

 //===----------------------------------------------------------------------===//
 
 #include "LeonPasses.h"
 #include "llvm/CodeGen/ISDOpcodes.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
+#include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
 LEONMachineFunctionPass::LEONMachineFunctionPass(TargetMachine &tm, char &ID)
     : MachineFunctionPass(ID) {}
 
 LEONMachineFunctionPass::LEONMachineFunctionPass(char &ID)
for (auto MBBI = MBB.begin(), E = MBB.end(); MBBI != E; ++MBBI) {
         }
       }
     }
   }
 
   return Modified;
 }
 
+
+//*****************************************************************************
+//**** DetectRoundChange pass
+//*****************************************************************************
+// To prevent any explicit change of the default rounding mode, this pass
+// detects any call of the fesetround function.
+// A warning is generated to ensure the user knows this has happened.
+//
+// Detects an erratum in UT699 LEON 3 processor
+
+char DetectRoundChange::ID = 0;
+
+DetectRoundChange::DetectRoundChange(TargetMachine &tm)
+    : LEONMachineFunctionPass(tm, ID) {}
+
+bool DetectRoundChange::runOnMachineFunction(MachineFunction &MF) {
+  Subtarget = &MF.getSubtarget<SparcSubtarget>();
+
+  bool Modified = false;
+  for (auto MFI = MF.begin(), E = MF.end(); MFI != E; ++MFI) {
+    MachineBasicBlock &MBB = *MFI;
+    for (auto MBBI = MBB.begin(), E = MBB.end(); MBBI != E; ++MBBI) {
+      MachineInstr &MI = *MBBI;
+      unsigned Opcode = MI.getOpcode();
+      if (Opcode == SP::CALL && MI.getNumOperands() > 0) {
+        MachineOperand &MO = MI.getOperand(0);
+
+        if (MO.isGlobal()) {
+          StringRef FuncName = MO.getGlobal()->getName();
+          if (FuncName.compare_lower("fesetround") == 0) {
+            errs() << "Error: You are using the detectroundchange "
+                      "option to detect rounding changes that will "
+                      "cause LEON errata. The only way to fix this "
+                      "is to remove the call to fesetround from "
+                      "the source code.\n";
+          }
+        }
+      }
+    }
+  }
+
+  return Modified;
+}
+
 //*****************************************************************************
 //**** FixAllFDIVSQRT pass
 //*****************************************************************************
 // This pass fixes the incorrectly working FDIVx and FSQRTx instructions that
 // exist for some earlier versions of the LEON processor line. Five NOP
 // instructions need to be inserted after these instructions to ensure the
 // correct result is placed in the destination registers before they are used.
 //
for (auto MBBI = MBB.begin(), E = MBB.end(); MBBI != E; ++MBBI) {
           BuildMI(MBB, NMBBI, DL, TII.get(SP::NOP));
 
         Modified = true;
       }
     }
   }
 
   return Modified;
 }

lib/Target/Sparc/SparcSubtarget.h

class SparcSubtarget : public SparcGenSubtargetInfo {
 
   // LEON features
   bool HasUmacSmac;
   bool HasLeonCasa;
   bool InsertNOPLoad;
   bool FixFSMULD;
   bool ReplaceFMULS;
   bool FixAllFDIVSQRT;
+  bool DetectRoundChange;
   bool PerformSDIVReplace;
 
   SparcInstrInfo InstrInfo;
   SparcTargetLowering TLInfo;
   SelectionDAGTargetInfo TSInfo;
   SparcFrameLowering FrameLowering;
 
 public:
public:
   // Leon options
   bool hasUmacSmac() const { return HasUmacSmac; }
   bool performSDIVReplace() const { return PerformSDIVReplace; }
   bool hasLeonCasa() const { return HasLeonCasa; }
   bool insertNOPLoad() const { return InsertNOPLoad; }
   bool fixFSMULD() const { return FixFSMULD; }
   bool replaceFMULS() const { return ReplaceFMULS; }
   bool fixAllFDIVSQRT() const { return FixAllFDIVSQRT; }
+  bool detectRoundChange() const { return DetectRoundChange; }
 
   /// ParseSubtargetFeatures - Parses features string setting specified
   /// subtarget options.  Definition of function is auto generated by tblgen.
   void ParseSubtargetFeatures(StringRef CPU, StringRef FS);
   SparcSubtarget &initializeSubtargetDependencies(StringRef CPU, StringRef FS);
 
   bool is64Bit() const { return Is64Bit; }
 

lib/Target/Sparc/SparcSubtarget.cpp

SparcSubtarget &SparcSubtarget::initializeSubtargetDependencies(StringRef CPU,
   // Leon features
   HasLeonCasa = false;
   HasUmacSmac = false;
   PerformSDIVReplace = false;
   InsertNOPLoad = false;
   FixFSMULD = false;
   ReplaceFMULS = false;
   FixAllFDIVSQRT = false;
+  DetectRoundChange = false;
 
   // Determine default and user specified characteristics
   std::string CPUName = CPU;
   if (CPUName.empty())
     CPUName = (Is64Bit) ? "v9" : "v8";
 
   // Parse features string.
   ParseSubtargetFeatures(CPUName, FS);

lib/Target/Sparc/SparcTargetMachine.cpp

void SparcPassConfig::addPreEmitPass(){
   if (this->getSparcTargetMachine().getSubtargetImpl()->fixFSMULD())
   {
     addPass(new FixFSMULD(getSparcTargetMachine()));
   }
   if (this->getSparcTargetMachine().getSubtargetImpl()->replaceFMULS())
   {
     addPass(new ReplaceFMULS(getSparcTargetMachine()));
   }
+  if (this->getSparcTargetMachine().getSubtargetImpl()->detectRoundChange()) {
+    addPass(new DetectRoundChange(getSparcTargetMachine()));
+  }
   if (this->getSparcTargetMachine().getSubtargetImpl()->fixAllFDIVSQRT())
   {
     addPass(new FixAllFDIVSQRT(getSparcTargetMachine()));
   }
 }
 
 void SparcV8TargetMachine::anchor() { }
 

test/CodeGen/SPARC/LeonDetectRoundChangePassUT.ll

+; RUN: llc %s -O0 -march=sparc -mcpu=leon3 -mattr=+detectroundchange -o -  |& grep "detect rounding changes"
+
+; Function Attrs: nounwind
+declare i32 @fesetround(i32)
+
+define void @test_round_change() {
+entry:
+  %call = call i32 @fesetround(i32 2048)
+
+  ret void
+}