LLVM  14.0.0git
X86InsertWait.cpp
Go to the documentation of this file.
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"
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 
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 
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()) ||
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) &&
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 }
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:105
MachineInstr.h
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AllocatorList.h:23
X86Subtarget.h
llvm::X86Subtarget
Definition: X86Subtarget.h:52
llvm::MachineFunctionPass
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
Definition: MachineFunctionPass.h:30
MachineBasicBlock.h
isX87ControlInstruction
static bool isX87ControlInstruction(MachineInstr &MI)
Definition: X86InsertWait.cpp:58
LLVM_DEBUG
#define LLVM_DEBUG(X)
Definition: Debug.h:101
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
X86.h
isX87NonWaitingControlInstruction
static bool isX87NonWaitingControlInstruction(MachineInstr &MI)
Definition: X86InsertWait.cpp:82
TII
const HexagonInstrInfo * TII
Definition: HexagonCopyToCombine.cpp:129
DebugLoc.h
llvm::MachineBasicBlock
Definition: MachineBasicBlock.h:95
llvm::MachineFunction::getSubtarget
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
Definition: MachineFunction.h:634
llvm::Function::hasFnAttribute
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.cpp:626
llvm::MachineInstr
Representation of each machine instruction.
Definition: MachineInstr.h:64
llvm::ARM_MB::ST
@ ST
Definition: ARMBaseInfo.h:73
MachineFunctionPass.h
llvm::MachineFunction
Definition: MachineFunction.h:234
llvm::X86InstrInfo
Definition: X86InstrInfo.h:130
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
MBB
MachineBasicBlock & MBB
Definition: AArch64SLSHardening.cpp:74
llvm::MachineFunction::getFunction
Function & getFunction()
Return the LLVM function that this machine code represents.
Definition: MachineFunction.h:600
llvm::createX86InsertX87waitPass
FunctionPass * createX86InsertX87waitPass()
This pass insert wait instruction after X87 instructions which could raise fp exceptions when strict-...
Definition: X86InsertWait.cpp:56
llvm::MachineBasicBlock::begin
iterator begin()
Definition: MachineBasicBlock.h:268
MachineInstrBuilder.h
llvm::BuildMI
MachineInstrBuilder BuildMI(MachineFunction &MF, const DebugLoc &DL, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
Definition: MachineInstrBuilder.h:328
llvm::X86ISD::FLDCW16m
@ FLDCW16m
Definition: X86ISelLowering.h:810
llvm::X86::isX87Instruction
bool isX87Instruction(MachineInstr &MI)
Check if the instruction is X87 instruction.
Definition: X86InstrInfo.cpp:3015
llvm::X86ISD::FNSTCW16m
@ FNSTCW16m
Definition: X86ISelLowering.h:807
MachineOperand.h
llvm::FunctionPass
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:298
MachineFunction.h
X86InstrInfo.h
llvm::MachineInstrBundleIterator< MachineInstr >
Debug.h
llvm::MachineBasicBlock::end
iterator end()
Definition: MachineBasicBlock.h:270
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:38