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 }
131