llvm/lib/Target/X86/X86InsertWait.cpp

   1 //-  X86Insertwait.cpp - Strict-Fp:Insert wait instruction X87 instructions --//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file defines the pass which insert x86 wait instructions after each
  10 // X87 instructions when strict float is enabled.
  11 //
  12 // The logic to insert a wait instruction after an X87 instruction is as below:
  13 // 1. If the X87 instruction don't raise float exception nor is a load/store
  14 //    instruction, or is a x87 control instruction, don't insert wait.
  15 // 2. If the X87 instruction is an instruction which the following instruction
  16 //    is an X87 exception synchronizing X87 instruction, don't insert wait.
  17 // 3. For other situations, insert wait instruction.
  18 //
  19 //===----------------------------------------------------------------------===//
  20
  21 #include "X86.h"
  22 #include "X86InstrInfo.h"
  23 #include "X86Subtarget.h"
  24 #include "llvm/CodeGen/MachineBasicBlock.h"
  25 #include "llvm/CodeGen/MachineFunction.h"
  26 #include "llvm/CodeGen/MachineFunctionPass.h"
  27 #include "llvm/CodeGen/MachineInstr.h"
  28 #include "llvm/CodeGen/MachineInstrBuilder.h"
  29 #include "llvm/CodeGen/MachineOperand.h"
  30 #include "llvm/IR/DebugLoc.h"
  31 #include "llvm/Support/Debug.h"
  32
  33 using namespace llvm;
  34
  35 #define DEBUG_TYPE "x86-insert-wait"
  36
  37 namespace {
  38
  39 class WaitInsert : public MachineFunctionPass {
  40 public:
  41   static char ID;
  42
  43   WaitInsert() : MachineFunctionPass(ID) {}
  44
  45   bool runOnMachineFunction(MachineFunction &MF) override;
  46
  47   StringRef getPassName() const override {
  48     return "X86 insert wait instruction";
  49   }
  50 };
  51
  52 } // namespace
  53
  54 char WaitInsert::ID = 0;
  55
  56 FunctionPass *llvm::createX86InsertX87waitPass() { return new WaitInsert(); }
  57
  58 static bool isX87ControlInstruction(MachineInstr &MI) {
  59   switch (MI.getOpcode()) {
  60   case X86::FNINIT:
  61   case X86::FLDCW16m:
  62   case X86::FNSTCW16m:
  63   case X86::FNSTSW16r:
  64   case X86::FNSTSWm:
  65   case X86::FNCLEX:
  66   case X86::FLDENVm:
  67   case X86::FSTENVm:
  68   case X86::FRSTORm:
  69   case X86::FSAVEm:
  70   case X86::FINCSTP:
  71   case X86::FDECSTP:
  72   case X86::FFREE:
  73   case X86::FFREEP:
  74   case X86::FNOP:
  75   case X86::WAIT:
  76     return true;
  77   default:
  78     return false;
  79   }
  80 }
  81
  82 static bool isX87NonWaitingControlInstruction(MachineInstr &MI) {
  83   // a few special control instructions don't perform a wait operation
  84   switch (MI.getOpcode()) {
  85   case X86::FNINIT:
  86   case X86::FNSTSW16r:
  87   case X86::FNSTSWm:
  88   case X86::FNSTCW16m:
  89   case X86::FNCLEX:
  90     return true;
  91   default:
  92     return false;
  93   }
  94 }
  95
  96 bool WaitInsert::runOnMachineFunction(MachineFunction &MF) {
  97   if (!MF.getFunction().hasFnAttribute(Attribute::StrictFP))
  98     return false;
  99
 100   const X86Subtarget &ST = MF.getSubtarget<X86Subtarget>();
 101   const X86InstrInfo *TII = ST.getInstrInfo();
 102   bool Changed = false;
 103
 104   for (MachineBasicBlock &MBB : MF) {
 105     for (MachineBasicBlock::iterator MI = MBB.begin(); MI != MBB.end(); ++MI) {
 106       // Jump non X87 instruction.
 107       if (!X86::isX87Instruction(*MI))
 108         continue;
 109       // If the instruction instruction neither has float exception nor is
 110       // a load/store instruction, or the instruction is x87 control
 111       // instruction, do not insert wait.
 112       if (!(MI->mayRaiseFPException() || MI->mayLoadOrStore()) ||
 113           isX87ControlInstruction(*MI))
 114         continue;
 115       // If the following instruction is an X87 instruction and isn't an X87
 116       // non-waiting control instruction, we can omit insert wait instruction.
 117       MachineBasicBlock::iterator AfterMI = std::next(MI);
 118       if (AfterMI != MBB.end() && X86::isX87Instruction(*AfterMI) &&
 119           !isX87NonWaitingControlInstruction(*AfterMI))
 120         continue;
 121
 122       BuildMI(MBB, AfterMI, MI->getDebugLoc(), TII->get(X86::WAIT));
 123       LLVM_DEBUG(dbgs() << "\nInsert wait after:\t" << *MI);
 124       // Jump the newly inserting wait
 125       ++MI;
 126       Changed = true;
 127     }
 128   }
 129   return Changed;
 130 }