106f32e7eSjoerg //===- X86ISelDAGToDAG.cpp - A DAG pattern matching inst selector for X86 -===//
206f32e7eSjoerg //
306f32e7eSjoerg // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
406f32e7eSjoerg // See https://llvm.org/LICENSE.txt for license information.
506f32e7eSjoerg // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
606f32e7eSjoerg //
706f32e7eSjoerg //===----------------------------------------------------------------------===//
806f32e7eSjoerg //
906f32e7eSjoerg // This file defines a DAG pattern matching instruction selector for X86,
1006f32e7eSjoerg // converting from a legalized dag to a X86 dag.
1106f32e7eSjoerg //
1206f32e7eSjoerg //===----------------------------------------------------------------------===//
1306f32e7eSjoerg
1406f32e7eSjoerg #include "X86.h"
1506f32e7eSjoerg #include "X86MachineFunctionInfo.h"
1606f32e7eSjoerg #include "X86RegisterInfo.h"
1706f32e7eSjoerg #include "X86Subtarget.h"
1806f32e7eSjoerg #include "X86TargetMachine.h"
1906f32e7eSjoerg #include "llvm/ADT/Statistic.h"
20*da58b97aSjoerg #include "llvm/CodeGen/MachineModuleInfo.h"
2106f32e7eSjoerg #include "llvm/CodeGen/SelectionDAGISel.h"
2206f32e7eSjoerg #include "llvm/Config/llvm-config.h"
2306f32e7eSjoerg #include "llvm/IR/ConstantRange.h"
2406f32e7eSjoerg #include "llvm/IR/Function.h"
2506f32e7eSjoerg #include "llvm/IR/Instructions.h"
2606f32e7eSjoerg #include "llvm/IR/Intrinsics.h"
27*da58b97aSjoerg #include "llvm/IR/IntrinsicsX86.h"
2806f32e7eSjoerg #include "llvm/IR/Type.h"
2906f32e7eSjoerg #include "llvm/Support/Debug.h"
3006f32e7eSjoerg #include "llvm/Support/ErrorHandling.h"
3106f32e7eSjoerg #include "llvm/Support/KnownBits.h"
3206f32e7eSjoerg #include "llvm/Support/MathExtras.h"
33*da58b97aSjoerg #include <cstdint>
34*da58b97aSjoerg
3506f32e7eSjoerg using namespace llvm;
3606f32e7eSjoerg
3706f32e7eSjoerg #define DEBUG_TYPE "x86-isel"
3806f32e7eSjoerg
3906f32e7eSjoerg STATISTIC(NumLoadMoved, "Number of loads moved below TokenFactor");
4006f32e7eSjoerg
4106f32e7eSjoerg static cl::opt<bool> AndImmShrink("x86-and-imm-shrink", cl::init(true),
4206f32e7eSjoerg cl::desc("Enable setting constant bits to reduce size of mask immediates"),
4306f32e7eSjoerg cl::Hidden);
4406f32e7eSjoerg
45*da58b97aSjoerg static cl::opt<bool> EnablePromoteAnyextLoad(
46*da58b97aSjoerg "x86-promote-anyext-load", cl::init(true),
47*da58b97aSjoerg cl::desc("Enable promoting aligned anyext load to wider load"), cl::Hidden);
48*da58b97aSjoerg
49*da58b97aSjoerg extern cl::opt<bool> IndirectBranchTracking;
50*da58b97aSjoerg
5106f32e7eSjoerg //===----------------------------------------------------------------------===//
5206f32e7eSjoerg // Pattern Matcher Implementation
5306f32e7eSjoerg //===----------------------------------------------------------------------===//
5406f32e7eSjoerg
5506f32e7eSjoerg namespace {
5606f32e7eSjoerg /// This corresponds to X86AddressMode, but uses SDValue's instead of register
5706f32e7eSjoerg /// numbers for the leaves of the matched tree.
5806f32e7eSjoerg struct X86ISelAddressMode {
5906f32e7eSjoerg enum {
6006f32e7eSjoerg RegBase,
6106f32e7eSjoerg FrameIndexBase
6206f32e7eSjoerg } BaseType;
6306f32e7eSjoerg
6406f32e7eSjoerg // This is really a union, discriminated by BaseType!
6506f32e7eSjoerg SDValue Base_Reg;
6606f32e7eSjoerg int Base_FrameIndex;
6706f32e7eSjoerg
6806f32e7eSjoerg unsigned Scale;
6906f32e7eSjoerg SDValue IndexReg;
7006f32e7eSjoerg int32_t Disp;
7106f32e7eSjoerg SDValue Segment;
7206f32e7eSjoerg const GlobalValue *GV;
7306f32e7eSjoerg const Constant *CP;
7406f32e7eSjoerg const BlockAddress *BlockAddr;
7506f32e7eSjoerg const char *ES;
7606f32e7eSjoerg MCSymbol *MCSym;
7706f32e7eSjoerg int JT;
78*da58b97aSjoerg Align Alignment; // CP alignment.
7906f32e7eSjoerg unsigned char SymbolFlags; // X86II::MO_*
8006f32e7eSjoerg bool NegateIndex = false;
8106f32e7eSjoerg
X86ISelAddressMode__anoncccf0fea0111::X86ISelAddressMode8206f32e7eSjoerg X86ISelAddressMode()
8306f32e7eSjoerg : BaseType(RegBase), Base_FrameIndex(0), Scale(1), IndexReg(), Disp(0),
8406f32e7eSjoerg Segment(), GV(nullptr), CP(nullptr), BlockAddr(nullptr), ES(nullptr),
85*da58b97aSjoerg MCSym(nullptr), JT(-1), SymbolFlags(X86II::MO_NO_FLAG) {}
8606f32e7eSjoerg
hasSymbolicDisplacement__anoncccf0fea0111::X86ISelAddressMode8706f32e7eSjoerg bool hasSymbolicDisplacement() const {
8806f32e7eSjoerg return GV != nullptr || CP != nullptr || ES != nullptr ||
8906f32e7eSjoerg MCSym != nullptr || JT != -1 || BlockAddr != nullptr;
9006f32e7eSjoerg }
9106f32e7eSjoerg
hasBaseOrIndexReg__anoncccf0fea0111::X86ISelAddressMode9206f32e7eSjoerg bool hasBaseOrIndexReg() const {
9306f32e7eSjoerg return BaseType == FrameIndexBase ||
9406f32e7eSjoerg IndexReg.getNode() != nullptr || Base_Reg.getNode() != nullptr;
9506f32e7eSjoerg }
9606f32e7eSjoerg
9706f32e7eSjoerg /// Return true if this addressing mode is already RIP-relative.
isRIPRelative__anoncccf0fea0111::X86ISelAddressMode9806f32e7eSjoerg bool isRIPRelative() const {
9906f32e7eSjoerg if (BaseType != RegBase) return false;
10006f32e7eSjoerg if (RegisterSDNode *RegNode =
10106f32e7eSjoerg dyn_cast_or_null<RegisterSDNode>(Base_Reg.getNode()))
10206f32e7eSjoerg return RegNode->getReg() == X86::RIP;
10306f32e7eSjoerg return false;
10406f32e7eSjoerg }
10506f32e7eSjoerg
setBaseReg__anoncccf0fea0111::X86ISelAddressMode10606f32e7eSjoerg void setBaseReg(SDValue Reg) {
10706f32e7eSjoerg BaseType = RegBase;
10806f32e7eSjoerg Base_Reg = Reg;
10906f32e7eSjoerg }
11006f32e7eSjoerg
11106f32e7eSjoerg #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
dump__anoncccf0fea0111::X86ISelAddressMode11206f32e7eSjoerg void dump(SelectionDAG *DAG = nullptr) {
11306f32e7eSjoerg dbgs() << "X86ISelAddressMode " << this << '\n';
11406f32e7eSjoerg dbgs() << "Base_Reg ";
11506f32e7eSjoerg if (Base_Reg.getNode())
11606f32e7eSjoerg Base_Reg.getNode()->dump(DAG);
11706f32e7eSjoerg else
11806f32e7eSjoerg dbgs() << "nul\n";
11906f32e7eSjoerg if (BaseType == FrameIndexBase)
12006f32e7eSjoerg dbgs() << " Base.FrameIndex " << Base_FrameIndex << '\n';
12106f32e7eSjoerg dbgs() << " Scale " << Scale << '\n'
12206f32e7eSjoerg << "IndexReg ";
12306f32e7eSjoerg if (NegateIndex)
12406f32e7eSjoerg dbgs() << "negate ";
12506f32e7eSjoerg if (IndexReg.getNode())
12606f32e7eSjoerg IndexReg.getNode()->dump(DAG);
12706f32e7eSjoerg else
12806f32e7eSjoerg dbgs() << "nul\n";
12906f32e7eSjoerg dbgs() << " Disp " << Disp << '\n'
13006f32e7eSjoerg << "GV ";
13106f32e7eSjoerg if (GV)
13206f32e7eSjoerg GV->dump();
13306f32e7eSjoerg else
13406f32e7eSjoerg dbgs() << "nul";
13506f32e7eSjoerg dbgs() << " CP ";
13606f32e7eSjoerg if (CP)
13706f32e7eSjoerg CP->dump();
13806f32e7eSjoerg else
13906f32e7eSjoerg dbgs() << "nul";
14006f32e7eSjoerg dbgs() << '\n'
14106f32e7eSjoerg << "ES ";
14206f32e7eSjoerg if (ES)
14306f32e7eSjoerg dbgs() << ES;
14406f32e7eSjoerg else
14506f32e7eSjoerg dbgs() << "nul";
14606f32e7eSjoerg dbgs() << " MCSym ";
14706f32e7eSjoerg if (MCSym)
14806f32e7eSjoerg dbgs() << MCSym;
14906f32e7eSjoerg else
15006f32e7eSjoerg dbgs() << "nul";
151*da58b97aSjoerg dbgs() << " JT" << JT << " Align" << Alignment.value() << '\n';
15206f32e7eSjoerg }
15306f32e7eSjoerg #endif
15406f32e7eSjoerg };
15506f32e7eSjoerg }
15606f32e7eSjoerg
15706f32e7eSjoerg namespace {
15806f32e7eSjoerg //===--------------------------------------------------------------------===//
15906f32e7eSjoerg /// ISel - X86-specific code to select X86 machine instructions for
16006f32e7eSjoerg /// SelectionDAG operations.
16106f32e7eSjoerg ///
16206f32e7eSjoerg class X86DAGToDAGISel final : public SelectionDAGISel {
16306f32e7eSjoerg /// Keep a pointer to the X86Subtarget around so that we can
16406f32e7eSjoerg /// make the right decision when generating code for different targets.
16506f32e7eSjoerg const X86Subtarget *Subtarget;
16606f32e7eSjoerg
16706f32e7eSjoerg /// If true, selector should try to optimize for minimum code size.
16806f32e7eSjoerg bool OptForMinSize;
16906f32e7eSjoerg
17006f32e7eSjoerg /// Disable direct TLS access through segment registers.
17106f32e7eSjoerg bool IndirectTlsSegRefs;
17206f32e7eSjoerg
17306f32e7eSjoerg public:
X86DAGToDAGISel(X86TargetMachine & tm,CodeGenOpt::Level OptLevel)17406f32e7eSjoerg explicit X86DAGToDAGISel(X86TargetMachine &tm, CodeGenOpt::Level OptLevel)
175*da58b97aSjoerg : SelectionDAGISel(tm, OptLevel), Subtarget(nullptr),
17606f32e7eSjoerg OptForMinSize(false), IndirectTlsSegRefs(false) {}
17706f32e7eSjoerg
getPassName() const17806f32e7eSjoerg StringRef getPassName() const override {
17906f32e7eSjoerg return "X86 DAG->DAG Instruction Selection";
18006f32e7eSjoerg }
18106f32e7eSjoerg
runOnMachineFunction(MachineFunction & MF)18206f32e7eSjoerg bool runOnMachineFunction(MachineFunction &MF) override {
18306f32e7eSjoerg // Reset the subtarget each time through.
18406f32e7eSjoerg Subtarget = &MF.getSubtarget<X86Subtarget>();
18506f32e7eSjoerg IndirectTlsSegRefs = MF.getFunction().hasFnAttribute(
18606f32e7eSjoerg "indirect-tls-seg-refs");
18706f32e7eSjoerg
18806f32e7eSjoerg // OptFor[Min]Size are used in pattern predicates that isel is matching.
18906f32e7eSjoerg OptForMinSize = MF.getFunction().hasMinSize();
190*da58b97aSjoerg assert((!OptForMinSize || MF.getFunction().hasOptSize()) &&
19106f32e7eSjoerg "OptForMinSize implies OptForSize");
19206f32e7eSjoerg
19306f32e7eSjoerg SelectionDAGISel::runOnMachineFunction(MF);
19406f32e7eSjoerg return true;
19506f32e7eSjoerg }
19606f32e7eSjoerg
197*da58b97aSjoerg void emitFunctionEntryCode() override;
19806f32e7eSjoerg
19906f32e7eSjoerg bool IsProfitableToFold(SDValue N, SDNode *U, SDNode *Root) const override;
20006f32e7eSjoerg
20106f32e7eSjoerg void PreprocessISelDAG() override;
20206f32e7eSjoerg void PostprocessISelDAG() override;
20306f32e7eSjoerg
20406f32e7eSjoerg // Include the pieces autogenerated from the target description.
20506f32e7eSjoerg #include "X86GenDAGISel.inc"
20606f32e7eSjoerg
20706f32e7eSjoerg private:
20806f32e7eSjoerg void Select(SDNode *N) override;
20906f32e7eSjoerg
21006f32e7eSjoerg bool foldOffsetIntoAddress(uint64_t Offset, X86ISelAddressMode &AM);
211*da58b97aSjoerg bool matchLoadInAddress(LoadSDNode *N, X86ISelAddressMode &AM,
212*da58b97aSjoerg bool AllowSegmentRegForX32 = false);
21306f32e7eSjoerg bool matchWrapper(SDValue N, X86ISelAddressMode &AM);
21406f32e7eSjoerg bool matchAddress(SDValue N, X86ISelAddressMode &AM);
21506f32e7eSjoerg bool matchVectorAddress(SDValue N, X86ISelAddressMode &AM);
21606f32e7eSjoerg bool matchAdd(SDValue &N, X86ISelAddressMode &AM, unsigned Depth);
21706f32e7eSjoerg bool matchAddressRecursively(SDValue N, X86ISelAddressMode &AM,
21806f32e7eSjoerg unsigned Depth);
21906f32e7eSjoerg bool matchAddressBase(SDValue N, X86ISelAddressMode &AM);
22006f32e7eSjoerg bool selectAddr(SDNode *Parent, SDValue N, SDValue &Base,
22106f32e7eSjoerg SDValue &Scale, SDValue &Index, SDValue &Disp,
22206f32e7eSjoerg SDValue &Segment);
223*da58b97aSjoerg bool selectVectorAddr(MemSDNode *Parent, SDValue BasePtr, SDValue IndexOp,
224*da58b97aSjoerg SDValue ScaleOp, SDValue &Base, SDValue &Scale,
225*da58b97aSjoerg SDValue &Index, SDValue &Disp, SDValue &Segment);
22606f32e7eSjoerg bool selectMOV64Imm32(SDValue N, SDValue &Imm);
22706f32e7eSjoerg bool selectLEAAddr(SDValue N, SDValue &Base,
22806f32e7eSjoerg SDValue &Scale, SDValue &Index, SDValue &Disp,
22906f32e7eSjoerg SDValue &Segment);
23006f32e7eSjoerg bool selectLEA64_32Addr(SDValue N, SDValue &Base,
23106f32e7eSjoerg SDValue &Scale, SDValue &Index, SDValue &Disp,
23206f32e7eSjoerg SDValue &Segment);
23306f32e7eSjoerg bool selectTLSADDRAddr(SDValue N, SDValue &Base,
23406f32e7eSjoerg SDValue &Scale, SDValue &Index, SDValue &Disp,
23506f32e7eSjoerg SDValue &Segment);
23606f32e7eSjoerg bool selectRelocImm(SDValue N, SDValue &Op);
23706f32e7eSjoerg
23806f32e7eSjoerg bool tryFoldLoad(SDNode *Root, SDNode *P, SDValue N,
23906f32e7eSjoerg SDValue &Base, SDValue &Scale,
24006f32e7eSjoerg SDValue &Index, SDValue &Disp,
24106f32e7eSjoerg SDValue &Segment);
24206f32e7eSjoerg
24306f32e7eSjoerg // Convenience method where P is also root.
tryFoldLoad(SDNode * P,SDValue N,SDValue & Base,SDValue & Scale,SDValue & Index,SDValue & Disp,SDValue & Segment)24406f32e7eSjoerg bool tryFoldLoad(SDNode *P, SDValue N,
24506f32e7eSjoerg SDValue &Base, SDValue &Scale,
24606f32e7eSjoerg SDValue &Index, SDValue &Disp,
24706f32e7eSjoerg SDValue &Segment) {
24806f32e7eSjoerg return tryFoldLoad(P, P, N, Base, Scale, Index, Disp, Segment);
24906f32e7eSjoerg }
25006f32e7eSjoerg
25106f32e7eSjoerg bool tryFoldBroadcast(SDNode *Root, SDNode *P, SDValue N,
25206f32e7eSjoerg SDValue &Base, SDValue &Scale,
25306f32e7eSjoerg SDValue &Index, SDValue &Disp,
25406f32e7eSjoerg SDValue &Segment);
25506f32e7eSjoerg
256*da58b97aSjoerg bool isProfitableToFormMaskedOp(SDNode *N) const;
257*da58b97aSjoerg
25806f32e7eSjoerg /// Implement addressing mode selection for inline asm expressions.
25906f32e7eSjoerg bool SelectInlineAsmMemoryOperand(const SDValue &Op,
26006f32e7eSjoerg unsigned ConstraintID,
26106f32e7eSjoerg std::vector<SDValue> &OutOps) override;
26206f32e7eSjoerg
26306f32e7eSjoerg void emitSpecialCodeForMain();
26406f32e7eSjoerg
getAddressOperands(X86ISelAddressMode & AM,const SDLoc & DL,MVT VT,SDValue & Base,SDValue & Scale,SDValue & Index,SDValue & Disp,SDValue & Segment)26506f32e7eSjoerg inline void getAddressOperands(X86ISelAddressMode &AM, const SDLoc &DL,
26606f32e7eSjoerg MVT VT, SDValue &Base, SDValue &Scale,
26706f32e7eSjoerg SDValue &Index, SDValue &Disp,
26806f32e7eSjoerg SDValue &Segment) {
26906f32e7eSjoerg if (AM.BaseType == X86ISelAddressMode::FrameIndexBase)
27006f32e7eSjoerg Base = CurDAG->getTargetFrameIndex(
27106f32e7eSjoerg AM.Base_FrameIndex, TLI->getPointerTy(CurDAG->getDataLayout()));
27206f32e7eSjoerg else if (AM.Base_Reg.getNode())
27306f32e7eSjoerg Base = AM.Base_Reg;
27406f32e7eSjoerg else
27506f32e7eSjoerg Base = CurDAG->getRegister(0, VT);
27606f32e7eSjoerg
27706f32e7eSjoerg Scale = getI8Imm(AM.Scale, DL);
27806f32e7eSjoerg
27906f32e7eSjoerg // Negate the index if needed.
28006f32e7eSjoerg if (AM.NegateIndex) {
28106f32e7eSjoerg unsigned NegOpc = VT == MVT::i64 ? X86::NEG64r : X86::NEG32r;
28206f32e7eSjoerg SDValue Neg = SDValue(CurDAG->getMachineNode(NegOpc, DL, VT, MVT::i32,
28306f32e7eSjoerg AM.IndexReg), 0);
28406f32e7eSjoerg AM.IndexReg = Neg;
28506f32e7eSjoerg }
28606f32e7eSjoerg
28706f32e7eSjoerg if (AM.IndexReg.getNode())
28806f32e7eSjoerg Index = AM.IndexReg;
28906f32e7eSjoerg else
29006f32e7eSjoerg Index = CurDAG->getRegister(0, VT);
29106f32e7eSjoerg
29206f32e7eSjoerg // These are 32-bit even in 64-bit mode since RIP-relative offset
29306f32e7eSjoerg // is 32-bit.
29406f32e7eSjoerg if (AM.GV)
29506f32e7eSjoerg Disp = CurDAG->getTargetGlobalAddress(AM.GV, SDLoc(),
29606f32e7eSjoerg MVT::i32, AM.Disp,
29706f32e7eSjoerg AM.SymbolFlags);
29806f32e7eSjoerg else if (AM.CP)
299*da58b97aSjoerg Disp = CurDAG->getTargetConstantPool(AM.CP, MVT::i32, AM.Alignment,
300*da58b97aSjoerg AM.Disp, AM.SymbolFlags);
30106f32e7eSjoerg else if (AM.ES) {
30206f32e7eSjoerg assert(!AM.Disp && "Non-zero displacement is ignored with ES.");
30306f32e7eSjoerg Disp = CurDAG->getTargetExternalSymbol(AM.ES, MVT::i32, AM.SymbolFlags);
30406f32e7eSjoerg } else if (AM.MCSym) {
30506f32e7eSjoerg assert(!AM.Disp && "Non-zero displacement is ignored with MCSym.");
30606f32e7eSjoerg assert(AM.SymbolFlags == 0 && "oo");
30706f32e7eSjoerg Disp = CurDAG->getMCSymbol(AM.MCSym, MVT::i32);
30806f32e7eSjoerg } else if (AM.JT != -1) {
30906f32e7eSjoerg assert(!AM.Disp && "Non-zero displacement is ignored with JT.");
31006f32e7eSjoerg Disp = CurDAG->getTargetJumpTable(AM.JT, MVT::i32, AM.SymbolFlags);
31106f32e7eSjoerg } else if (AM.BlockAddr)
31206f32e7eSjoerg Disp = CurDAG->getTargetBlockAddress(AM.BlockAddr, MVT::i32, AM.Disp,
31306f32e7eSjoerg AM.SymbolFlags);
31406f32e7eSjoerg else
31506f32e7eSjoerg Disp = CurDAG->getTargetConstant(AM.Disp, DL, MVT::i32);
31606f32e7eSjoerg
31706f32e7eSjoerg if (AM.Segment.getNode())
31806f32e7eSjoerg Segment = AM.Segment;
31906f32e7eSjoerg else
32006f32e7eSjoerg Segment = CurDAG->getRegister(0, MVT::i16);
32106f32e7eSjoerg }
32206f32e7eSjoerg
32306f32e7eSjoerg // Utility function to determine whether we should avoid selecting
32406f32e7eSjoerg // immediate forms of instructions for better code size or not.
32506f32e7eSjoerg // At a high level, we'd like to avoid such instructions when
32606f32e7eSjoerg // we have similar constants used within the same basic block
32706f32e7eSjoerg // that can be kept in a register.
32806f32e7eSjoerg //
shouldAvoidImmediateInstFormsForSize(SDNode * N) const32906f32e7eSjoerg bool shouldAvoidImmediateInstFormsForSize(SDNode *N) const {
33006f32e7eSjoerg uint32_t UseCount = 0;
33106f32e7eSjoerg
33206f32e7eSjoerg // Do not want to hoist if we're not optimizing for size.
33306f32e7eSjoerg // TODO: We'd like to remove this restriction.
33406f32e7eSjoerg // See the comment in X86InstrInfo.td for more info.
335*da58b97aSjoerg if (!CurDAG->shouldOptForSize())
33606f32e7eSjoerg return false;
33706f32e7eSjoerg
33806f32e7eSjoerg // Walk all the users of the immediate.
33906f32e7eSjoerg for (SDNode::use_iterator UI = N->use_begin(),
34006f32e7eSjoerg UE = N->use_end(); (UI != UE) && (UseCount < 2); ++UI) {
34106f32e7eSjoerg
34206f32e7eSjoerg SDNode *User = *UI;
34306f32e7eSjoerg
34406f32e7eSjoerg // This user is already selected. Count it as a legitimate use and
34506f32e7eSjoerg // move on.
34606f32e7eSjoerg if (User->isMachineOpcode()) {
34706f32e7eSjoerg UseCount++;
34806f32e7eSjoerg continue;
34906f32e7eSjoerg }
35006f32e7eSjoerg
35106f32e7eSjoerg // We want to count stores of immediates as real uses.
35206f32e7eSjoerg if (User->getOpcode() == ISD::STORE &&
35306f32e7eSjoerg User->getOperand(1).getNode() == N) {
35406f32e7eSjoerg UseCount++;
35506f32e7eSjoerg continue;
35606f32e7eSjoerg }
35706f32e7eSjoerg
35806f32e7eSjoerg // We don't currently match users that have > 2 operands (except
35906f32e7eSjoerg // for stores, which are handled above)
36006f32e7eSjoerg // Those instruction won't match in ISEL, for now, and would
36106f32e7eSjoerg // be counted incorrectly.
36206f32e7eSjoerg // This may change in the future as we add additional instruction
36306f32e7eSjoerg // types.
36406f32e7eSjoerg if (User->getNumOperands() != 2)
36506f32e7eSjoerg continue;
36606f32e7eSjoerg
367*da58b97aSjoerg // If this is a sign-extended 8-bit integer immediate used in an ALU
368*da58b97aSjoerg // instruction, there is probably an opcode encoding to save space.
369*da58b97aSjoerg auto *C = dyn_cast<ConstantSDNode>(N);
370*da58b97aSjoerg if (C && isInt<8>(C->getSExtValue()))
37106f32e7eSjoerg continue;
37206f32e7eSjoerg
37306f32e7eSjoerg // Immediates that are used for offsets as part of stack
37406f32e7eSjoerg // manipulation should be left alone. These are typically
37506f32e7eSjoerg // used to indicate SP offsets for argument passing and
37606f32e7eSjoerg // will get pulled into stores/pushes (implicitly).
37706f32e7eSjoerg if (User->getOpcode() == X86ISD::ADD ||
37806f32e7eSjoerg User->getOpcode() == ISD::ADD ||
37906f32e7eSjoerg User->getOpcode() == X86ISD::SUB ||
38006f32e7eSjoerg User->getOpcode() == ISD::SUB) {
38106f32e7eSjoerg
38206f32e7eSjoerg // Find the other operand of the add/sub.
38306f32e7eSjoerg SDValue OtherOp = User->getOperand(0);
38406f32e7eSjoerg if (OtherOp.getNode() == N)
38506f32e7eSjoerg OtherOp = User->getOperand(1);
38606f32e7eSjoerg
38706f32e7eSjoerg // Don't count if the other operand is SP.
38806f32e7eSjoerg RegisterSDNode *RegNode;
38906f32e7eSjoerg if (OtherOp->getOpcode() == ISD::CopyFromReg &&
39006f32e7eSjoerg (RegNode = dyn_cast_or_null<RegisterSDNode>(
39106f32e7eSjoerg OtherOp->getOperand(1).getNode())))
39206f32e7eSjoerg if ((RegNode->getReg() == X86::ESP) ||
39306f32e7eSjoerg (RegNode->getReg() == X86::RSP))
39406f32e7eSjoerg continue;
39506f32e7eSjoerg }
39606f32e7eSjoerg
39706f32e7eSjoerg // ... otherwise, count this and move on.
39806f32e7eSjoerg UseCount++;
39906f32e7eSjoerg }
40006f32e7eSjoerg
40106f32e7eSjoerg // If we have more than 1 use, then recommend for hoisting.
40206f32e7eSjoerg return (UseCount > 1);
40306f32e7eSjoerg }
40406f32e7eSjoerg
40506f32e7eSjoerg /// Return a target constant with the specified value of type i8.
getI8Imm(unsigned Imm,const SDLoc & DL)40606f32e7eSjoerg inline SDValue getI8Imm(unsigned Imm, const SDLoc &DL) {
40706f32e7eSjoerg return CurDAG->getTargetConstant(Imm, DL, MVT::i8);
40806f32e7eSjoerg }
40906f32e7eSjoerg
41006f32e7eSjoerg /// Return a target constant with the specified value, of type i32.
getI32Imm(unsigned Imm,const SDLoc & DL)41106f32e7eSjoerg inline SDValue getI32Imm(unsigned Imm, const SDLoc &DL) {
41206f32e7eSjoerg return CurDAG->getTargetConstant(Imm, DL, MVT::i32);
41306f32e7eSjoerg }
41406f32e7eSjoerg
41506f32e7eSjoerg /// Return a target constant with the specified value, of type i64.
getI64Imm(uint64_t Imm,const SDLoc & DL)41606f32e7eSjoerg inline SDValue getI64Imm(uint64_t Imm, const SDLoc &DL) {
41706f32e7eSjoerg return CurDAG->getTargetConstant(Imm, DL, MVT::i64);
41806f32e7eSjoerg }
41906f32e7eSjoerg
getExtractVEXTRACTImmediate(SDNode * N,unsigned VecWidth,const SDLoc & DL)42006f32e7eSjoerg SDValue getExtractVEXTRACTImmediate(SDNode *N, unsigned VecWidth,
42106f32e7eSjoerg const SDLoc &DL) {
42206f32e7eSjoerg assert((VecWidth == 128 || VecWidth == 256) && "Unexpected vector width");
42306f32e7eSjoerg uint64_t Index = N->getConstantOperandVal(1);
42406f32e7eSjoerg MVT VecVT = N->getOperand(0).getSimpleValueType();
42506f32e7eSjoerg return getI8Imm((Index * VecVT.getScalarSizeInBits()) / VecWidth, DL);
42606f32e7eSjoerg }
42706f32e7eSjoerg
getInsertVINSERTImmediate(SDNode * N,unsigned VecWidth,const SDLoc & DL)42806f32e7eSjoerg SDValue getInsertVINSERTImmediate(SDNode *N, unsigned VecWidth,
42906f32e7eSjoerg const SDLoc &DL) {
43006f32e7eSjoerg assert((VecWidth == 128 || VecWidth == 256) && "Unexpected vector width");
43106f32e7eSjoerg uint64_t Index = N->getConstantOperandVal(2);
43206f32e7eSjoerg MVT VecVT = N->getSimpleValueType(0);
43306f32e7eSjoerg return getI8Imm((Index * VecVT.getScalarSizeInBits()) / VecWidth, DL);
43406f32e7eSjoerg }
43506f32e7eSjoerg
43606f32e7eSjoerg // Helper to detect unneeded and instructions on shift amounts. Called
43706f32e7eSjoerg // from PatFrags in tablegen.
isUnneededShiftMask(SDNode * N,unsigned Width) const43806f32e7eSjoerg bool isUnneededShiftMask(SDNode *N, unsigned Width) const {
43906f32e7eSjoerg assert(N->getOpcode() == ISD::AND && "Unexpected opcode");
44006f32e7eSjoerg const APInt &Val = cast<ConstantSDNode>(N->getOperand(1))->getAPIntValue();
44106f32e7eSjoerg
44206f32e7eSjoerg if (Val.countTrailingOnes() >= Width)
44306f32e7eSjoerg return true;
44406f32e7eSjoerg
44506f32e7eSjoerg APInt Mask = Val | CurDAG->computeKnownBits(N->getOperand(0)).Zero;
44606f32e7eSjoerg return Mask.countTrailingOnes() >= Width;
44706f32e7eSjoerg }
44806f32e7eSjoerg
44906f32e7eSjoerg /// Return an SDNode that returns the value of the global base register.
45006f32e7eSjoerg /// Output instructions required to initialize the global base register,
45106f32e7eSjoerg /// if necessary.
45206f32e7eSjoerg SDNode *getGlobalBaseReg();
45306f32e7eSjoerg
45406f32e7eSjoerg /// Return a reference to the TargetMachine, casted to the target-specific
45506f32e7eSjoerg /// type.
getTargetMachine() const45606f32e7eSjoerg const X86TargetMachine &getTargetMachine() const {
45706f32e7eSjoerg return static_cast<const X86TargetMachine &>(TM);
45806f32e7eSjoerg }
45906f32e7eSjoerg
46006f32e7eSjoerg /// Return a reference to the TargetInstrInfo, casted to the target-specific
46106f32e7eSjoerg /// type.
getInstrInfo() const46206f32e7eSjoerg const X86InstrInfo *getInstrInfo() const {
46306f32e7eSjoerg return Subtarget->getInstrInfo();
46406f32e7eSjoerg }
46506f32e7eSjoerg
46606f32e7eSjoerg /// Address-mode matching performs shift-of-and to and-of-shift
46706f32e7eSjoerg /// reassociation in order to expose more scaled addressing
46806f32e7eSjoerg /// opportunities.
ComplexPatternFuncMutatesDAG() const46906f32e7eSjoerg bool ComplexPatternFuncMutatesDAG() const override {
47006f32e7eSjoerg return true;
47106f32e7eSjoerg }
47206f32e7eSjoerg
47306f32e7eSjoerg bool isSExtAbsoluteSymbolRef(unsigned Width, SDNode *N) const;
47406f32e7eSjoerg
47506f32e7eSjoerg // Indicates we should prefer to use a non-temporal load for this load.
useNonTemporalLoad(LoadSDNode * N) const47606f32e7eSjoerg bool useNonTemporalLoad(LoadSDNode *N) const {
47706f32e7eSjoerg if (!N->isNonTemporal())
47806f32e7eSjoerg return false;
47906f32e7eSjoerg
48006f32e7eSjoerg unsigned StoreSize = N->getMemoryVT().getStoreSize();
48106f32e7eSjoerg
48206f32e7eSjoerg if (N->getAlignment() < StoreSize)
48306f32e7eSjoerg return false;
48406f32e7eSjoerg
48506f32e7eSjoerg switch (StoreSize) {
48606f32e7eSjoerg default: llvm_unreachable("Unsupported store size");
48706f32e7eSjoerg case 4:
48806f32e7eSjoerg case 8:
48906f32e7eSjoerg return false;
49006f32e7eSjoerg case 16:
49106f32e7eSjoerg return Subtarget->hasSSE41();
49206f32e7eSjoerg case 32:
49306f32e7eSjoerg return Subtarget->hasAVX2();
49406f32e7eSjoerg case 64:
49506f32e7eSjoerg return Subtarget->hasAVX512();
49606f32e7eSjoerg }
49706f32e7eSjoerg }
49806f32e7eSjoerg
49906f32e7eSjoerg bool foldLoadStoreIntoMemOperand(SDNode *Node);
50006f32e7eSjoerg MachineSDNode *matchBEXTRFromAndImm(SDNode *Node);
50106f32e7eSjoerg bool matchBitExtract(SDNode *Node);
50206f32e7eSjoerg bool shrinkAndImmediate(SDNode *N);
50306f32e7eSjoerg bool isMaskZeroExtended(SDNode *N) const;
50406f32e7eSjoerg bool tryShiftAmountMod(SDNode *N);
50506f32e7eSjoerg bool tryShrinkShlLogicImm(SDNode *N);
506*da58b97aSjoerg bool tryVPTERNLOG(SDNode *N);
507*da58b97aSjoerg bool matchVPTERNLOG(SDNode *Root, SDNode *ParentA, SDNode *ParentBC,
508*da58b97aSjoerg SDValue A, SDValue B, SDValue C, uint8_t Imm);
50906f32e7eSjoerg bool tryVPTESTM(SDNode *Root, SDValue Setcc, SDValue Mask);
51006f32e7eSjoerg bool tryMatchBitSelect(SDNode *N);
51106f32e7eSjoerg
51206f32e7eSjoerg MachineSDNode *emitPCMPISTR(unsigned ROpc, unsigned MOpc, bool MayFoldLoad,
51306f32e7eSjoerg const SDLoc &dl, MVT VT, SDNode *Node);
51406f32e7eSjoerg MachineSDNode *emitPCMPESTR(unsigned ROpc, unsigned MOpc, bool MayFoldLoad,
51506f32e7eSjoerg const SDLoc &dl, MVT VT, SDNode *Node,
51606f32e7eSjoerg SDValue &InFlag);
51706f32e7eSjoerg
51806f32e7eSjoerg bool tryOptimizeRem8Extend(SDNode *N);
51906f32e7eSjoerg
52006f32e7eSjoerg bool onlyUsesZeroFlag(SDValue Flags) const;
52106f32e7eSjoerg bool hasNoSignFlagUses(SDValue Flags) const;
52206f32e7eSjoerg bool hasNoCarryFlagUses(SDValue Flags) const;
52306f32e7eSjoerg };
52406f32e7eSjoerg }
52506f32e7eSjoerg
52606f32e7eSjoerg
52706f32e7eSjoerg // Returns true if this masked compare can be implemented legally with this
52806f32e7eSjoerg // type.
isLegalMaskCompare(SDNode * N,const X86Subtarget * Subtarget)52906f32e7eSjoerg static bool isLegalMaskCompare(SDNode *N, const X86Subtarget *Subtarget) {
53006f32e7eSjoerg unsigned Opcode = N->getOpcode();
531*da58b97aSjoerg if (Opcode == X86ISD::CMPM || Opcode == X86ISD::CMPMM ||
532*da58b97aSjoerg Opcode == X86ISD::STRICT_CMPM || Opcode == ISD::SETCC ||
533*da58b97aSjoerg Opcode == X86ISD::CMPMM_SAE || Opcode == X86ISD::VFPCLASS) {
53406f32e7eSjoerg // We can get 256-bit 8 element types here without VLX being enabled. When
53506f32e7eSjoerg // this happens we will use 512-bit operations and the mask will not be
53606f32e7eSjoerg // zero extended.
53706f32e7eSjoerg EVT OpVT = N->getOperand(0).getValueType();
538*da58b97aSjoerg // The first operand of X86ISD::STRICT_CMPM is chain, so we need to get the
539*da58b97aSjoerg // second operand.
540*da58b97aSjoerg if (Opcode == X86ISD::STRICT_CMPM)
541*da58b97aSjoerg OpVT = N->getOperand(1).getValueType();
54206f32e7eSjoerg if (OpVT.is256BitVector() || OpVT.is128BitVector())
54306f32e7eSjoerg return Subtarget->hasVLX();
54406f32e7eSjoerg
54506f32e7eSjoerg return true;
54606f32e7eSjoerg }
54706f32e7eSjoerg // Scalar opcodes use 128 bit registers, but aren't subject to the VLX check.
54806f32e7eSjoerg if (Opcode == X86ISD::VFPCLASSS || Opcode == X86ISD::FSETCCM ||
54906f32e7eSjoerg Opcode == X86ISD::FSETCCM_SAE)
55006f32e7eSjoerg return true;
55106f32e7eSjoerg
55206f32e7eSjoerg return false;
55306f32e7eSjoerg }
55406f32e7eSjoerg
55506f32e7eSjoerg // Returns true if we can assume the writer of the mask has zero extended it
55606f32e7eSjoerg // for us.
isMaskZeroExtended(SDNode * N) const55706f32e7eSjoerg bool X86DAGToDAGISel::isMaskZeroExtended(SDNode *N) const {
55806f32e7eSjoerg // If this is an AND, check if we have a compare on either side. As long as
55906f32e7eSjoerg // one side guarantees the mask is zero extended, the AND will preserve those
56006f32e7eSjoerg // zeros.
56106f32e7eSjoerg if (N->getOpcode() == ISD::AND)
56206f32e7eSjoerg return isLegalMaskCompare(N->getOperand(0).getNode(), Subtarget) ||
56306f32e7eSjoerg isLegalMaskCompare(N->getOperand(1).getNode(), Subtarget);
56406f32e7eSjoerg
56506f32e7eSjoerg return isLegalMaskCompare(N, Subtarget);
56606f32e7eSjoerg }
56706f32e7eSjoerg
56806f32e7eSjoerg bool
IsProfitableToFold(SDValue N,SDNode * U,SDNode * Root) const56906f32e7eSjoerg X86DAGToDAGISel::IsProfitableToFold(SDValue N, SDNode *U, SDNode *Root) const {
57006f32e7eSjoerg if (OptLevel == CodeGenOpt::None) return false;
57106f32e7eSjoerg
57206f32e7eSjoerg if (!N.hasOneUse())
57306f32e7eSjoerg return false;
57406f32e7eSjoerg
57506f32e7eSjoerg if (N.getOpcode() != ISD::LOAD)
57606f32e7eSjoerg return true;
57706f32e7eSjoerg
57806f32e7eSjoerg // Don't fold non-temporal loads if we have an instruction for them.
57906f32e7eSjoerg if (useNonTemporalLoad(cast<LoadSDNode>(N)))
58006f32e7eSjoerg return false;
58106f32e7eSjoerg
58206f32e7eSjoerg // If N is a load, do additional profitability checks.
58306f32e7eSjoerg if (U == Root) {
58406f32e7eSjoerg switch (U->getOpcode()) {
58506f32e7eSjoerg default: break;
58606f32e7eSjoerg case X86ISD::ADD:
58706f32e7eSjoerg case X86ISD::ADC:
58806f32e7eSjoerg case X86ISD::SUB:
58906f32e7eSjoerg case X86ISD::SBB:
59006f32e7eSjoerg case X86ISD::AND:
59106f32e7eSjoerg case X86ISD::XOR:
59206f32e7eSjoerg case X86ISD::OR:
59306f32e7eSjoerg case ISD::ADD:
59406f32e7eSjoerg case ISD::ADDCARRY:
59506f32e7eSjoerg case ISD::AND:
59606f32e7eSjoerg case ISD::OR:
59706f32e7eSjoerg case ISD::XOR: {
59806f32e7eSjoerg SDValue Op1 = U->getOperand(1);
59906f32e7eSjoerg
60006f32e7eSjoerg // If the other operand is a 8-bit immediate we should fold the immediate
60106f32e7eSjoerg // instead. This reduces code size.
60206f32e7eSjoerg // e.g.
60306f32e7eSjoerg // movl 4(%esp), %eax
60406f32e7eSjoerg // addl $4, %eax
60506f32e7eSjoerg // vs.
60606f32e7eSjoerg // movl $4, %eax
60706f32e7eSjoerg // addl 4(%esp), %eax
60806f32e7eSjoerg // The former is 2 bytes shorter. In case where the increment is 1, then
60906f32e7eSjoerg // the saving can be 4 bytes (by using incl %eax).
61006f32e7eSjoerg if (ConstantSDNode *Imm = dyn_cast<ConstantSDNode>(Op1)) {
61106f32e7eSjoerg if (Imm->getAPIntValue().isSignedIntN(8))
61206f32e7eSjoerg return false;
61306f32e7eSjoerg
61406f32e7eSjoerg // If this is a 64-bit AND with an immediate that fits in 32-bits,
61506f32e7eSjoerg // prefer using the smaller and over folding the load. This is needed to
61606f32e7eSjoerg // make sure immediates created by shrinkAndImmediate are always folded.
61706f32e7eSjoerg // Ideally we would narrow the load during DAG combine and get the
61806f32e7eSjoerg // best of both worlds.
61906f32e7eSjoerg if (U->getOpcode() == ISD::AND &&
62006f32e7eSjoerg Imm->getAPIntValue().getBitWidth() == 64 &&
62106f32e7eSjoerg Imm->getAPIntValue().isIntN(32))
62206f32e7eSjoerg return false;
62306f32e7eSjoerg
62406f32e7eSjoerg // If this really a zext_inreg that can be represented with a movzx
62506f32e7eSjoerg // instruction, prefer that.
62606f32e7eSjoerg // TODO: We could shrink the load and fold if it is non-volatile.
62706f32e7eSjoerg if (U->getOpcode() == ISD::AND &&
62806f32e7eSjoerg (Imm->getAPIntValue() == UINT8_MAX ||
62906f32e7eSjoerg Imm->getAPIntValue() == UINT16_MAX ||
63006f32e7eSjoerg Imm->getAPIntValue() == UINT32_MAX))
63106f32e7eSjoerg return false;
63206f32e7eSjoerg
63306f32e7eSjoerg // ADD/SUB with can negate the immediate and use the opposite operation
63406f32e7eSjoerg // to fit 128 into a sign extended 8 bit immediate.
63506f32e7eSjoerg if ((U->getOpcode() == ISD::ADD || U->getOpcode() == ISD::SUB) &&
63606f32e7eSjoerg (-Imm->getAPIntValue()).isSignedIntN(8))
63706f32e7eSjoerg return false;
638*da58b97aSjoerg
639*da58b97aSjoerg if ((U->getOpcode() == X86ISD::ADD || U->getOpcode() == X86ISD::SUB) &&
640*da58b97aSjoerg (-Imm->getAPIntValue()).isSignedIntN(8) &&
641*da58b97aSjoerg hasNoCarryFlagUses(SDValue(U, 1)))
642*da58b97aSjoerg return false;
64306f32e7eSjoerg }
64406f32e7eSjoerg
64506f32e7eSjoerg // If the other operand is a TLS address, we should fold it instead.
64606f32e7eSjoerg // This produces
64706f32e7eSjoerg // movl %gs:0, %eax
64806f32e7eSjoerg // leal i@NTPOFF(%eax), %eax
64906f32e7eSjoerg // instead of
65006f32e7eSjoerg // movl $i@NTPOFF, %eax
65106f32e7eSjoerg // addl %gs:0, %eax
65206f32e7eSjoerg // if the block also has an access to a second TLS address this will save
65306f32e7eSjoerg // a load.
65406f32e7eSjoerg // FIXME: This is probably also true for non-TLS addresses.
65506f32e7eSjoerg if (Op1.getOpcode() == X86ISD::Wrapper) {
65606f32e7eSjoerg SDValue Val = Op1.getOperand(0);
65706f32e7eSjoerg if (Val.getOpcode() == ISD::TargetGlobalTLSAddress)
65806f32e7eSjoerg return false;
65906f32e7eSjoerg }
66006f32e7eSjoerg
66106f32e7eSjoerg // Don't fold load if this matches the BTS/BTR/BTC patterns.
66206f32e7eSjoerg // BTS: (or X, (shl 1, n))
66306f32e7eSjoerg // BTR: (and X, (rotl -2, n))
66406f32e7eSjoerg // BTC: (xor X, (shl 1, n))
66506f32e7eSjoerg if (U->getOpcode() == ISD::OR || U->getOpcode() == ISD::XOR) {
66606f32e7eSjoerg if (U->getOperand(0).getOpcode() == ISD::SHL &&
66706f32e7eSjoerg isOneConstant(U->getOperand(0).getOperand(0)))
66806f32e7eSjoerg return false;
66906f32e7eSjoerg
67006f32e7eSjoerg if (U->getOperand(1).getOpcode() == ISD::SHL &&
67106f32e7eSjoerg isOneConstant(U->getOperand(1).getOperand(0)))
67206f32e7eSjoerg return false;
67306f32e7eSjoerg }
67406f32e7eSjoerg if (U->getOpcode() == ISD::AND) {
67506f32e7eSjoerg SDValue U0 = U->getOperand(0);
67606f32e7eSjoerg SDValue U1 = U->getOperand(1);
67706f32e7eSjoerg if (U0.getOpcode() == ISD::ROTL) {
67806f32e7eSjoerg auto *C = dyn_cast<ConstantSDNode>(U0.getOperand(0));
67906f32e7eSjoerg if (C && C->getSExtValue() == -2)
68006f32e7eSjoerg return false;
68106f32e7eSjoerg }
68206f32e7eSjoerg
68306f32e7eSjoerg if (U1.getOpcode() == ISD::ROTL) {
68406f32e7eSjoerg auto *C = dyn_cast<ConstantSDNode>(U1.getOperand(0));
68506f32e7eSjoerg if (C && C->getSExtValue() == -2)
68606f32e7eSjoerg return false;
68706f32e7eSjoerg }
68806f32e7eSjoerg }
68906f32e7eSjoerg
69006f32e7eSjoerg break;
69106f32e7eSjoerg }
69206f32e7eSjoerg case ISD::SHL:
69306f32e7eSjoerg case ISD::SRA:
69406f32e7eSjoerg case ISD::SRL:
69506f32e7eSjoerg // Don't fold a load into a shift by immediate. The BMI2 instructions
69606f32e7eSjoerg // support folding a load, but not an immediate. The legacy instructions
69706f32e7eSjoerg // support folding an immediate, but can't fold a load. Folding an
69806f32e7eSjoerg // immediate is preferable to folding a load.
69906f32e7eSjoerg if (isa<ConstantSDNode>(U->getOperand(1)))
70006f32e7eSjoerg return false;
70106f32e7eSjoerg
70206f32e7eSjoerg break;
70306f32e7eSjoerg }
70406f32e7eSjoerg }
70506f32e7eSjoerg
70606f32e7eSjoerg // Prevent folding a load if this can implemented with an insert_subreg or
70706f32e7eSjoerg // a move that implicitly zeroes.
70806f32e7eSjoerg if (Root->getOpcode() == ISD::INSERT_SUBVECTOR &&
70906f32e7eSjoerg isNullConstant(Root->getOperand(2)) &&
71006f32e7eSjoerg (Root->getOperand(0).isUndef() ||
71106f32e7eSjoerg ISD::isBuildVectorAllZeros(Root->getOperand(0).getNode())))
71206f32e7eSjoerg return false;
71306f32e7eSjoerg
71406f32e7eSjoerg return true;
71506f32e7eSjoerg }
71606f32e7eSjoerg
717*da58b97aSjoerg // Indicates it is profitable to form an AVX512 masked operation. Returning
718*da58b97aSjoerg // false will favor a masked register-register masked move or vblendm and the
719*da58b97aSjoerg // operation will be selected separately.
isProfitableToFormMaskedOp(SDNode * N) const720*da58b97aSjoerg bool X86DAGToDAGISel::isProfitableToFormMaskedOp(SDNode *N) const {
721*da58b97aSjoerg assert(
722*da58b97aSjoerg (N->getOpcode() == ISD::VSELECT || N->getOpcode() == X86ISD::SELECTS) &&
723*da58b97aSjoerg "Unexpected opcode!");
724*da58b97aSjoerg
725*da58b97aSjoerg // If the operation has additional users, the operation will be duplicated.
726*da58b97aSjoerg // Check the use count to prevent that.
727*da58b97aSjoerg // FIXME: Are there cheap opcodes we might want to duplicate?
728*da58b97aSjoerg return N->getOperand(1).hasOneUse();
729*da58b97aSjoerg }
730*da58b97aSjoerg
73106f32e7eSjoerg /// Replace the original chain operand of the call with
73206f32e7eSjoerg /// load's chain operand and move load below the call's chain operand.
moveBelowOrigChain(SelectionDAG * CurDAG,SDValue Load,SDValue Call,SDValue OrigChain)73306f32e7eSjoerg static void moveBelowOrigChain(SelectionDAG *CurDAG, SDValue Load,
73406f32e7eSjoerg SDValue Call, SDValue OrigChain) {
73506f32e7eSjoerg SmallVector<SDValue, 8> Ops;
73606f32e7eSjoerg SDValue Chain = OrigChain.getOperand(0);
73706f32e7eSjoerg if (Chain.getNode() == Load.getNode())
73806f32e7eSjoerg Ops.push_back(Load.getOperand(0));
73906f32e7eSjoerg else {
74006f32e7eSjoerg assert(Chain.getOpcode() == ISD::TokenFactor &&
74106f32e7eSjoerg "Unexpected chain operand");
74206f32e7eSjoerg for (unsigned i = 0, e = Chain.getNumOperands(); i != e; ++i)
74306f32e7eSjoerg if (Chain.getOperand(i).getNode() == Load.getNode())
74406f32e7eSjoerg Ops.push_back(Load.getOperand(0));
74506f32e7eSjoerg else
74606f32e7eSjoerg Ops.push_back(Chain.getOperand(i));
74706f32e7eSjoerg SDValue NewChain =
74806f32e7eSjoerg CurDAG->getNode(ISD::TokenFactor, SDLoc(Load), MVT::Other, Ops);
74906f32e7eSjoerg Ops.clear();
75006f32e7eSjoerg Ops.push_back(NewChain);
75106f32e7eSjoerg }
75206f32e7eSjoerg Ops.append(OrigChain->op_begin() + 1, OrigChain->op_end());
75306f32e7eSjoerg CurDAG->UpdateNodeOperands(OrigChain.getNode(), Ops);
75406f32e7eSjoerg CurDAG->UpdateNodeOperands(Load.getNode(), Call.getOperand(0),
75506f32e7eSjoerg Load.getOperand(1), Load.getOperand(2));
75606f32e7eSjoerg
75706f32e7eSjoerg Ops.clear();
75806f32e7eSjoerg Ops.push_back(SDValue(Load.getNode(), 1));
75906f32e7eSjoerg Ops.append(Call->op_begin() + 1, Call->op_end());
76006f32e7eSjoerg CurDAG->UpdateNodeOperands(Call.getNode(), Ops);
76106f32e7eSjoerg }
76206f32e7eSjoerg
76306f32e7eSjoerg /// Return true if call address is a load and it can be
76406f32e7eSjoerg /// moved below CALLSEQ_START and the chains leading up to the call.
76506f32e7eSjoerg /// Return the CALLSEQ_START by reference as a second output.
76606f32e7eSjoerg /// In the case of a tail call, there isn't a callseq node between the call
76706f32e7eSjoerg /// chain and the load.
isCalleeLoad(SDValue Callee,SDValue & Chain,bool HasCallSeq)76806f32e7eSjoerg static bool isCalleeLoad(SDValue Callee, SDValue &Chain, bool HasCallSeq) {
76906f32e7eSjoerg // The transformation is somewhat dangerous if the call's chain was glued to
77006f32e7eSjoerg // the call. After MoveBelowOrigChain the load is moved between the call and
77106f32e7eSjoerg // the chain, this can create a cycle if the load is not folded. So it is
77206f32e7eSjoerg // *really* important that we are sure the load will be folded.
77306f32e7eSjoerg if (Callee.getNode() == Chain.getNode() || !Callee.hasOneUse())
77406f32e7eSjoerg return false;
77506f32e7eSjoerg LoadSDNode *LD = dyn_cast<LoadSDNode>(Callee.getNode());
77606f32e7eSjoerg if (!LD ||
77706f32e7eSjoerg !LD->isSimple() ||
77806f32e7eSjoerg LD->getAddressingMode() != ISD::UNINDEXED ||
77906f32e7eSjoerg LD->getExtensionType() != ISD::NON_EXTLOAD)
78006f32e7eSjoerg return false;
78106f32e7eSjoerg
78206f32e7eSjoerg // Now let's find the callseq_start.
78306f32e7eSjoerg while (HasCallSeq && Chain.getOpcode() != ISD::CALLSEQ_START) {
78406f32e7eSjoerg if (!Chain.hasOneUse())
78506f32e7eSjoerg return false;
78606f32e7eSjoerg Chain = Chain.getOperand(0);
78706f32e7eSjoerg }
78806f32e7eSjoerg
78906f32e7eSjoerg if (!Chain.getNumOperands())
79006f32e7eSjoerg return false;
79106f32e7eSjoerg // Since we are not checking for AA here, conservatively abort if the chain
79206f32e7eSjoerg // writes to memory. It's not safe to move the callee (a load) across a store.
79306f32e7eSjoerg if (isa<MemSDNode>(Chain.getNode()) &&
79406f32e7eSjoerg cast<MemSDNode>(Chain.getNode())->writeMem())
79506f32e7eSjoerg return false;
79606f32e7eSjoerg if (Chain.getOperand(0).getNode() == Callee.getNode())
79706f32e7eSjoerg return true;
79806f32e7eSjoerg if (Chain.getOperand(0).getOpcode() == ISD::TokenFactor &&
79906f32e7eSjoerg Callee.getValue(1).isOperandOf(Chain.getOperand(0).getNode()) &&
80006f32e7eSjoerg Callee.getValue(1).hasOneUse())
80106f32e7eSjoerg return true;
80206f32e7eSjoerg return false;
80306f32e7eSjoerg }
80406f32e7eSjoerg
isEndbrImm64(uint64_t Imm)805*da58b97aSjoerg static bool isEndbrImm64(uint64_t Imm) {
806*da58b97aSjoerg // There may be some other prefix bytes between 0xF3 and 0x0F1EFA.
807*da58b97aSjoerg // i.g: 0xF3660F1EFA, 0xF3670F1EFA
808*da58b97aSjoerg if ((Imm & 0x00FFFFFF) != 0x0F1EFA)
809*da58b97aSjoerg return false;
810*da58b97aSjoerg
811*da58b97aSjoerg uint8_t OptionalPrefixBytes [] = {0x26, 0x2e, 0x36, 0x3e, 0x64,
812*da58b97aSjoerg 0x65, 0x66, 0x67, 0xf0, 0xf2};
813*da58b97aSjoerg int i = 24; // 24bit 0x0F1EFA has matched
814*da58b97aSjoerg while (i < 64) {
815*da58b97aSjoerg uint8_t Byte = (Imm >> i) & 0xFF;
816*da58b97aSjoerg if (Byte == 0xF3)
817*da58b97aSjoerg return true;
818*da58b97aSjoerg if (!llvm::is_contained(OptionalPrefixBytes, Byte))
819*da58b97aSjoerg return false;
820*da58b97aSjoerg i += 8;
821*da58b97aSjoerg }
822*da58b97aSjoerg
823*da58b97aSjoerg return false;
824*da58b97aSjoerg }
825*da58b97aSjoerg
PreprocessISelDAG()82606f32e7eSjoerg void X86DAGToDAGISel::PreprocessISelDAG() {
827*da58b97aSjoerg bool MadeChange = false;
82806f32e7eSjoerg for (SelectionDAG::allnodes_iterator I = CurDAG->allnodes_begin(),
82906f32e7eSjoerg E = CurDAG->allnodes_end(); I != E; ) {
83006f32e7eSjoerg SDNode *N = &*I++; // Preincrement iterator to avoid invalidation issues.
83106f32e7eSjoerg
832*da58b97aSjoerg // This is for CET enhancement.
833*da58b97aSjoerg //
834*da58b97aSjoerg // ENDBR32 and ENDBR64 have specific opcodes:
835*da58b97aSjoerg // ENDBR32: F3 0F 1E FB
836*da58b97aSjoerg // ENDBR64: F3 0F 1E FA
837*da58b97aSjoerg // And we want that attackers won’t find unintended ENDBR32/64
838*da58b97aSjoerg // opcode matches in the binary
839*da58b97aSjoerg // Here’s an example:
840*da58b97aSjoerg // If the compiler had to generate asm for the following code:
841*da58b97aSjoerg // a = 0xF30F1EFA
842*da58b97aSjoerg // it could, for example, generate:
843*da58b97aSjoerg // mov 0xF30F1EFA, dword ptr[a]
844*da58b97aSjoerg // In such a case, the binary would include a gadget that starts
845*da58b97aSjoerg // with a fake ENDBR64 opcode. Therefore, we split such generation
846*da58b97aSjoerg // into multiple operations, let it not shows in the binary
847*da58b97aSjoerg if (N->getOpcode() == ISD::Constant) {
848*da58b97aSjoerg MVT VT = N->getSimpleValueType(0);
849*da58b97aSjoerg int64_t Imm = cast<ConstantSDNode>(N)->getSExtValue();
850*da58b97aSjoerg int32_t EndbrImm = Subtarget->is64Bit() ? 0xF30F1EFA : 0xF30F1EFB;
851*da58b97aSjoerg if (Imm == EndbrImm || isEndbrImm64(Imm)) {
852*da58b97aSjoerg // Check that the cf-protection-branch is enabled.
853*da58b97aSjoerg Metadata *CFProtectionBranch =
854*da58b97aSjoerg MF->getMMI().getModule()->getModuleFlag("cf-protection-branch");
855*da58b97aSjoerg if (CFProtectionBranch || IndirectBranchTracking) {
856*da58b97aSjoerg SDLoc dl(N);
857*da58b97aSjoerg SDValue Complement = CurDAG->getConstant(~Imm, dl, VT, false, true);
858*da58b97aSjoerg Complement = CurDAG->getNOT(dl, Complement, VT);
859*da58b97aSjoerg --I;
860*da58b97aSjoerg CurDAG->ReplaceAllUsesOfValueWith(SDValue(N, 0), Complement);
861*da58b97aSjoerg ++I;
862*da58b97aSjoerg MadeChange = true;
863*da58b97aSjoerg continue;
864*da58b97aSjoerg }
865*da58b97aSjoerg }
866*da58b97aSjoerg }
867*da58b97aSjoerg
86806f32e7eSjoerg // If this is a target specific AND node with no flag usages, turn it back
86906f32e7eSjoerg // into ISD::AND to enable test instruction matching.
87006f32e7eSjoerg if (N->getOpcode() == X86ISD::AND && !N->hasAnyUseOfValue(1)) {
87106f32e7eSjoerg SDValue Res = CurDAG->getNode(ISD::AND, SDLoc(N), N->getValueType(0),
87206f32e7eSjoerg N->getOperand(0), N->getOperand(1));
87306f32e7eSjoerg --I;
87406f32e7eSjoerg CurDAG->ReplaceAllUsesOfValueWith(SDValue(N, 0), Res);
87506f32e7eSjoerg ++I;
876*da58b97aSjoerg MadeChange = true;
87706f32e7eSjoerg continue;
87806f32e7eSjoerg }
87906f32e7eSjoerg
880*da58b97aSjoerg /// Convert vector increment or decrement to sub/add with an all-ones
881*da58b97aSjoerg /// constant:
882*da58b97aSjoerg /// add X, <1, 1...> --> sub X, <-1, -1...>
883*da58b97aSjoerg /// sub X, <1, 1...> --> add X, <-1, -1...>
884*da58b97aSjoerg /// The all-ones vector constant can be materialized using a pcmpeq
885*da58b97aSjoerg /// instruction that is commonly recognized as an idiom (has no register
886*da58b97aSjoerg /// dependency), so that's better/smaller than loading a splat 1 constant.
887*da58b97aSjoerg if ((N->getOpcode() == ISD::ADD || N->getOpcode() == ISD::SUB) &&
888*da58b97aSjoerg N->getSimpleValueType(0).isVector()) {
889*da58b97aSjoerg
890*da58b97aSjoerg APInt SplatVal;
891*da58b97aSjoerg if (X86::isConstantSplat(N->getOperand(1), SplatVal) &&
892*da58b97aSjoerg SplatVal.isOneValue()) {
893*da58b97aSjoerg SDLoc DL(N);
894*da58b97aSjoerg
895*da58b97aSjoerg MVT VT = N->getSimpleValueType(0);
896*da58b97aSjoerg unsigned NumElts = VT.getSizeInBits() / 32;
897*da58b97aSjoerg SDValue AllOnes =
898*da58b97aSjoerg CurDAG->getAllOnesConstant(DL, MVT::getVectorVT(MVT::i32, NumElts));
899*da58b97aSjoerg AllOnes = CurDAG->getBitcast(VT, AllOnes);
900*da58b97aSjoerg
901*da58b97aSjoerg unsigned NewOpcode = N->getOpcode() == ISD::ADD ? ISD::SUB : ISD::ADD;
902*da58b97aSjoerg SDValue Res =
903*da58b97aSjoerg CurDAG->getNode(NewOpcode, DL, VT, N->getOperand(0), AllOnes);
904*da58b97aSjoerg --I;
905*da58b97aSjoerg CurDAG->ReplaceAllUsesWith(N, Res.getNode());
906*da58b97aSjoerg ++I;
907*da58b97aSjoerg MadeChange = true;
908*da58b97aSjoerg continue;
909*da58b97aSjoerg }
910*da58b97aSjoerg }
911*da58b97aSjoerg
91206f32e7eSjoerg switch (N->getOpcode()) {
913*da58b97aSjoerg case X86ISD::VBROADCAST: {
914*da58b97aSjoerg MVT VT = N->getSimpleValueType(0);
915*da58b97aSjoerg // Emulate v32i16/v64i8 broadcast without BWI.
916*da58b97aSjoerg if (!Subtarget->hasBWI() && (VT == MVT::v32i16 || VT == MVT::v64i8)) {
917*da58b97aSjoerg MVT NarrowVT = VT == MVT::v32i16 ? MVT::v16i16 : MVT::v32i8;
918*da58b97aSjoerg SDLoc dl(N);
919*da58b97aSjoerg SDValue NarrowBCast =
920*da58b97aSjoerg CurDAG->getNode(X86ISD::VBROADCAST, dl, NarrowVT, N->getOperand(0));
921*da58b97aSjoerg SDValue Res =
922*da58b97aSjoerg CurDAG->getNode(ISD::INSERT_SUBVECTOR, dl, VT, CurDAG->getUNDEF(VT),
923*da58b97aSjoerg NarrowBCast, CurDAG->getIntPtrConstant(0, dl));
924*da58b97aSjoerg unsigned Index = VT == MVT::v32i16 ? 16 : 32;
925*da58b97aSjoerg Res = CurDAG->getNode(ISD::INSERT_SUBVECTOR, dl, VT, Res, NarrowBCast,
926*da58b97aSjoerg CurDAG->getIntPtrConstant(Index, dl));
927*da58b97aSjoerg
928*da58b97aSjoerg --I;
929*da58b97aSjoerg CurDAG->ReplaceAllUsesWith(N, Res.getNode());
930*da58b97aSjoerg ++I;
931*da58b97aSjoerg MadeChange = true;
932*da58b97aSjoerg continue;
933*da58b97aSjoerg }
934*da58b97aSjoerg
935*da58b97aSjoerg break;
936*da58b97aSjoerg }
937*da58b97aSjoerg case X86ISD::VBROADCAST_LOAD: {
938*da58b97aSjoerg MVT VT = N->getSimpleValueType(0);
939*da58b97aSjoerg // Emulate v32i16/v64i8 broadcast without BWI.
940*da58b97aSjoerg if (!Subtarget->hasBWI() && (VT == MVT::v32i16 || VT == MVT::v64i8)) {
941*da58b97aSjoerg MVT NarrowVT = VT == MVT::v32i16 ? MVT::v16i16 : MVT::v32i8;
942*da58b97aSjoerg auto *MemNode = cast<MemSDNode>(N);
943*da58b97aSjoerg SDLoc dl(N);
944*da58b97aSjoerg SDVTList VTs = CurDAG->getVTList(NarrowVT, MVT::Other);
945*da58b97aSjoerg SDValue Ops[] = {MemNode->getChain(), MemNode->getBasePtr()};
946*da58b97aSjoerg SDValue NarrowBCast = CurDAG->getMemIntrinsicNode(
947*da58b97aSjoerg X86ISD::VBROADCAST_LOAD, dl, VTs, Ops, MemNode->getMemoryVT(),
948*da58b97aSjoerg MemNode->getMemOperand());
949*da58b97aSjoerg SDValue Res =
950*da58b97aSjoerg CurDAG->getNode(ISD::INSERT_SUBVECTOR, dl, VT, CurDAG->getUNDEF(VT),
951*da58b97aSjoerg NarrowBCast, CurDAG->getIntPtrConstant(0, dl));
952*da58b97aSjoerg unsigned Index = VT == MVT::v32i16 ? 16 : 32;
953*da58b97aSjoerg Res = CurDAG->getNode(ISD::INSERT_SUBVECTOR, dl, VT, Res, NarrowBCast,
954*da58b97aSjoerg CurDAG->getIntPtrConstant(Index, dl));
955*da58b97aSjoerg
956*da58b97aSjoerg --I;
957*da58b97aSjoerg SDValue To[] = {Res, NarrowBCast.getValue(1)};
958*da58b97aSjoerg CurDAG->ReplaceAllUsesWith(N, To);
959*da58b97aSjoerg ++I;
960*da58b97aSjoerg MadeChange = true;
961*da58b97aSjoerg continue;
962*da58b97aSjoerg }
963*da58b97aSjoerg
964*da58b97aSjoerg break;
965*da58b97aSjoerg }
966*da58b97aSjoerg case ISD::VSELECT: {
967*da58b97aSjoerg // Replace VSELECT with non-mask conditions with with BLENDV.
968*da58b97aSjoerg if (N->getOperand(0).getValueType().getVectorElementType() == MVT::i1)
969*da58b97aSjoerg break;
970*da58b97aSjoerg
971*da58b97aSjoerg assert(Subtarget->hasSSE41() && "Expected SSE4.1 support!");
972*da58b97aSjoerg SDValue Blendv =
973*da58b97aSjoerg CurDAG->getNode(X86ISD::BLENDV, SDLoc(N), N->getValueType(0),
974*da58b97aSjoerg N->getOperand(0), N->getOperand(1), N->getOperand(2));
975*da58b97aSjoerg --I;
976*da58b97aSjoerg CurDAG->ReplaceAllUsesWith(N, Blendv.getNode());
977*da58b97aSjoerg ++I;
978*da58b97aSjoerg MadeChange = true;
979*da58b97aSjoerg continue;
980*da58b97aSjoerg }
981*da58b97aSjoerg case ISD::FP_ROUND:
982*da58b97aSjoerg case ISD::STRICT_FP_ROUND:
98306f32e7eSjoerg case ISD::FP_TO_SINT:
984*da58b97aSjoerg case ISD::FP_TO_UINT:
985*da58b97aSjoerg case ISD::STRICT_FP_TO_SINT:
986*da58b97aSjoerg case ISD::STRICT_FP_TO_UINT: {
98706f32e7eSjoerg // Replace vector fp_to_s/uint with their X86 specific equivalent so we
98806f32e7eSjoerg // don't need 2 sets of patterns.
98906f32e7eSjoerg if (!N->getSimpleValueType(0).isVector())
99006f32e7eSjoerg break;
99106f32e7eSjoerg
99206f32e7eSjoerg unsigned NewOpc;
99306f32e7eSjoerg switch (N->getOpcode()) {
99406f32e7eSjoerg default: llvm_unreachable("Unexpected opcode!");
995*da58b97aSjoerg case ISD::FP_ROUND: NewOpc = X86ISD::VFPROUND; break;
996*da58b97aSjoerg case ISD::STRICT_FP_ROUND: NewOpc = X86ISD::STRICT_VFPROUND; break;
997*da58b97aSjoerg case ISD::STRICT_FP_TO_SINT: NewOpc = X86ISD::STRICT_CVTTP2SI; break;
99806f32e7eSjoerg case ISD::FP_TO_SINT: NewOpc = X86ISD::CVTTP2SI; break;
999*da58b97aSjoerg case ISD::STRICT_FP_TO_UINT: NewOpc = X86ISD::STRICT_CVTTP2UI; break;
100006f32e7eSjoerg case ISD::FP_TO_UINT: NewOpc = X86ISD::CVTTP2UI; break;
100106f32e7eSjoerg }
1002*da58b97aSjoerg SDValue Res;
1003*da58b97aSjoerg if (N->isStrictFPOpcode())
1004*da58b97aSjoerg Res =
1005*da58b97aSjoerg CurDAG->getNode(NewOpc, SDLoc(N), {N->getValueType(0), MVT::Other},
1006*da58b97aSjoerg {N->getOperand(0), N->getOperand(1)});
1007*da58b97aSjoerg else
1008*da58b97aSjoerg Res =
1009*da58b97aSjoerg CurDAG->getNode(NewOpc, SDLoc(N), N->getValueType(0),
101006f32e7eSjoerg N->getOperand(0));
101106f32e7eSjoerg --I;
1012*da58b97aSjoerg CurDAG->ReplaceAllUsesWith(N, Res.getNode());
101306f32e7eSjoerg ++I;
1014*da58b97aSjoerg MadeChange = true;
101506f32e7eSjoerg continue;
101606f32e7eSjoerg }
101706f32e7eSjoerg case ISD::SHL:
101806f32e7eSjoerg case ISD::SRA:
101906f32e7eSjoerg case ISD::SRL: {
102006f32e7eSjoerg // Replace vector shifts with their X86 specific equivalent so we don't
102106f32e7eSjoerg // need 2 sets of patterns.
102206f32e7eSjoerg if (!N->getValueType(0).isVector())
102306f32e7eSjoerg break;
102406f32e7eSjoerg
102506f32e7eSjoerg unsigned NewOpc;
102606f32e7eSjoerg switch (N->getOpcode()) {
102706f32e7eSjoerg default: llvm_unreachable("Unexpected opcode!");
102806f32e7eSjoerg case ISD::SHL: NewOpc = X86ISD::VSHLV; break;
102906f32e7eSjoerg case ISD::SRA: NewOpc = X86ISD::VSRAV; break;
103006f32e7eSjoerg case ISD::SRL: NewOpc = X86ISD::VSRLV; break;
103106f32e7eSjoerg }
103206f32e7eSjoerg SDValue Res = CurDAG->getNode(NewOpc, SDLoc(N), N->getValueType(0),
103306f32e7eSjoerg N->getOperand(0), N->getOperand(1));
103406f32e7eSjoerg --I;
103506f32e7eSjoerg CurDAG->ReplaceAllUsesOfValueWith(SDValue(N, 0), Res);
103606f32e7eSjoerg ++I;
1037*da58b97aSjoerg MadeChange = true;
103806f32e7eSjoerg continue;
103906f32e7eSjoerg }
104006f32e7eSjoerg case ISD::ANY_EXTEND:
104106f32e7eSjoerg case ISD::ANY_EXTEND_VECTOR_INREG: {
104206f32e7eSjoerg // Replace vector any extend with the zero extend equivalents so we don't
104306f32e7eSjoerg // need 2 sets of patterns. Ignore vXi1 extensions.
1044*da58b97aSjoerg if (!N->getValueType(0).isVector())
104506f32e7eSjoerg break;
104606f32e7eSjoerg
1047*da58b97aSjoerg unsigned NewOpc;
1048*da58b97aSjoerg if (N->getOperand(0).getScalarValueSizeInBits() == 1) {
1049*da58b97aSjoerg assert(N->getOpcode() == ISD::ANY_EXTEND &&
1050*da58b97aSjoerg "Unexpected opcode for mask vector!");
1051*da58b97aSjoerg NewOpc = ISD::SIGN_EXTEND;
1052*da58b97aSjoerg } else {
1053*da58b97aSjoerg NewOpc = N->getOpcode() == ISD::ANY_EXTEND
105406f32e7eSjoerg ? ISD::ZERO_EXTEND
105506f32e7eSjoerg : ISD::ZERO_EXTEND_VECTOR_INREG;
1056*da58b97aSjoerg }
105706f32e7eSjoerg
105806f32e7eSjoerg SDValue Res = CurDAG->getNode(NewOpc, SDLoc(N), N->getValueType(0),
105906f32e7eSjoerg N->getOperand(0));
106006f32e7eSjoerg --I;
106106f32e7eSjoerg CurDAG->ReplaceAllUsesOfValueWith(SDValue(N, 0), Res);
106206f32e7eSjoerg ++I;
1063*da58b97aSjoerg MadeChange = true;
106406f32e7eSjoerg continue;
106506f32e7eSjoerg }
106606f32e7eSjoerg case ISD::FCEIL:
1067*da58b97aSjoerg case ISD::STRICT_FCEIL:
106806f32e7eSjoerg case ISD::FFLOOR:
1069*da58b97aSjoerg case ISD::STRICT_FFLOOR:
107006f32e7eSjoerg case ISD::FTRUNC:
1071*da58b97aSjoerg case ISD::STRICT_FTRUNC:
1072*da58b97aSjoerg case ISD::FROUNDEVEN:
1073*da58b97aSjoerg case ISD::STRICT_FROUNDEVEN:
107406f32e7eSjoerg case ISD::FNEARBYINT:
1075*da58b97aSjoerg case ISD::STRICT_FNEARBYINT:
1076*da58b97aSjoerg case ISD::FRINT:
1077*da58b97aSjoerg case ISD::STRICT_FRINT: {
107806f32e7eSjoerg // Replace fp rounding with their X86 specific equivalent so we don't
107906f32e7eSjoerg // need 2 sets of patterns.
108006f32e7eSjoerg unsigned Imm;
108106f32e7eSjoerg switch (N->getOpcode()) {
108206f32e7eSjoerg default: llvm_unreachable("Unexpected opcode!");
1083*da58b97aSjoerg case ISD::STRICT_FCEIL:
108406f32e7eSjoerg case ISD::FCEIL: Imm = 0xA; break;
1085*da58b97aSjoerg case ISD::STRICT_FFLOOR:
108606f32e7eSjoerg case ISD::FFLOOR: Imm = 0x9; break;
1087*da58b97aSjoerg case ISD::STRICT_FTRUNC:
108806f32e7eSjoerg case ISD::FTRUNC: Imm = 0xB; break;
1089*da58b97aSjoerg case ISD::STRICT_FROUNDEVEN:
1090*da58b97aSjoerg case ISD::FROUNDEVEN: Imm = 0x8; break;
1091*da58b97aSjoerg case ISD::STRICT_FNEARBYINT:
109206f32e7eSjoerg case ISD::FNEARBYINT: Imm = 0xC; break;
1093*da58b97aSjoerg case ISD::STRICT_FRINT:
109406f32e7eSjoerg case ISD::FRINT: Imm = 0x4; break;
109506f32e7eSjoerg }
109606f32e7eSjoerg SDLoc dl(N);
1097*da58b97aSjoerg bool IsStrict = N->isStrictFPOpcode();
1098*da58b97aSjoerg SDValue Res;
1099*da58b97aSjoerg if (IsStrict)
1100*da58b97aSjoerg Res = CurDAG->getNode(X86ISD::STRICT_VRNDSCALE, dl,
1101*da58b97aSjoerg {N->getValueType(0), MVT::Other},
1102*da58b97aSjoerg {N->getOperand(0), N->getOperand(1),
1103*da58b97aSjoerg CurDAG->getTargetConstant(Imm, dl, MVT::i32)});
1104*da58b97aSjoerg else
1105*da58b97aSjoerg Res = CurDAG->getNode(X86ISD::VRNDSCALE, dl, N->getValueType(0),
1106*da58b97aSjoerg N->getOperand(0),
1107*da58b97aSjoerg CurDAG->getTargetConstant(Imm, dl, MVT::i32));
110806f32e7eSjoerg --I;
1109*da58b97aSjoerg CurDAG->ReplaceAllUsesWith(N, Res.getNode());
111006f32e7eSjoerg ++I;
1111*da58b97aSjoerg MadeChange = true;
111206f32e7eSjoerg continue;
111306f32e7eSjoerg }
111406f32e7eSjoerg case X86ISD::FANDN:
111506f32e7eSjoerg case X86ISD::FAND:
111606f32e7eSjoerg case X86ISD::FOR:
111706f32e7eSjoerg case X86ISD::FXOR: {
111806f32e7eSjoerg // Widen scalar fp logic ops to vector to reduce isel patterns.
111906f32e7eSjoerg // FIXME: Can we do this during lowering/combine.
112006f32e7eSjoerg MVT VT = N->getSimpleValueType(0);
112106f32e7eSjoerg if (VT.isVector() || VT == MVT::f128)
112206f32e7eSjoerg break;
112306f32e7eSjoerg
112406f32e7eSjoerg MVT VecVT = VT == MVT::f64 ? MVT::v2f64 : MVT::v4f32;
112506f32e7eSjoerg SDLoc dl(N);
112606f32e7eSjoerg SDValue Op0 = CurDAG->getNode(ISD::SCALAR_TO_VECTOR, dl, VecVT,
112706f32e7eSjoerg N->getOperand(0));
112806f32e7eSjoerg SDValue Op1 = CurDAG->getNode(ISD::SCALAR_TO_VECTOR, dl, VecVT,
112906f32e7eSjoerg N->getOperand(1));
113006f32e7eSjoerg
113106f32e7eSjoerg SDValue Res;
113206f32e7eSjoerg if (Subtarget->hasSSE2()) {
113306f32e7eSjoerg EVT IntVT = EVT(VecVT).changeVectorElementTypeToInteger();
113406f32e7eSjoerg Op0 = CurDAG->getNode(ISD::BITCAST, dl, IntVT, Op0);
113506f32e7eSjoerg Op1 = CurDAG->getNode(ISD::BITCAST, dl, IntVT, Op1);
113606f32e7eSjoerg unsigned Opc;
113706f32e7eSjoerg switch (N->getOpcode()) {
113806f32e7eSjoerg default: llvm_unreachable("Unexpected opcode!");
113906f32e7eSjoerg case X86ISD::FANDN: Opc = X86ISD::ANDNP; break;
114006f32e7eSjoerg case X86ISD::FAND: Opc = ISD::AND; break;
114106f32e7eSjoerg case X86ISD::FOR: Opc = ISD::OR; break;
114206f32e7eSjoerg case X86ISD::FXOR: Opc = ISD::XOR; break;
114306f32e7eSjoerg }
114406f32e7eSjoerg Res = CurDAG->getNode(Opc, dl, IntVT, Op0, Op1);
114506f32e7eSjoerg Res = CurDAG->getNode(ISD::BITCAST, dl, VecVT, Res);
114606f32e7eSjoerg } else {
114706f32e7eSjoerg Res = CurDAG->getNode(N->getOpcode(), dl, VecVT, Op0, Op1);
114806f32e7eSjoerg }
114906f32e7eSjoerg Res = CurDAG->getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, Res,
115006f32e7eSjoerg CurDAG->getIntPtrConstant(0, dl));
115106f32e7eSjoerg --I;
115206f32e7eSjoerg CurDAG->ReplaceAllUsesOfValueWith(SDValue(N, 0), Res);
115306f32e7eSjoerg ++I;
1154*da58b97aSjoerg MadeChange = true;
115506f32e7eSjoerg continue;
115606f32e7eSjoerg }
115706f32e7eSjoerg }
115806f32e7eSjoerg
115906f32e7eSjoerg if (OptLevel != CodeGenOpt::None &&
116006f32e7eSjoerg // Only do this when the target can fold the load into the call or
116106f32e7eSjoerg // jmp.
1162*da58b97aSjoerg !Subtarget->useIndirectThunkCalls() &&
116306f32e7eSjoerg ((N->getOpcode() == X86ISD::CALL && !Subtarget->slowTwoMemOps()) ||
116406f32e7eSjoerg (N->getOpcode() == X86ISD::TC_RETURN &&
116506f32e7eSjoerg (Subtarget->is64Bit() ||
116606f32e7eSjoerg !getTargetMachine().isPositionIndependent())))) {
116706f32e7eSjoerg /// Also try moving call address load from outside callseq_start to just
116806f32e7eSjoerg /// before the call to allow it to be folded.
116906f32e7eSjoerg ///
117006f32e7eSjoerg /// [Load chain]
117106f32e7eSjoerg /// ^
117206f32e7eSjoerg /// |
117306f32e7eSjoerg /// [Load]
117406f32e7eSjoerg /// ^ ^
117506f32e7eSjoerg /// | |
117606f32e7eSjoerg /// / \--
117706f32e7eSjoerg /// / |
117806f32e7eSjoerg ///[CALLSEQ_START] |
117906f32e7eSjoerg /// ^ |
118006f32e7eSjoerg /// | |
118106f32e7eSjoerg /// [LOAD/C2Reg] |
118206f32e7eSjoerg /// | |
118306f32e7eSjoerg /// \ /
118406f32e7eSjoerg /// \ /
118506f32e7eSjoerg /// [CALL]
118606f32e7eSjoerg bool HasCallSeq = N->getOpcode() == X86ISD::CALL;
118706f32e7eSjoerg SDValue Chain = N->getOperand(0);
118806f32e7eSjoerg SDValue Load = N->getOperand(1);
118906f32e7eSjoerg if (!isCalleeLoad(Load, Chain, HasCallSeq))
119006f32e7eSjoerg continue;
119106f32e7eSjoerg moveBelowOrigChain(CurDAG, Load, SDValue(N, 0), Chain);
119206f32e7eSjoerg ++NumLoadMoved;
1193*da58b97aSjoerg MadeChange = true;
119406f32e7eSjoerg continue;
119506f32e7eSjoerg }
119606f32e7eSjoerg
119706f32e7eSjoerg // Lower fpround and fpextend nodes that target the FP stack to be store and
119806f32e7eSjoerg // load to the stack. This is a gross hack. We would like to simply mark
119906f32e7eSjoerg // these as being illegal, but when we do that, legalize produces these when
120006f32e7eSjoerg // it expands calls, then expands these in the same legalize pass. We would
120106f32e7eSjoerg // like dag combine to be able to hack on these between the call expansion
120206f32e7eSjoerg // and the node legalization. As such this pass basically does "really
120306f32e7eSjoerg // late" legalization of these inline with the X86 isel pass.
120406f32e7eSjoerg // FIXME: This should only happen when not compiled with -O0.
120506f32e7eSjoerg switch (N->getOpcode()) {
120606f32e7eSjoerg default: continue;
120706f32e7eSjoerg case ISD::FP_ROUND:
120806f32e7eSjoerg case ISD::FP_EXTEND:
120906f32e7eSjoerg {
121006f32e7eSjoerg MVT SrcVT = N->getOperand(0).getSimpleValueType();
121106f32e7eSjoerg MVT DstVT = N->getSimpleValueType(0);
121206f32e7eSjoerg
121306f32e7eSjoerg // If any of the sources are vectors, no fp stack involved.
121406f32e7eSjoerg if (SrcVT.isVector() || DstVT.isVector())
121506f32e7eSjoerg continue;
121606f32e7eSjoerg
121706f32e7eSjoerg // If the source and destination are SSE registers, then this is a legal
121806f32e7eSjoerg // conversion that should not be lowered.
121906f32e7eSjoerg const X86TargetLowering *X86Lowering =
122006f32e7eSjoerg static_cast<const X86TargetLowering *>(TLI);
122106f32e7eSjoerg bool SrcIsSSE = X86Lowering->isScalarFPTypeInSSEReg(SrcVT);
122206f32e7eSjoerg bool DstIsSSE = X86Lowering->isScalarFPTypeInSSEReg(DstVT);
122306f32e7eSjoerg if (SrcIsSSE && DstIsSSE)
122406f32e7eSjoerg continue;
122506f32e7eSjoerg
122606f32e7eSjoerg if (!SrcIsSSE && !DstIsSSE) {
122706f32e7eSjoerg // If this is an FPStack extension, it is a noop.
122806f32e7eSjoerg if (N->getOpcode() == ISD::FP_EXTEND)
122906f32e7eSjoerg continue;
123006f32e7eSjoerg // If this is a value-preserving FPStack truncation, it is a noop.
123106f32e7eSjoerg if (N->getConstantOperandVal(1))
123206f32e7eSjoerg continue;
123306f32e7eSjoerg }
123406f32e7eSjoerg
123506f32e7eSjoerg // Here we could have an FP stack truncation or an FPStack <-> SSE convert.
123606f32e7eSjoerg // FPStack has extload and truncstore. SSE can fold direct loads into other
123706f32e7eSjoerg // operations. Based on this, decide what we want to do.
1238*da58b97aSjoerg MVT MemVT = (N->getOpcode() == ISD::FP_ROUND) ? DstVT : SrcVT;
123906f32e7eSjoerg SDValue MemTmp = CurDAG->CreateStackTemporary(MemVT);
1240*da58b97aSjoerg int SPFI = cast<FrameIndexSDNode>(MemTmp)->getIndex();
1241*da58b97aSjoerg MachinePointerInfo MPI =
1242*da58b97aSjoerg MachinePointerInfo::getFixedStack(CurDAG->getMachineFunction(), SPFI);
124306f32e7eSjoerg SDLoc dl(N);
124406f32e7eSjoerg
124506f32e7eSjoerg // FIXME: optimize the case where the src/dest is a load or store?
124606f32e7eSjoerg
1247*da58b97aSjoerg SDValue Store = CurDAG->getTruncStore(
1248*da58b97aSjoerg CurDAG->getEntryNode(), dl, N->getOperand(0), MemTmp, MPI, MemVT);
1249*da58b97aSjoerg SDValue Result = CurDAG->getExtLoad(ISD::EXTLOAD, dl, DstVT, Store,
1250*da58b97aSjoerg MemTmp, MPI, MemVT);
125106f32e7eSjoerg
125206f32e7eSjoerg // We're about to replace all uses of the FP_ROUND/FP_EXTEND with the
125306f32e7eSjoerg // extload we created. This will cause general havok on the dag because
125406f32e7eSjoerg // anything below the conversion could be folded into other existing nodes.
125506f32e7eSjoerg // To avoid invalidating 'I', back it up to the convert node.
125606f32e7eSjoerg --I;
125706f32e7eSjoerg CurDAG->ReplaceAllUsesOfValueWith(SDValue(N, 0), Result);
125806f32e7eSjoerg break;
125906f32e7eSjoerg }
126006f32e7eSjoerg
126106f32e7eSjoerg //The sequence of events for lowering STRICT_FP versions of these nodes requires
126206f32e7eSjoerg //dealing with the chain differently, as there is already a preexisting chain.
126306f32e7eSjoerg case ISD::STRICT_FP_ROUND:
126406f32e7eSjoerg case ISD::STRICT_FP_EXTEND:
126506f32e7eSjoerg {
126606f32e7eSjoerg MVT SrcVT = N->getOperand(1).getSimpleValueType();
126706f32e7eSjoerg MVT DstVT = N->getSimpleValueType(0);
126806f32e7eSjoerg
126906f32e7eSjoerg // If any of the sources are vectors, no fp stack involved.
127006f32e7eSjoerg if (SrcVT.isVector() || DstVT.isVector())
127106f32e7eSjoerg continue;
127206f32e7eSjoerg
127306f32e7eSjoerg // If the source and destination are SSE registers, then this is a legal
127406f32e7eSjoerg // conversion that should not be lowered.
127506f32e7eSjoerg const X86TargetLowering *X86Lowering =
127606f32e7eSjoerg static_cast<const X86TargetLowering *>(TLI);
127706f32e7eSjoerg bool SrcIsSSE = X86Lowering->isScalarFPTypeInSSEReg(SrcVT);
127806f32e7eSjoerg bool DstIsSSE = X86Lowering->isScalarFPTypeInSSEReg(DstVT);
127906f32e7eSjoerg if (SrcIsSSE && DstIsSSE)
128006f32e7eSjoerg continue;
128106f32e7eSjoerg
128206f32e7eSjoerg if (!SrcIsSSE && !DstIsSSE) {
128306f32e7eSjoerg // If this is an FPStack extension, it is a noop.
128406f32e7eSjoerg if (N->getOpcode() == ISD::STRICT_FP_EXTEND)
128506f32e7eSjoerg continue;
128606f32e7eSjoerg // If this is a value-preserving FPStack truncation, it is a noop.
128706f32e7eSjoerg if (N->getConstantOperandVal(2))
128806f32e7eSjoerg continue;
128906f32e7eSjoerg }
129006f32e7eSjoerg
129106f32e7eSjoerg // Here we could have an FP stack truncation or an FPStack <-> SSE convert.
129206f32e7eSjoerg // FPStack has extload and truncstore. SSE can fold direct loads into other
129306f32e7eSjoerg // operations. Based on this, decide what we want to do.
1294*da58b97aSjoerg MVT MemVT = (N->getOpcode() == ISD::STRICT_FP_ROUND) ? DstVT : SrcVT;
129506f32e7eSjoerg SDValue MemTmp = CurDAG->CreateStackTemporary(MemVT);
1296*da58b97aSjoerg int SPFI = cast<FrameIndexSDNode>(MemTmp)->getIndex();
1297*da58b97aSjoerg MachinePointerInfo MPI =
1298*da58b97aSjoerg MachinePointerInfo::getFixedStack(CurDAG->getMachineFunction(), SPFI);
129906f32e7eSjoerg SDLoc dl(N);
130006f32e7eSjoerg
130106f32e7eSjoerg // FIXME: optimize the case where the src/dest is a load or store?
130206f32e7eSjoerg
130306f32e7eSjoerg //Since the operation is StrictFP, use the preexisting chain.
1304*da58b97aSjoerg SDValue Store, Result;
1305*da58b97aSjoerg if (!SrcIsSSE) {
1306*da58b97aSjoerg SDVTList VTs = CurDAG->getVTList(MVT::Other);
1307*da58b97aSjoerg SDValue Ops[] = {N->getOperand(0), N->getOperand(1), MemTmp};
1308*da58b97aSjoerg Store = CurDAG->getMemIntrinsicNode(X86ISD::FST, dl, VTs, Ops, MemVT,
1309*da58b97aSjoerg MPI, /*Align*/ None,
1310*da58b97aSjoerg MachineMemOperand::MOStore);
1311*da58b97aSjoerg if (N->getFlags().hasNoFPExcept()) {
1312*da58b97aSjoerg SDNodeFlags Flags = Store->getFlags();
1313*da58b97aSjoerg Flags.setNoFPExcept(true);
1314*da58b97aSjoerg Store->setFlags(Flags);
1315*da58b97aSjoerg }
1316*da58b97aSjoerg } else {
1317*da58b97aSjoerg assert(SrcVT == MemVT && "Unexpected VT!");
1318*da58b97aSjoerg Store = CurDAG->getStore(N->getOperand(0), dl, N->getOperand(1), MemTmp,
1319*da58b97aSjoerg MPI);
1320*da58b97aSjoerg }
1321*da58b97aSjoerg
1322*da58b97aSjoerg if (!DstIsSSE) {
1323*da58b97aSjoerg SDVTList VTs = CurDAG->getVTList(DstVT, MVT::Other);
1324*da58b97aSjoerg SDValue Ops[] = {Store, MemTmp};
1325*da58b97aSjoerg Result = CurDAG->getMemIntrinsicNode(
1326*da58b97aSjoerg X86ISD::FLD, dl, VTs, Ops, MemVT, MPI,
1327*da58b97aSjoerg /*Align*/ None, MachineMemOperand::MOLoad);
1328*da58b97aSjoerg if (N->getFlags().hasNoFPExcept()) {
1329*da58b97aSjoerg SDNodeFlags Flags = Result->getFlags();
1330*da58b97aSjoerg Flags.setNoFPExcept(true);
1331*da58b97aSjoerg Result->setFlags(Flags);
1332*da58b97aSjoerg }
1333*da58b97aSjoerg } else {
1334*da58b97aSjoerg assert(DstVT == MemVT && "Unexpected VT!");
1335*da58b97aSjoerg Result = CurDAG->getLoad(DstVT, dl, Store, MemTmp, MPI);
1336*da58b97aSjoerg }
133706f32e7eSjoerg
133806f32e7eSjoerg // We're about to replace all uses of the FP_ROUND/FP_EXTEND with the
133906f32e7eSjoerg // extload we created. This will cause general havok on the dag because
134006f32e7eSjoerg // anything below the conversion could be folded into other existing nodes.
134106f32e7eSjoerg // To avoid invalidating 'I', back it up to the convert node.
134206f32e7eSjoerg --I;
134306f32e7eSjoerg CurDAG->ReplaceAllUsesWith(N, Result.getNode());
134406f32e7eSjoerg break;
134506f32e7eSjoerg }
134606f32e7eSjoerg }
134706f32e7eSjoerg
134806f32e7eSjoerg
134906f32e7eSjoerg // Now that we did that, the node is dead. Increment the iterator to the
135006f32e7eSjoerg // next node to process, then delete N.
135106f32e7eSjoerg ++I;
1352*da58b97aSjoerg MadeChange = true;
135306f32e7eSjoerg }
135406f32e7eSjoerg
1355*da58b97aSjoerg // Remove any dead nodes that may have been left behind.
1356*da58b97aSjoerg if (MadeChange)
135706f32e7eSjoerg CurDAG->RemoveDeadNodes();
135806f32e7eSjoerg }
135906f32e7eSjoerg
136006f32e7eSjoerg // Look for a redundant movzx/movsx that can occur after an 8-bit divrem.
tryOptimizeRem8Extend(SDNode * N)136106f32e7eSjoerg bool X86DAGToDAGISel::tryOptimizeRem8Extend(SDNode *N) {
136206f32e7eSjoerg unsigned Opc = N->getMachineOpcode();
136306f32e7eSjoerg if (Opc != X86::MOVZX32rr8 && Opc != X86::MOVSX32rr8 &&
136406f32e7eSjoerg Opc != X86::MOVSX64rr8)
136506f32e7eSjoerg return false;
136606f32e7eSjoerg
136706f32e7eSjoerg SDValue N0 = N->getOperand(0);
136806f32e7eSjoerg
136906f32e7eSjoerg // We need to be extracting the lower bit of an extend.
137006f32e7eSjoerg if (!N0.isMachineOpcode() ||
137106f32e7eSjoerg N0.getMachineOpcode() != TargetOpcode::EXTRACT_SUBREG ||
137206f32e7eSjoerg N0.getConstantOperandVal(1) != X86::sub_8bit)
137306f32e7eSjoerg return false;
137406f32e7eSjoerg
137506f32e7eSjoerg // We're looking for either a movsx or movzx to match the original opcode.
137606f32e7eSjoerg unsigned ExpectedOpc = Opc == X86::MOVZX32rr8 ? X86::MOVZX32rr8_NOREX
137706f32e7eSjoerg : X86::MOVSX32rr8_NOREX;
137806f32e7eSjoerg SDValue N00 = N0.getOperand(0);
137906f32e7eSjoerg if (!N00.isMachineOpcode() || N00.getMachineOpcode() != ExpectedOpc)
138006f32e7eSjoerg return false;
138106f32e7eSjoerg
138206f32e7eSjoerg if (Opc == X86::MOVSX64rr8) {
138306f32e7eSjoerg // If we had a sign extend from 8 to 64 bits. We still need to go from 32
138406f32e7eSjoerg // to 64.
138506f32e7eSjoerg MachineSDNode *Extend = CurDAG->getMachineNode(X86::MOVSX64rr32, SDLoc(N),
138606f32e7eSjoerg MVT::i64, N00);
138706f32e7eSjoerg ReplaceUses(N, Extend);
138806f32e7eSjoerg } else {
138906f32e7eSjoerg // Ok we can drop this extend and just use the original extend.
139006f32e7eSjoerg ReplaceUses(N, N00.getNode());
139106f32e7eSjoerg }
139206f32e7eSjoerg
139306f32e7eSjoerg return true;
139406f32e7eSjoerg }
139506f32e7eSjoerg
PostprocessISelDAG()139606f32e7eSjoerg void X86DAGToDAGISel::PostprocessISelDAG() {
139706f32e7eSjoerg // Skip peepholes at -O0.
139806f32e7eSjoerg if (TM.getOptLevel() == CodeGenOpt::None)
139906f32e7eSjoerg return;
140006f32e7eSjoerg
140106f32e7eSjoerg SelectionDAG::allnodes_iterator Position = CurDAG->allnodes_end();
140206f32e7eSjoerg
140306f32e7eSjoerg bool MadeChange = false;
140406f32e7eSjoerg while (Position != CurDAG->allnodes_begin()) {
140506f32e7eSjoerg SDNode *N = &*--Position;
140606f32e7eSjoerg // Skip dead nodes and any non-machine opcodes.
140706f32e7eSjoerg if (N->use_empty() || !N->isMachineOpcode())
140806f32e7eSjoerg continue;
140906f32e7eSjoerg
141006f32e7eSjoerg if (tryOptimizeRem8Extend(N)) {
141106f32e7eSjoerg MadeChange = true;
141206f32e7eSjoerg continue;
141306f32e7eSjoerg }
141406f32e7eSjoerg
141506f32e7eSjoerg // Look for a TESTrr+ANDrr pattern where both operands of the test are
141606f32e7eSjoerg // the same. Rewrite to remove the AND.
141706f32e7eSjoerg unsigned Opc = N->getMachineOpcode();
141806f32e7eSjoerg if ((Opc == X86::TEST8rr || Opc == X86::TEST16rr ||
141906f32e7eSjoerg Opc == X86::TEST32rr || Opc == X86::TEST64rr) &&
142006f32e7eSjoerg N->getOperand(0) == N->getOperand(1) &&
142106f32e7eSjoerg N->isOnlyUserOf(N->getOperand(0).getNode()) &&
142206f32e7eSjoerg N->getOperand(0).isMachineOpcode()) {
142306f32e7eSjoerg SDValue And = N->getOperand(0);
142406f32e7eSjoerg unsigned N0Opc = And.getMachineOpcode();
142506f32e7eSjoerg if (N0Opc == X86::AND8rr || N0Opc == X86::AND16rr ||
142606f32e7eSjoerg N0Opc == X86::AND32rr || N0Opc == X86::AND64rr) {
142706f32e7eSjoerg MachineSDNode *Test = CurDAG->getMachineNode(Opc, SDLoc(N),
142806f32e7eSjoerg MVT::i32,
142906f32e7eSjoerg And.getOperand(0),
143006f32e7eSjoerg And.getOperand(1));
143106f32e7eSjoerg ReplaceUses(N, Test);
143206f32e7eSjoerg MadeChange = true;
143306f32e7eSjoerg continue;
143406f32e7eSjoerg }
143506f32e7eSjoerg if (N0Opc == X86::AND8rm || N0Opc == X86::AND16rm ||
143606f32e7eSjoerg N0Opc == X86::AND32rm || N0Opc == X86::AND64rm) {
143706f32e7eSjoerg unsigned NewOpc;
143806f32e7eSjoerg switch (N0Opc) {
143906f32e7eSjoerg case X86::AND8rm: NewOpc = X86::TEST8mr; break;
144006f32e7eSjoerg case X86::AND16rm: NewOpc = X86::TEST16mr; break;
144106f32e7eSjoerg case X86::AND32rm: NewOpc = X86::TEST32mr; break;
144206f32e7eSjoerg case X86::AND64rm: NewOpc = X86::TEST64mr; break;
144306f32e7eSjoerg }
144406f32e7eSjoerg
144506f32e7eSjoerg // Need to swap the memory and register operand.
144606f32e7eSjoerg SDValue Ops[] = { And.getOperand(1),
144706f32e7eSjoerg And.getOperand(2),
144806f32e7eSjoerg And.getOperand(3),
144906f32e7eSjoerg And.getOperand(4),
145006f32e7eSjoerg And.getOperand(5),
145106f32e7eSjoerg And.getOperand(0),
145206f32e7eSjoerg And.getOperand(6) /* Chain */ };
145306f32e7eSjoerg MachineSDNode *Test = CurDAG->getMachineNode(NewOpc, SDLoc(N),
145406f32e7eSjoerg MVT::i32, MVT::Other, Ops);
1455*da58b97aSjoerg CurDAG->setNodeMemRefs(
1456*da58b97aSjoerg Test, cast<MachineSDNode>(And.getNode())->memoperands());
145706f32e7eSjoerg ReplaceUses(N, Test);
145806f32e7eSjoerg MadeChange = true;
145906f32e7eSjoerg continue;
146006f32e7eSjoerg }
146106f32e7eSjoerg }
146206f32e7eSjoerg
146306f32e7eSjoerg // Look for a KAND+KORTEST and turn it into KTEST if only the zero flag is
146406f32e7eSjoerg // used. We're doing this late so we can prefer to fold the AND into masked
146506f32e7eSjoerg // comparisons. Doing that can be better for the live range of the mask
146606f32e7eSjoerg // register.
146706f32e7eSjoerg if ((Opc == X86::KORTESTBrr || Opc == X86::KORTESTWrr ||
146806f32e7eSjoerg Opc == X86::KORTESTDrr || Opc == X86::KORTESTQrr) &&
146906f32e7eSjoerg N->getOperand(0) == N->getOperand(1) &&
147006f32e7eSjoerg N->isOnlyUserOf(N->getOperand(0).getNode()) &&
147106f32e7eSjoerg N->getOperand(0).isMachineOpcode() &&
147206f32e7eSjoerg onlyUsesZeroFlag(SDValue(N, 0))) {
147306f32e7eSjoerg SDValue And = N->getOperand(0);
147406f32e7eSjoerg unsigned N0Opc = And.getMachineOpcode();
147506f32e7eSjoerg // KANDW is legal with AVX512F, but KTESTW requires AVX512DQ. The other
147606f32e7eSjoerg // KAND instructions and KTEST use the same ISA feature.
147706f32e7eSjoerg if (N0Opc == X86::KANDBrr ||
147806f32e7eSjoerg (N0Opc == X86::KANDWrr && Subtarget->hasDQI()) ||
147906f32e7eSjoerg N0Opc == X86::KANDDrr || N0Opc == X86::KANDQrr) {
148006f32e7eSjoerg unsigned NewOpc;
148106f32e7eSjoerg switch (Opc) {
148206f32e7eSjoerg default: llvm_unreachable("Unexpected opcode!");
148306f32e7eSjoerg case X86::KORTESTBrr: NewOpc = X86::KTESTBrr; break;
148406f32e7eSjoerg case X86::KORTESTWrr: NewOpc = X86::KTESTWrr; break;
148506f32e7eSjoerg case X86::KORTESTDrr: NewOpc = X86::KTESTDrr; break;
148606f32e7eSjoerg case X86::KORTESTQrr: NewOpc = X86::KTESTQrr; break;
148706f32e7eSjoerg }
148806f32e7eSjoerg MachineSDNode *KTest = CurDAG->getMachineNode(NewOpc, SDLoc(N),
148906f32e7eSjoerg MVT::i32,
149006f32e7eSjoerg And.getOperand(0),
149106f32e7eSjoerg And.getOperand(1));
149206f32e7eSjoerg ReplaceUses(N, KTest);
149306f32e7eSjoerg MadeChange = true;
149406f32e7eSjoerg continue;
149506f32e7eSjoerg }
149606f32e7eSjoerg }
149706f32e7eSjoerg
149806f32e7eSjoerg // Attempt to remove vectors moves that were inserted to zero upper bits.
149906f32e7eSjoerg if (Opc != TargetOpcode::SUBREG_TO_REG)
150006f32e7eSjoerg continue;
150106f32e7eSjoerg
150206f32e7eSjoerg unsigned SubRegIdx = N->getConstantOperandVal(2);
150306f32e7eSjoerg if (SubRegIdx != X86::sub_xmm && SubRegIdx != X86::sub_ymm)
150406f32e7eSjoerg continue;
150506f32e7eSjoerg
150606f32e7eSjoerg SDValue Move = N->getOperand(1);
150706f32e7eSjoerg if (!Move.isMachineOpcode())
150806f32e7eSjoerg continue;
150906f32e7eSjoerg
151006f32e7eSjoerg // Make sure its one of the move opcodes we recognize.
151106f32e7eSjoerg switch (Move.getMachineOpcode()) {
151206f32e7eSjoerg default:
151306f32e7eSjoerg continue;
151406f32e7eSjoerg case X86::VMOVAPDrr: case X86::VMOVUPDrr:
151506f32e7eSjoerg case X86::VMOVAPSrr: case X86::VMOVUPSrr:
151606f32e7eSjoerg case X86::VMOVDQArr: case X86::VMOVDQUrr:
151706f32e7eSjoerg case X86::VMOVAPDYrr: case X86::VMOVUPDYrr:
151806f32e7eSjoerg case X86::VMOVAPSYrr: case X86::VMOVUPSYrr:
151906f32e7eSjoerg case X86::VMOVDQAYrr: case X86::VMOVDQUYrr:
152006f32e7eSjoerg case X86::VMOVAPDZ128rr: case X86::VMOVUPDZ128rr:
152106f32e7eSjoerg case X86::VMOVAPSZ128rr: case X86::VMOVUPSZ128rr:
152206f32e7eSjoerg case X86::VMOVDQA32Z128rr: case X86::VMOVDQU32Z128rr:
152306f32e7eSjoerg case X86::VMOVDQA64Z128rr: case X86::VMOVDQU64Z128rr:
152406f32e7eSjoerg case X86::VMOVAPDZ256rr: case X86::VMOVUPDZ256rr:
152506f32e7eSjoerg case X86::VMOVAPSZ256rr: case X86::VMOVUPSZ256rr:
152606f32e7eSjoerg case X86::VMOVDQA32Z256rr: case X86::VMOVDQU32Z256rr:
152706f32e7eSjoerg case X86::VMOVDQA64Z256rr: case X86::VMOVDQU64Z256rr:
152806f32e7eSjoerg break;
152906f32e7eSjoerg }
153006f32e7eSjoerg
153106f32e7eSjoerg SDValue In = Move.getOperand(0);
153206f32e7eSjoerg if (!In.isMachineOpcode() ||
153306f32e7eSjoerg In.getMachineOpcode() <= TargetOpcode::GENERIC_OP_END)
153406f32e7eSjoerg continue;
153506f32e7eSjoerg
153606f32e7eSjoerg // Make sure the instruction has a VEX, XOP, or EVEX prefix. This covers
153706f32e7eSjoerg // the SHA instructions which use a legacy encoding.
153806f32e7eSjoerg uint64_t TSFlags = getInstrInfo()->get(In.getMachineOpcode()).TSFlags;
153906f32e7eSjoerg if ((TSFlags & X86II::EncodingMask) != X86II::VEX &&
154006f32e7eSjoerg (TSFlags & X86II::EncodingMask) != X86II::EVEX &&
154106f32e7eSjoerg (TSFlags & X86II::EncodingMask) != X86II::XOP)
154206f32e7eSjoerg continue;
154306f32e7eSjoerg
154406f32e7eSjoerg // Producing instruction is another vector instruction. We can drop the
154506f32e7eSjoerg // move.
154606f32e7eSjoerg CurDAG->UpdateNodeOperands(N, N->getOperand(0), In, N->getOperand(2));
154706f32e7eSjoerg MadeChange = true;
154806f32e7eSjoerg }
154906f32e7eSjoerg
155006f32e7eSjoerg if (MadeChange)
155106f32e7eSjoerg CurDAG->RemoveDeadNodes();
155206f32e7eSjoerg }
155306f32e7eSjoerg
155406f32e7eSjoerg
155506f32e7eSjoerg /// Emit any code that needs to be executed only in the main function.
emitSpecialCodeForMain()155606f32e7eSjoerg void X86DAGToDAGISel::emitSpecialCodeForMain() {
155706f32e7eSjoerg if (Subtarget->isTargetCygMing()) {
155806f32e7eSjoerg TargetLowering::ArgListTy Args;
155906f32e7eSjoerg auto &DL = CurDAG->getDataLayout();
156006f32e7eSjoerg
156106f32e7eSjoerg TargetLowering::CallLoweringInfo CLI(*CurDAG);
156206f32e7eSjoerg CLI.setChain(CurDAG->getRoot())
156306f32e7eSjoerg .setCallee(CallingConv::C, Type::getVoidTy(*CurDAG->getContext()),
156406f32e7eSjoerg CurDAG->getExternalSymbol("__main", TLI->getPointerTy(DL)),
156506f32e7eSjoerg std::move(Args));
156606f32e7eSjoerg const TargetLowering &TLI = CurDAG->getTargetLoweringInfo();
156706f32e7eSjoerg std::pair<SDValue, SDValue> Result = TLI.LowerCallTo(CLI);
156806f32e7eSjoerg CurDAG->setRoot(Result.second);
156906f32e7eSjoerg }
157006f32e7eSjoerg }
157106f32e7eSjoerg
emitFunctionEntryCode()1572*da58b97aSjoerg void X86DAGToDAGISel::emitFunctionEntryCode() {
157306f32e7eSjoerg // If this is main, emit special code for main.
157406f32e7eSjoerg const Function &F = MF->getFunction();
157506f32e7eSjoerg if (F.hasExternalLinkage() && F.getName() == "main")
157606f32e7eSjoerg emitSpecialCodeForMain();
157706f32e7eSjoerg }
157806f32e7eSjoerg
isDispSafeForFrameIndex(int64_t Val)157906f32e7eSjoerg static bool isDispSafeForFrameIndex(int64_t Val) {
158006f32e7eSjoerg // On 64-bit platforms, we can run into an issue where a frame index
158106f32e7eSjoerg // includes a displacement that, when added to the explicit displacement,
158206f32e7eSjoerg // will overflow the displacement field. Assuming that the frame index
158306f32e7eSjoerg // displacement fits into a 31-bit integer (which is only slightly more
158406f32e7eSjoerg // aggressive than the current fundamental assumption that it fits into
158506f32e7eSjoerg // a 32-bit integer), a 31-bit disp should always be safe.
158606f32e7eSjoerg return isInt<31>(Val);
158706f32e7eSjoerg }
158806f32e7eSjoerg
foldOffsetIntoAddress(uint64_t Offset,X86ISelAddressMode & AM)158906f32e7eSjoerg bool X86DAGToDAGISel::foldOffsetIntoAddress(uint64_t Offset,
159006f32e7eSjoerg X86ISelAddressMode &AM) {
1591*da58b97aSjoerg // We may have already matched a displacement and the caller just added the
1592*da58b97aSjoerg // symbolic displacement. So we still need to do the checks even if Offset
1593*da58b97aSjoerg // is zero.
159406f32e7eSjoerg
159506f32e7eSjoerg int64_t Val = AM.Disp + Offset;
1596*da58b97aSjoerg
1597*da58b97aSjoerg // Cannot combine ExternalSymbol displacements with integer offsets.
1598*da58b97aSjoerg if (Val != 0 && (AM.ES || AM.MCSym))
1599*da58b97aSjoerg return true;
1600*da58b97aSjoerg
160106f32e7eSjoerg CodeModel::Model M = TM.getCodeModel();
160206f32e7eSjoerg if (Subtarget->is64Bit()) {
1603*da58b97aSjoerg if (Val != 0 &&
1604*da58b97aSjoerg !X86::isOffsetSuitableForCodeModel(Val, M,
160506f32e7eSjoerg AM.hasSymbolicDisplacement()))
160606f32e7eSjoerg return true;
160706f32e7eSjoerg // In addition to the checks required for a register base, check that
160806f32e7eSjoerg // we do not try to use an unsafe Disp with a frame index.
160906f32e7eSjoerg if (AM.BaseType == X86ISelAddressMode::FrameIndexBase &&
161006f32e7eSjoerg !isDispSafeForFrameIndex(Val))
161106f32e7eSjoerg return true;
161206f32e7eSjoerg }
161306f32e7eSjoerg AM.Disp = Val;
161406f32e7eSjoerg return false;
161506f32e7eSjoerg
161606f32e7eSjoerg }
161706f32e7eSjoerg
matchLoadInAddress(LoadSDNode * N,X86ISelAddressMode & AM,bool AllowSegmentRegForX32)1618*da58b97aSjoerg bool X86DAGToDAGISel::matchLoadInAddress(LoadSDNode *N, X86ISelAddressMode &AM,
1619*da58b97aSjoerg bool AllowSegmentRegForX32) {
162006f32e7eSjoerg SDValue Address = N->getOperand(1);
162106f32e7eSjoerg
162206f32e7eSjoerg // load gs:0 -> GS segment register.
162306f32e7eSjoerg // load fs:0 -> FS segment register.
162406f32e7eSjoerg //
1625*da58b97aSjoerg // This optimization is generally valid because the GNU TLS model defines that
1626*da58b97aSjoerg // gs:0 (or fs:0 on X86-64) contains its own address. However, for X86-64 mode
1627*da58b97aSjoerg // with 32-bit registers, as we get in ILP32 mode, those registers are first
1628*da58b97aSjoerg // zero-extended to 64 bits and then added it to the base address, which gives
1629*da58b97aSjoerg // unwanted results when the register holds a negative value.
163006f32e7eSjoerg // For more information see http://people.redhat.com/drepper/tls.pdf
1631*da58b97aSjoerg if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Address)) {
163206f32e7eSjoerg if (C->getSExtValue() == 0 && AM.Segment.getNode() == nullptr &&
163306f32e7eSjoerg !IndirectTlsSegRefs &&
163406f32e7eSjoerg (Subtarget->isTargetGlibc() || Subtarget->isTargetAndroid() ||
1635*da58b97aSjoerg Subtarget->isTargetFuchsia())) {
1636*da58b97aSjoerg if (Subtarget->isTarget64BitILP32() && !AllowSegmentRegForX32)
1637*da58b97aSjoerg return true;
163806f32e7eSjoerg switch (N->getPointerInfo().getAddrSpace()) {
1639*da58b97aSjoerg case X86AS::GS:
164006f32e7eSjoerg AM.Segment = CurDAG->getRegister(X86::GS, MVT::i16);
164106f32e7eSjoerg return false;
1642*da58b97aSjoerg case X86AS::FS:
164306f32e7eSjoerg AM.Segment = CurDAG->getRegister(X86::FS, MVT::i16);
164406f32e7eSjoerg return false;
1645*da58b97aSjoerg // Address space X86AS::SS is not handled here, because it is not used to
164606f32e7eSjoerg // address TLS areas.
164706f32e7eSjoerg }
1648*da58b97aSjoerg }
1649*da58b97aSjoerg }
165006f32e7eSjoerg
165106f32e7eSjoerg return true;
165206f32e7eSjoerg }
165306f32e7eSjoerg
165406f32e7eSjoerg /// Try to match X86ISD::Wrapper and X86ISD::WrapperRIP nodes into an addressing
165506f32e7eSjoerg /// mode. These wrap things that will resolve down into a symbol reference.
165606f32e7eSjoerg /// If no match is possible, this returns true, otherwise it returns false.
matchWrapper(SDValue N,X86ISelAddressMode & AM)165706f32e7eSjoerg bool X86DAGToDAGISel::matchWrapper(SDValue N, X86ISelAddressMode &AM) {
165806f32e7eSjoerg // If the addressing mode already has a symbol as the displacement, we can
165906f32e7eSjoerg // never match another symbol.
166006f32e7eSjoerg if (AM.hasSymbolicDisplacement())
166106f32e7eSjoerg return true;
166206f32e7eSjoerg
166306f32e7eSjoerg bool IsRIPRelTLS = false;
166406f32e7eSjoerg bool IsRIPRel = N.getOpcode() == X86ISD::WrapperRIP;
166506f32e7eSjoerg if (IsRIPRel) {
166606f32e7eSjoerg SDValue Val = N.getOperand(0);
166706f32e7eSjoerg if (Val.getOpcode() == ISD::TargetGlobalTLSAddress)
166806f32e7eSjoerg IsRIPRelTLS = true;
166906f32e7eSjoerg }
167006f32e7eSjoerg
167106f32e7eSjoerg // We can't use an addressing mode in the 64-bit large code model.
167206f32e7eSjoerg // Global TLS addressing is an exception. In the medium code model,
167306f32e7eSjoerg // we use can use a mode when RIP wrappers are present.
167406f32e7eSjoerg // That signifies access to globals that are known to be "near",
167506f32e7eSjoerg // such as the GOT itself.
167606f32e7eSjoerg CodeModel::Model M = TM.getCodeModel();
167706f32e7eSjoerg if (Subtarget->is64Bit() &&
167806f32e7eSjoerg ((M == CodeModel::Large && !IsRIPRelTLS) ||
167906f32e7eSjoerg (M == CodeModel::Medium && !IsRIPRel)))
168006f32e7eSjoerg return true;
168106f32e7eSjoerg
168206f32e7eSjoerg // Base and index reg must be 0 in order to use %rip as base.
168306f32e7eSjoerg if (IsRIPRel && AM.hasBaseOrIndexReg())
168406f32e7eSjoerg return true;
168506f32e7eSjoerg
168606f32e7eSjoerg // Make a local copy in case we can't do this fold.
168706f32e7eSjoerg X86ISelAddressMode Backup = AM;
168806f32e7eSjoerg
168906f32e7eSjoerg int64_t Offset = 0;
169006f32e7eSjoerg SDValue N0 = N.getOperand(0);
169106f32e7eSjoerg if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(N0)) {
169206f32e7eSjoerg AM.GV = G->getGlobal();
169306f32e7eSjoerg AM.SymbolFlags = G->getTargetFlags();
169406f32e7eSjoerg Offset = G->getOffset();
169506f32e7eSjoerg } else if (ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(N0)) {
169606f32e7eSjoerg AM.CP = CP->getConstVal();
1697*da58b97aSjoerg AM.Alignment = CP->getAlign();
169806f32e7eSjoerg AM.SymbolFlags = CP->getTargetFlags();
169906f32e7eSjoerg Offset = CP->getOffset();
170006f32e7eSjoerg } else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(N0)) {
170106f32e7eSjoerg AM.ES = S->getSymbol();
170206f32e7eSjoerg AM.SymbolFlags = S->getTargetFlags();
170306f32e7eSjoerg } else if (auto *S = dyn_cast<MCSymbolSDNode>(N0)) {
170406f32e7eSjoerg AM.MCSym = S->getMCSymbol();
170506f32e7eSjoerg } else if (JumpTableSDNode *J = dyn_cast<JumpTableSDNode>(N0)) {
170606f32e7eSjoerg AM.JT = J->getIndex();
170706f32e7eSjoerg AM.SymbolFlags = J->getTargetFlags();
170806f32e7eSjoerg } else if (BlockAddressSDNode *BA = dyn_cast<BlockAddressSDNode>(N0)) {
170906f32e7eSjoerg AM.BlockAddr = BA->getBlockAddress();
171006f32e7eSjoerg AM.SymbolFlags = BA->getTargetFlags();
171106f32e7eSjoerg Offset = BA->getOffset();
171206f32e7eSjoerg } else
171306f32e7eSjoerg llvm_unreachable("Unhandled symbol reference node.");
171406f32e7eSjoerg
171506f32e7eSjoerg if (foldOffsetIntoAddress(Offset, AM)) {
171606f32e7eSjoerg AM = Backup;
171706f32e7eSjoerg return true;
171806f32e7eSjoerg }
171906f32e7eSjoerg
172006f32e7eSjoerg if (IsRIPRel)
172106f32e7eSjoerg AM.setBaseReg(CurDAG->getRegister(X86::RIP, MVT::i64));
172206f32e7eSjoerg
172306f32e7eSjoerg // Commit the changes now that we know this fold is safe.
172406f32e7eSjoerg return false;
172506f32e7eSjoerg }
172606f32e7eSjoerg
172706f32e7eSjoerg /// Add the specified node to the specified addressing mode, returning true if
172806f32e7eSjoerg /// it cannot be done. This just pattern matches for the addressing mode.
matchAddress(SDValue N,X86ISelAddressMode & AM)172906f32e7eSjoerg bool X86DAGToDAGISel::matchAddress(SDValue N, X86ISelAddressMode &AM) {
173006f32e7eSjoerg if (matchAddressRecursively(N, AM, 0))
173106f32e7eSjoerg return true;
173206f32e7eSjoerg
1733*da58b97aSjoerg // Post-processing: Make a second attempt to fold a load, if we now know
1734*da58b97aSjoerg // that there will not be any other register. This is only performed for
1735*da58b97aSjoerg // 64-bit ILP32 mode since 32-bit mode and 64-bit LP64 mode will have folded
1736*da58b97aSjoerg // any foldable load the first time.
1737*da58b97aSjoerg if (Subtarget->isTarget64BitILP32() &&
1738*da58b97aSjoerg AM.BaseType == X86ISelAddressMode::RegBase &&
1739*da58b97aSjoerg AM.Base_Reg.getNode() != nullptr && AM.IndexReg.getNode() == nullptr) {
1740*da58b97aSjoerg SDValue Save_Base_Reg = AM.Base_Reg;
1741*da58b97aSjoerg if (auto *LoadN = dyn_cast<LoadSDNode>(Save_Base_Reg)) {
1742*da58b97aSjoerg AM.Base_Reg = SDValue();
1743*da58b97aSjoerg if (matchLoadInAddress(LoadN, AM, /*AllowSegmentRegForX32=*/true))
1744*da58b97aSjoerg AM.Base_Reg = Save_Base_Reg;
1745*da58b97aSjoerg }
1746*da58b97aSjoerg }
1747*da58b97aSjoerg
174806f32e7eSjoerg // Post-processing: Convert lea(,%reg,2) to lea(%reg,%reg), which has
174906f32e7eSjoerg // a smaller encoding and avoids a scaled-index.
175006f32e7eSjoerg if (AM.Scale == 2 &&
175106f32e7eSjoerg AM.BaseType == X86ISelAddressMode::RegBase &&
175206f32e7eSjoerg AM.Base_Reg.getNode() == nullptr) {
175306f32e7eSjoerg AM.Base_Reg = AM.IndexReg;
175406f32e7eSjoerg AM.Scale = 1;
175506f32e7eSjoerg }
175606f32e7eSjoerg
175706f32e7eSjoerg // Post-processing: Convert foo to foo(%rip), even in non-PIC mode,
175806f32e7eSjoerg // because it has a smaller encoding.
175906f32e7eSjoerg // TODO: Which other code models can use this?
176006f32e7eSjoerg switch (TM.getCodeModel()) {
176106f32e7eSjoerg default: break;
176206f32e7eSjoerg case CodeModel::Small:
176306f32e7eSjoerg case CodeModel::Kernel:
176406f32e7eSjoerg if (Subtarget->is64Bit() &&
176506f32e7eSjoerg AM.Scale == 1 &&
176606f32e7eSjoerg AM.BaseType == X86ISelAddressMode::RegBase &&
176706f32e7eSjoerg AM.Base_Reg.getNode() == nullptr &&
176806f32e7eSjoerg AM.IndexReg.getNode() == nullptr &&
176906f32e7eSjoerg AM.SymbolFlags == X86II::MO_NO_FLAG &&
177006f32e7eSjoerg AM.hasSymbolicDisplacement())
177106f32e7eSjoerg AM.Base_Reg = CurDAG->getRegister(X86::RIP, MVT::i64);
177206f32e7eSjoerg break;
177306f32e7eSjoerg }
177406f32e7eSjoerg
177506f32e7eSjoerg return false;
177606f32e7eSjoerg }
177706f32e7eSjoerg
matchAdd(SDValue & N,X86ISelAddressMode & AM,unsigned Depth)177806f32e7eSjoerg bool X86DAGToDAGISel::matchAdd(SDValue &N, X86ISelAddressMode &AM,
177906f32e7eSjoerg unsigned Depth) {
178006f32e7eSjoerg // Add an artificial use to this node so that we can keep track of
178106f32e7eSjoerg // it if it gets CSE'd with a different node.
178206f32e7eSjoerg HandleSDNode Handle(N);
178306f32e7eSjoerg
178406f32e7eSjoerg X86ISelAddressMode Backup = AM;
178506f32e7eSjoerg if (!matchAddressRecursively(N.getOperand(0), AM, Depth+1) &&
178606f32e7eSjoerg !matchAddressRecursively(Handle.getValue().getOperand(1), AM, Depth+1))
178706f32e7eSjoerg return false;
178806f32e7eSjoerg AM = Backup;
178906f32e7eSjoerg
1790*da58b97aSjoerg // Try again after commutating the operands.
1791*da58b97aSjoerg if (!matchAddressRecursively(Handle.getValue().getOperand(1), AM,
1792*da58b97aSjoerg Depth + 1) &&
179306f32e7eSjoerg !matchAddressRecursively(Handle.getValue().getOperand(0), AM, Depth + 1))
179406f32e7eSjoerg return false;
179506f32e7eSjoerg AM = Backup;
179606f32e7eSjoerg
179706f32e7eSjoerg // If we couldn't fold both operands into the address at the same time,
179806f32e7eSjoerg // see if we can just put each operand into a register and fold at least
179906f32e7eSjoerg // the add.
180006f32e7eSjoerg if (AM.BaseType == X86ISelAddressMode::RegBase &&
180106f32e7eSjoerg !AM.Base_Reg.getNode() &&
180206f32e7eSjoerg !AM.IndexReg.getNode()) {
180306f32e7eSjoerg N = Handle.getValue();
180406f32e7eSjoerg AM.Base_Reg = N.getOperand(0);
180506f32e7eSjoerg AM.IndexReg = N.getOperand(1);
180606f32e7eSjoerg AM.Scale = 1;
180706f32e7eSjoerg return false;
180806f32e7eSjoerg }
180906f32e7eSjoerg N = Handle.getValue();
181006f32e7eSjoerg return true;
181106f32e7eSjoerg }
181206f32e7eSjoerg
181306f32e7eSjoerg // Insert a node into the DAG at least before the Pos node's position. This
181406f32e7eSjoerg // will reposition the node as needed, and will assign it a node ID that is <=
181506f32e7eSjoerg // the Pos node's ID. Note that this does *not* preserve the uniqueness of node
181606f32e7eSjoerg // IDs! The selection DAG must no longer depend on their uniqueness when this
181706f32e7eSjoerg // is used.
insertDAGNode(SelectionDAG & DAG,SDValue Pos,SDValue N)181806f32e7eSjoerg static void insertDAGNode(SelectionDAG &DAG, SDValue Pos, SDValue N) {
181906f32e7eSjoerg if (N->getNodeId() == -1 ||
182006f32e7eSjoerg (SelectionDAGISel::getUninvalidatedNodeId(N.getNode()) >
182106f32e7eSjoerg SelectionDAGISel::getUninvalidatedNodeId(Pos.getNode()))) {
182206f32e7eSjoerg DAG.RepositionNode(Pos->getIterator(), N.getNode());
182306f32e7eSjoerg // Mark Node as invalid for pruning as after this it may be a successor to a
182406f32e7eSjoerg // selected node but otherwise be in the same position of Pos.
182506f32e7eSjoerg // Conservatively mark it with the same -abs(Id) to assure node id
182606f32e7eSjoerg // invariant is preserved.
182706f32e7eSjoerg N->setNodeId(Pos->getNodeId());
182806f32e7eSjoerg SelectionDAGISel::InvalidateNodeId(N.getNode());
182906f32e7eSjoerg }
183006f32e7eSjoerg }
183106f32e7eSjoerg
183206f32e7eSjoerg // Transform "(X >> (8-C1)) & (0xff << C1)" to "((X >> 8) & 0xff) << C1" if
183306f32e7eSjoerg // safe. This allows us to convert the shift and and into an h-register
183406f32e7eSjoerg // extract and a scaled index. Returns false if the simplification is
183506f32e7eSjoerg // performed.
foldMaskAndShiftToExtract(SelectionDAG & DAG,SDValue N,uint64_t Mask,SDValue Shift,SDValue X,X86ISelAddressMode & AM)183606f32e7eSjoerg static bool foldMaskAndShiftToExtract(SelectionDAG &DAG, SDValue N,
183706f32e7eSjoerg uint64_t Mask,
183806f32e7eSjoerg SDValue Shift, SDValue X,
183906f32e7eSjoerg X86ISelAddressMode &AM) {
184006f32e7eSjoerg if (Shift.getOpcode() != ISD::SRL ||
184106f32e7eSjoerg !isa<ConstantSDNode>(Shift.getOperand(1)) ||
184206f32e7eSjoerg !Shift.hasOneUse())
184306f32e7eSjoerg return true;
184406f32e7eSjoerg
184506f32e7eSjoerg int ScaleLog = 8 - Shift.getConstantOperandVal(1);
184606f32e7eSjoerg if (ScaleLog <= 0 || ScaleLog >= 4 ||
184706f32e7eSjoerg Mask != (0xffu << ScaleLog))
184806f32e7eSjoerg return true;
184906f32e7eSjoerg
185006f32e7eSjoerg MVT VT = N.getSimpleValueType();
185106f32e7eSjoerg SDLoc DL(N);
185206f32e7eSjoerg SDValue Eight = DAG.getConstant(8, DL, MVT::i8);
185306f32e7eSjoerg SDValue NewMask = DAG.getConstant(0xff, DL, VT);
185406f32e7eSjoerg SDValue Srl = DAG.getNode(ISD::SRL, DL, VT, X, Eight);
185506f32e7eSjoerg SDValue And = DAG.getNode(ISD::AND, DL, VT, Srl, NewMask);
185606f32e7eSjoerg SDValue ShlCount = DAG.getConstant(ScaleLog, DL, MVT::i8);
185706f32e7eSjoerg SDValue Shl = DAG.getNode(ISD::SHL, DL, VT, And, ShlCount);
185806f32e7eSjoerg
185906f32e7eSjoerg // Insert the new nodes into the topological ordering. We must do this in
186006f32e7eSjoerg // a valid topological ordering as nothing is going to go back and re-sort
186106f32e7eSjoerg // these nodes. We continually insert before 'N' in sequence as this is
186206f32e7eSjoerg // essentially a pre-flattened and pre-sorted sequence of nodes. There is no
186306f32e7eSjoerg // hierarchy left to express.
186406f32e7eSjoerg insertDAGNode(DAG, N, Eight);
186506f32e7eSjoerg insertDAGNode(DAG, N, Srl);
186606f32e7eSjoerg insertDAGNode(DAG, N, NewMask);
186706f32e7eSjoerg insertDAGNode(DAG, N, And);
186806f32e7eSjoerg insertDAGNode(DAG, N, ShlCount);
186906f32e7eSjoerg insertDAGNode(DAG, N, Shl);
187006f32e7eSjoerg DAG.ReplaceAllUsesWith(N, Shl);
187106f32e7eSjoerg DAG.RemoveDeadNode(N.getNode());
187206f32e7eSjoerg AM.IndexReg = And;
187306f32e7eSjoerg AM.Scale = (1 << ScaleLog);
187406f32e7eSjoerg return false;
187506f32e7eSjoerg }
187606f32e7eSjoerg
187706f32e7eSjoerg // Transforms "(X << C1) & C2" to "(X & (C2>>C1)) << C1" if safe and if this
187806f32e7eSjoerg // allows us to fold the shift into this addressing mode. Returns false if the
187906f32e7eSjoerg // transform succeeded.
foldMaskedShiftToScaledMask(SelectionDAG & DAG,SDValue N,X86ISelAddressMode & AM)188006f32e7eSjoerg static bool foldMaskedShiftToScaledMask(SelectionDAG &DAG, SDValue N,
188106f32e7eSjoerg X86ISelAddressMode &AM) {
188206f32e7eSjoerg SDValue Shift = N.getOperand(0);
188306f32e7eSjoerg
188406f32e7eSjoerg // Use a signed mask so that shifting right will insert sign bits. These
188506f32e7eSjoerg // bits will be removed when we shift the result left so it doesn't matter
188606f32e7eSjoerg // what we use. This might allow a smaller immediate encoding.
188706f32e7eSjoerg int64_t Mask = cast<ConstantSDNode>(N->getOperand(1))->getSExtValue();
188806f32e7eSjoerg
188906f32e7eSjoerg // If we have an any_extend feeding the AND, look through it to see if there
189006f32e7eSjoerg // is a shift behind it. But only if the AND doesn't use the extended bits.
189106f32e7eSjoerg // FIXME: Generalize this to other ANY_EXTEND than i32 to i64?
189206f32e7eSjoerg bool FoundAnyExtend = false;
189306f32e7eSjoerg if (Shift.getOpcode() == ISD::ANY_EXTEND && Shift.hasOneUse() &&
189406f32e7eSjoerg Shift.getOperand(0).getSimpleValueType() == MVT::i32 &&
189506f32e7eSjoerg isUInt<32>(Mask)) {
189606f32e7eSjoerg FoundAnyExtend = true;
189706f32e7eSjoerg Shift = Shift.getOperand(0);
189806f32e7eSjoerg }
189906f32e7eSjoerg
190006f32e7eSjoerg if (Shift.getOpcode() != ISD::SHL ||
190106f32e7eSjoerg !isa<ConstantSDNode>(Shift.getOperand(1)))
190206f32e7eSjoerg return true;
190306f32e7eSjoerg
190406f32e7eSjoerg SDValue X = Shift.getOperand(0);
190506f32e7eSjoerg
190606f32e7eSjoerg // Not likely to be profitable if either the AND or SHIFT node has more
190706f32e7eSjoerg // than one use (unless all uses are for address computation). Besides,
190806f32e7eSjoerg // isel mechanism requires their node ids to be reused.
190906f32e7eSjoerg if (!N.hasOneUse() || !Shift.hasOneUse())
191006f32e7eSjoerg return true;
191106f32e7eSjoerg
191206f32e7eSjoerg // Verify that the shift amount is something we can fold.
191306f32e7eSjoerg unsigned ShiftAmt = Shift.getConstantOperandVal(1);
191406f32e7eSjoerg if (ShiftAmt != 1 && ShiftAmt != 2 && ShiftAmt != 3)
191506f32e7eSjoerg return true;
191606f32e7eSjoerg
191706f32e7eSjoerg MVT VT = N.getSimpleValueType();
191806f32e7eSjoerg SDLoc DL(N);
191906f32e7eSjoerg if (FoundAnyExtend) {
192006f32e7eSjoerg SDValue NewX = DAG.getNode(ISD::ANY_EXTEND, DL, VT, X);
192106f32e7eSjoerg insertDAGNode(DAG, N, NewX);
192206f32e7eSjoerg X = NewX;
192306f32e7eSjoerg }
192406f32e7eSjoerg
192506f32e7eSjoerg SDValue NewMask = DAG.getConstant(Mask >> ShiftAmt, DL, VT);
192606f32e7eSjoerg SDValue NewAnd = DAG.getNode(ISD::AND, DL, VT, X, NewMask);
192706f32e7eSjoerg SDValue NewShift = DAG.getNode(ISD::SHL, DL, VT, NewAnd, Shift.getOperand(1));
192806f32e7eSjoerg
192906f32e7eSjoerg // Insert the new nodes into the topological ordering. We must do this in
193006f32e7eSjoerg // a valid topological ordering as nothing is going to go back and re-sort
193106f32e7eSjoerg // these nodes. We continually insert before 'N' in sequence as this is
193206f32e7eSjoerg // essentially a pre-flattened and pre-sorted sequence of nodes. There is no
193306f32e7eSjoerg // hierarchy left to express.
193406f32e7eSjoerg insertDAGNode(DAG, N, NewMask);
193506f32e7eSjoerg insertDAGNode(DAG, N, NewAnd);
193606f32e7eSjoerg insertDAGNode(DAG, N, NewShift);
193706f32e7eSjoerg DAG.ReplaceAllUsesWith(N, NewShift);
193806f32e7eSjoerg DAG.RemoveDeadNode(N.getNode());
193906f32e7eSjoerg
194006f32e7eSjoerg AM.Scale = 1 << ShiftAmt;
194106f32e7eSjoerg AM.IndexReg = NewAnd;
194206f32e7eSjoerg return false;
194306f32e7eSjoerg }
194406f32e7eSjoerg
194506f32e7eSjoerg // Implement some heroics to detect shifts of masked values where the mask can
194606f32e7eSjoerg // be replaced by extending the shift and undoing that in the addressing mode
194706f32e7eSjoerg // scale. Patterns such as (shl (srl x, c1), c2) are canonicalized into (and
194806f32e7eSjoerg // (srl x, SHIFT), MASK) by DAGCombines that don't know the shl can be done in
194906f32e7eSjoerg // the addressing mode. This results in code such as:
195006f32e7eSjoerg //
195106f32e7eSjoerg // int f(short *y, int *lookup_table) {
195206f32e7eSjoerg // ...
195306f32e7eSjoerg // return *y + lookup_table[*y >> 11];
195406f32e7eSjoerg // }
195506f32e7eSjoerg //
195606f32e7eSjoerg // Turning into:
195706f32e7eSjoerg // movzwl (%rdi), %eax
195806f32e7eSjoerg // movl %eax, %ecx
195906f32e7eSjoerg // shrl $11, %ecx
196006f32e7eSjoerg // addl (%rsi,%rcx,4), %eax
196106f32e7eSjoerg //
196206f32e7eSjoerg // Instead of:
196306f32e7eSjoerg // movzwl (%rdi), %eax
196406f32e7eSjoerg // movl %eax, %ecx
196506f32e7eSjoerg // shrl $9, %ecx
196606f32e7eSjoerg // andl $124, %rcx
196706f32e7eSjoerg // addl (%rsi,%rcx), %eax
196806f32e7eSjoerg //
196906f32e7eSjoerg // Note that this function assumes the mask is provided as a mask *after* the
197006f32e7eSjoerg // value is shifted. The input chain may or may not match that, but computing
197106f32e7eSjoerg // such a mask is trivial.
foldMaskAndShiftToScale(SelectionDAG & DAG,SDValue N,uint64_t Mask,SDValue Shift,SDValue X,X86ISelAddressMode & AM)197206f32e7eSjoerg static bool foldMaskAndShiftToScale(SelectionDAG &DAG, SDValue N,
197306f32e7eSjoerg uint64_t Mask,
197406f32e7eSjoerg SDValue Shift, SDValue X,
197506f32e7eSjoerg X86ISelAddressMode &AM) {
197606f32e7eSjoerg if (Shift.getOpcode() != ISD::SRL || !Shift.hasOneUse() ||
197706f32e7eSjoerg !isa<ConstantSDNode>(Shift.getOperand(1)))
197806f32e7eSjoerg return true;
197906f32e7eSjoerg
198006f32e7eSjoerg unsigned ShiftAmt = Shift.getConstantOperandVal(1);
198106f32e7eSjoerg unsigned MaskLZ = countLeadingZeros(Mask);
198206f32e7eSjoerg unsigned MaskTZ = countTrailingZeros(Mask);
198306f32e7eSjoerg
198406f32e7eSjoerg // The amount of shift we're trying to fit into the addressing mode is taken
198506f32e7eSjoerg // from the trailing zeros of the mask.
198606f32e7eSjoerg unsigned AMShiftAmt = MaskTZ;
198706f32e7eSjoerg
198806f32e7eSjoerg // There is nothing we can do here unless the mask is removing some bits.
198906f32e7eSjoerg // Also, the addressing mode can only represent shifts of 1, 2, or 3 bits.
1990*da58b97aSjoerg if (AMShiftAmt == 0 || AMShiftAmt > 3) return true;
199106f32e7eSjoerg
199206f32e7eSjoerg // We also need to ensure that mask is a continuous run of bits.
199306f32e7eSjoerg if (countTrailingOnes(Mask >> MaskTZ) + MaskTZ + MaskLZ != 64) return true;
199406f32e7eSjoerg
199506f32e7eSjoerg // Scale the leading zero count down based on the actual size of the value.
199606f32e7eSjoerg // Also scale it down based on the size of the shift.
199706f32e7eSjoerg unsigned ScaleDown = (64 - X.getSimpleValueType().getSizeInBits()) + ShiftAmt;
199806f32e7eSjoerg if (MaskLZ < ScaleDown)
199906f32e7eSjoerg return true;
200006f32e7eSjoerg MaskLZ -= ScaleDown;
200106f32e7eSjoerg
200206f32e7eSjoerg // The final check is to ensure that any masked out high bits of X are
200306f32e7eSjoerg // already known to be zero. Otherwise, the mask has a semantic impact
200406f32e7eSjoerg // other than masking out a couple of low bits. Unfortunately, because of
200506f32e7eSjoerg // the mask, zero extensions will be removed from operands in some cases.
200606f32e7eSjoerg // This code works extra hard to look through extensions because we can
200706f32e7eSjoerg // replace them with zero extensions cheaply if necessary.
200806f32e7eSjoerg bool ReplacingAnyExtend = false;
200906f32e7eSjoerg if (X.getOpcode() == ISD::ANY_EXTEND) {
201006f32e7eSjoerg unsigned ExtendBits = X.getSimpleValueType().getSizeInBits() -
201106f32e7eSjoerg X.getOperand(0).getSimpleValueType().getSizeInBits();
201206f32e7eSjoerg // Assume that we'll replace the any-extend with a zero-extend, and
201306f32e7eSjoerg // narrow the search to the extended value.
201406f32e7eSjoerg X = X.getOperand(0);
201506f32e7eSjoerg MaskLZ = ExtendBits > MaskLZ ? 0 : MaskLZ - ExtendBits;
201606f32e7eSjoerg ReplacingAnyExtend = true;
201706f32e7eSjoerg }
201806f32e7eSjoerg APInt MaskedHighBits =
201906f32e7eSjoerg APInt::getHighBitsSet(X.getSimpleValueType().getSizeInBits(), MaskLZ);
202006f32e7eSjoerg KnownBits Known = DAG.computeKnownBits(X);
202106f32e7eSjoerg if (MaskedHighBits != Known.Zero) return true;
202206f32e7eSjoerg
202306f32e7eSjoerg // We've identified a pattern that can be transformed into a single shift
202406f32e7eSjoerg // and an addressing mode. Make it so.
202506f32e7eSjoerg MVT VT = N.getSimpleValueType();
202606f32e7eSjoerg if (ReplacingAnyExtend) {
202706f32e7eSjoerg assert(X.getValueType() != VT);
202806f32e7eSjoerg // We looked through an ANY_EXTEND node, insert a ZERO_EXTEND.
202906f32e7eSjoerg SDValue NewX = DAG.getNode(ISD::ZERO_EXTEND, SDLoc(X), VT, X);
203006f32e7eSjoerg insertDAGNode(DAG, N, NewX);
203106f32e7eSjoerg X = NewX;
203206f32e7eSjoerg }
203306f32e7eSjoerg SDLoc DL(N);
203406f32e7eSjoerg SDValue NewSRLAmt = DAG.getConstant(ShiftAmt + AMShiftAmt, DL, MVT::i8);
203506f32e7eSjoerg SDValue NewSRL = DAG.getNode(ISD::SRL, DL, VT, X, NewSRLAmt);
203606f32e7eSjoerg SDValue NewSHLAmt = DAG.getConstant(AMShiftAmt, DL, MVT::i8);
203706f32e7eSjoerg SDValue NewSHL = DAG.getNode(ISD::SHL, DL, VT, NewSRL, NewSHLAmt);
203806f32e7eSjoerg
203906f32e7eSjoerg // Insert the new nodes into the topological ordering. We must do this in
204006f32e7eSjoerg // a valid topological ordering as nothing is going to go back and re-sort
204106f32e7eSjoerg // these nodes. We continually insert before 'N' in sequence as this is
204206f32e7eSjoerg // essentially a pre-flattened and pre-sorted sequence of nodes. There is no
204306f32e7eSjoerg // hierarchy left to express.
204406f32e7eSjoerg insertDAGNode(DAG, N, NewSRLAmt);
204506f32e7eSjoerg insertDAGNode(DAG, N, NewSRL);
204606f32e7eSjoerg insertDAGNode(DAG, N, NewSHLAmt);
204706f32e7eSjoerg insertDAGNode(DAG, N, NewSHL);
204806f32e7eSjoerg DAG.ReplaceAllUsesWith(N, NewSHL);
204906f32e7eSjoerg DAG.RemoveDeadNode(N.getNode());
205006f32e7eSjoerg
205106f32e7eSjoerg AM.Scale = 1 << AMShiftAmt;
205206f32e7eSjoerg AM.IndexReg = NewSRL;
205306f32e7eSjoerg return false;
205406f32e7eSjoerg }
205506f32e7eSjoerg
205606f32e7eSjoerg // Transform "(X >> SHIFT) & (MASK << C1)" to
205706f32e7eSjoerg // "((X >> (SHIFT + C1)) & (MASK)) << C1". Everything before the SHL will be
205806f32e7eSjoerg // matched to a BEXTR later. Returns false if the simplification is performed.
foldMaskedShiftToBEXTR(SelectionDAG & DAG,SDValue N,uint64_t Mask,SDValue Shift,SDValue X,X86ISelAddressMode & AM,const X86Subtarget & Subtarget)205906f32e7eSjoerg static bool foldMaskedShiftToBEXTR(SelectionDAG &DAG, SDValue N,
206006f32e7eSjoerg uint64_t Mask,
206106f32e7eSjoerg SDValue Shift, SDValue X,
206206f32e7eSjoerg X86ISelAddressMode &AM,
206306f32e7eSjoerg const X86Subtarget &Subtarget) {
206406f32e7eSjoerg if (Shift.getOpcode() != ISD::SRL ||
206506f32e7eSjoerg !isa<ConstantSDNode>(Shift.getOperand(1)) ||
206606f32e7eSjoerg !Shift.hasOneUse() || !N.hasOneUse())
206706f32e7eSjoerg return true;
206806f32e7eSjoerg
206906f32e7eSjoerg // Only do this if BEXTR will be matched by matchBEXTRFromAndImm.
207006f32e7eSjoerg if (!Subtarget.hasTBM() &&
207106f32e7eSjoerg !(Subtarget.hasBMI() && Subtarget.hasFastBEXTR()))
207206f32e7eSjoerg return true;
207306f32e7eSjoerg
207406f32e7eSjoerg // We need to ensure that mask is a continuous run of bits.
207506f32e7eSjoerg if (!isShiftedMask_64(Mask)) return true;
207606f32e7eSjoerg
207706f32e7eSjoerg unsigned ShiftAmt = Shift.getConstantOperandVal(1);
207806f32e7eSjoerg
207906f32e7eSjoerg // The amount of shift we're trying to fit into the addressing mode is taken
208006f32e7eSjoerg // from the trailing zeros of the mask.
208106f32e7eSjoerg unsigned AMShiftAmt = countTrailingZeros(Mask);
208206f32e7eSjoerg
208306f32e7eSjoerg // There is nothing we can do here unless the mask is removing some bits.
208406f32e7eSjoerg // Also, the addressing mode can only represent shifts of 1, 2, or 3 bits.
2085*da58b97aSjoerg if (AMShiftAmt == 0 || AMShiftAmt > 3) return true;
208606f32e7eSjoerg
208706f32e7eSjoerg MVT VT = N.getSimpleValueType();
208806f32e7eSjoerg SDLoc DL(N);
208906f32e7eSjoerg SDValue NewSRLAmt = DAG.getConstant(ShiftAmt + AMShiftAmt, DL, MVT::i8);
209006f32e7eSjoerg SDValue NewSRL = DAG.getNode(ISD::SRL, DL, VT, X, NewSRLAmt);
209106f32e7eSjoerg SDValue NewMask = DAG.getConstant(Mask >> AMShiftAmt, DL, VT);
209206f32e7eSjoerg SDValue NewAnd = DAG.getNode(ISD::AND, DL, VT, NewSRL, NewMask);
209306f32e7eSjoerg SDValue NewSHLAmt = DAG.getConstant(AMShiftAmt, DL, MVT::i8);
209406f32e7eSjoerg SDValue NewSHL = DAG.getNode(ISD::SHL, DL, VT, NewAnd, NewSHLAmt);
209506f32e7eSjoerg
209606f32e7eSjoerg // Insert the new nodes into the topological ordering. We must do this in
209706f32e7eSjoerg // a valid topological ordering as nothing is going to go back and re-sort
209806f32e7eSjoerg // these nodes. We continually insert before 'N' in sequence as this is
209906f32e7eSjoerg // essentially a pre-flattened and pre-sorted sequence of nodes. There is no
210006f32e7eSjoerg // hierarchy left to express.
210106f32e7eSjoerg insertDAGNode(DAG, N, NewSRLAmt);
210206f32e7eSjoerg insertDAGNode(DAG, N, NewSRL);
210306f32e7eSjoerg insertDAGNode(DAG, N, NewMask);
210406f32e7eSjoerg insertDAGNode(DAG, N, NewAnd);
210506f32e7eSjoerg insertDAGNode(DAG, N, NewSHLAmt);
210606f32e7eSjoerg insertDAGNode(DAG, N, NewSHL);
210706f32e7eSjoerg DAG.ReplaceAllUsesWith(N, NewSHL);
210806f32e7eSjoerg DAG.RemoveDeadNode(N.getNode());
210906f32e7eSjoerg
211006f32e7eSjoerg AM.Scale = 1 << AMShiftAmt;
211106f32e7eSjoerg AM.IndexReg = NewAnd;
211206f32e7eSjoerg return false;
211306f32e7eSjoerg }
211406f32e7eSjoerg
matchAddressRecursively(SDValue N,X86ISelAddressMode & AM,unsigned Depth)211506f32e7eSjoerg bool X86DAGToDAGISel::matchAddressRecursively(SDValue N, X86ISelAddressMode &AM,
211606f32e7eSjoerg unsigned Depth) {
211706f32e7eSjoerg SDLoc dl(N);
211806f32e7eSjoerg LLVM_DEBUG({
211906f32e7eSjoerg dbgs() << "MatchAddress: ";
212006f32e7eSjoerg AM.dump(CurDAG);
212106f32e7eSjoerg });
212206f32e7eSjoerg // Limit recursion.
212306f32e7eSjoerg if (Depth > 5)
212406f32e7eSjoerg return matchAddressBase(N, AM);
212506f32e7eSjoerg
212606f32e7eSjoerg // If this is already a %rip relative address, we can only merge immediates
212706f32e7eSjoerg // into it. Instead of handling this in every case, we handle it here.
212806f32e7eSjoerg // RIP relative addressing: %rip + 32-bit displacement!
212906f32e7eSjoerg if (AM.isRIPRelative()) {
213006f32e7eSjoerg // FIXME: JumpTable and ExternalSymbol address currently don't like
213106f32e7eSjoerg // displacements. It isn't very important, but this should be fixed for
213206f32e7eSjoerg // consistency.
213306f32e7eSjoerg if (!(AM.ES || AM.MCSym) && AM.JT != -1)
213406f32e7eSjoerg return true;
213506f32e7eSjoerg
213606f32e7eSjoerg if (ConstantSDNode *Cst = dyn_cast<ConstantSDNode>(N))
213706f32e7eSjoerg if (!foldOffsetIntoAddress(Cst->getSExtValue(), AM))
213806f32e7eSjoerg return false;
213906f32e7eSjoerg return true;
214006f32e7eSjoerg }
214106f32e7eSjoerg
214206f32e7eSjoerg switch (N.getOpcode()) {
214306f32e7eSjoerg default: break;
214406f32e7eSjoerg case ISD::LOCAL_RECOVER: {
214506f32e7eSjoerg if (!AM.hasSymbolicDisplacement() && AM.Disp == 0)
214606f32e7eSjoerg if (const auto *ESNode = dyn_cast<MCSymbolSDNode>(N.getOperand(0))) {
214706f32e7eSjoerg // Use the symbol and don't prefix it.
214806f32e7eSjoerg AM.MCSym = ESNode->getMCSymbol();
214906f32e7eSjoerg return false;
215006f32e7eSjoerg }
215106f32e7eSjoerg break;
215206f32e7eSjoerg }
215306f32e7eSjoerg case ISD::Constant: {
215406f32e7eSjoerg uint64_t Val = cast<ConstantSDNode>(N)->getSExtValue();
215506f32e7eSjoerg if (!foldOffsetIntoAddress(Val, AM))
215606f32e7eSjoerg return false;
215706f32e7eSjoerg break;
215806f32e7eSjoerg }
215906f32e7eSjoerg
216006f32e7eSjoerg case X86ISD::Wrapper:
216106f32e7eSjoerg case X86ISD::WrapperRIP:
216206f32e7eSjoerg if (!matchWrapper(N, AM))
216306f32e7eSjoerg return false;
216406f32e7eSjoerg break;
216506f32e7eSjoerg
216606f32e7eSjoerg case ISD::LOAD:
216706f32e7eSjoerg if (!matchLoadInAddress(cast<LoadSDNode>(N), AM))
216806f32e7eSjoerg return false;
216906f32e7eSjoerg break;
217006f32e7eSjoerg
217106f32e7eSjoerg case ISD::FrameIndex:
217206f32e7eSjoerg if (AM.BaseType == X86ISelAddressMode::RegBase &&
217306f32e7eSjoerg AM.Base_Reg.getNode() == nullptr &&
217406f32e7eSjoerg (!Subtarget->is64Bit() || isDispSafeForFrameIndex(AM.Disp))) {
217506f32e7eSjoerg AM.BaseType = X86ISelAddressMode::FrameIndexBase;
217606f32e7eSjoerg AM.Base_FrameIndex = cast<FrameIndexSDNode>(N)->getIndex();
217706f32e7eSjoerg return false;
217806f32e7eSjoerg }
217906f32e7eSjoerg break;
218006f32e7eSjoerg
218106f32e7eSjoerg case ISD::SHL:
218206f32e7eSjoerg if (AM.IndexReg.getNode() != nullptr || AM.Scale != 1)
218306f32e7eSjoerg break;
218406f32e7eSjoerg
218506f32e7eSjoerg if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
218606f32e7eSjoerg unsigned Val = CN->getZExtValue();
218706f32e7eSjoerg // Note that we handle x<<1 as (,x,2) rather than (x,x) here so
218806f32e7eSjoerg // that the base operand remains free for further matching. If
218906f32e7eSjoerg // the base doesn't end up getting used, a post-processing step
219006f32e7eSjoerg // in MatchAddress turns (,x,2) into (x,x), which is cheaper.
219106f32e7eSjoerg if (Val == 1 || Val == 2 || Val == 3) {
219206f32e7eSjoerg AM.Scale = 1 << Val;
219306f32e7eSjoerg SDValue ShVal = N.getOperand(0);
219406f32e7eSjoerg
219506f32e7eSjoerg // Okay, we know that we have a scale by now. However, if the scaled
219606f32e7eSjoerg // value is an add of something and a constant, we can fold the
219706f32e7eSjoerg // constant into the disp field here.
219806f32e7eSjoerg if (CurDAG->isBaseWithConstantOffset(ShVal)) {
219906f32e7eSjoerg AM.IndexReg = ShVal.getOperand(0);
220006f32e7eSjoerg ConstantSDNode *AddVal = cast<ConstantSDNode>(ShVal.getOperand(1));
220106f32e7eSjoerg uint64_t Disp = (uint64_t)AddVal->getSExtValue() << Val;
220206f32e7eSjoerg if (!foldOffsetIntoAddress(Disp, AM))
220306f32e7eSjoerg return false;
220406f32e7eSjoerg }
220506f32e7eSjoerg
220606f32e7eSjoerg AM.IndexReg = ShVal;
220706f32e7eSjoerg return false;
220806f32e7eSjoerg }
220906f32e7eSjoerg }
221006f32e7eSjoerg break;
221106f32e7eSjoerg
221206f32e7eSjoerg case ISD::SRL: {
221306f32e7eSjoerg // Scale must not be used already.
221406f32e7eSjoerg if (AM.IndexReg.getNode() != nullptr || AM.Scale != 1) break;
221506f32e7eSjoerg
221606f32e7eSjoerg // We only handle up to 64-bit values here as those are what matter for
221706f32e7eSjoerg // addressing mode optimizations.
221806f32e7eSjoerg assert(N.getSimpleValueType().getSizeInBits() <= 64 &&
221906f32e7eSjoerg "Unexpected value size!");
222006f32e7eSjoerg
222106f32e7eSjoerg SDValue And = N.getOperand(0);
222206f32e7eSjoerg if (And.getOpcode() != ISD::AND) break;
222306f32e7eSjoerg SDValue X = And.getOperand(0);
222406f32e7eSjoerg
222506f32e7eSjoerg // The mask used for the transform is expected to be post-shift, but we
222606f32e7eSjoerg // found the shift first so just apply the shift to the mask before passing
222706f32e7eSjoerg // it down.
222806f32e7eSjoerg if (!isa<ConstantSDNode>(N.getOperand(1)) ||
222906f32e7eSjoerg !isa<ConstantSDNode>(And.getOperand(1)))
223006f32e7eSjoerg break;
223106f32e7eSjoerg uint64_t Mask = And.getConstantOperandVal(1) >> N.getConstantOperandVal(1);
223206f32e7eSjoerg
223306f32e7eSjoerg // Try to fold the mask and shift into the scale, and return false if we
223406f32e7eSjoerg // succeed.
223506f32e7eSjoerg if (!foldMaskAndShiftToScale(*CurDAG, N, Mask, N, X, AM))
223606f32e7eSjoerg return false;
223706f32e7eSjoerg break;
223806f32e7eSjoerg }
223906f32e7eSjoerg
224006f32e7eSjoerg case ISD::SMUL_LOHI:
224106f32e7eSjoerg case ISD::UMUL_LOHI:
224206f32e7eSjoerg // A mul_lohi where we need the low part can be folded as a plain multiply.
224306f32e7eSjoerg if (N.getResNo() != 0) break;
224406f32e7eSjoerg LLVM_FALLTHROUGH;
224506f32e7eSjoerg case ISD::MUL:
224606f32e7eSjoerg case X86ISD::MUL_IMM:
224706f32e7eSjoerg // X*[3,5,9] -> X+X*[2,4,8]
224806f32e7eSjoerg if (AM.BaseType == X86ISelAddressMode::RegBase &&
224906f32e7eSjoerg AM.Base_Reg.getNode() == nullptr &&
225006f32e7eSjoerg AM.IndexReg.getNode() == nullptr) {
225106f32e7eSjoerg if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N.getOperand(1)))
225206f32e7eSjoerg if (CN->getZExtValue() == 3 || CN->getZExtValue() == 5 ||
225306f32e7eSjoerg CN->getZExtValue() == 9) {
225406f32e7eSjoerg AM.Scale = unsigned(CN->getZExtValue())-1;
225506f32e7eSjoerg
225606f32e7eSjoerg SDValue MulVal = N.getOperand(0);
225706f32e7eSjoerg SDValue Reg;
225806f32e7eSjoerg
225906f32e7eSjoerg // Okay, we know that we have a scale by now. However, if the scaled
226006f32e7eSjoerg // value is an add of something and a constant, we can fold the
226106f32e7eSjoerg // constant into the disp field here.
226206f32e7eSjoerg if (MulVal.getNode()->getOpcode() == ISD::ADD && MulVal.hasOneUse() &&
226306f32e7eSjoerg isa<ConstantSDNode>(MulVal.getOperand(1))) {
226406f32e7eSjoerg Reg = MulVal.getOperand(0);
226506f32e7eSjoerg ConstantSDNode *AddVal =
226606f32e7eSjoerg cast<ConstantSDNode>(MulVal.getOperand(1));
226706f32e7eSjoerg uint64_t Disp = AddVal->getSExtValue() * CN->getZExtValue();
226806f32e7eSjoerg if (foldOffsetIntoAddress(Disp, AM))
226906f32e7eSjoerg Reg = N.getOperand(0);
227006f32e7eSjoerg } else {
227106f32e7eSjoerg Reg = N.getOperand(0);
227206f32e7eSjoerg }
227306f32e7eSjoerg
227406f32e7eSjoerg AM.IndexReg = AM.Base_Reg = Reg;
227506f32e7eSjoerg return false;
227606f32e7eSjoerg }
227706f32e7eSjoerg }
227806f32e7eSjoerg break;
227906f32e7eSjoerg
228006f32e7eSjoerg case ISD::SUB: {
228106f32e7eSjoerg // Given A-B, if A can be completely folded into the address and
228206f32e7eSjoerg // the index field with the index field unused, use -B as the index.
228306f32e7eSjoerg // This is a win if a has multiple parts that can be folded into
228406f32e7eSjoerg // the address. Also, this saves a mov if the base register has
228506f32e7eSjoerg // other uses, since it avoids a two-address sub instruction, however
228606f32e7eSjoerg // it costs an additional mov if the index register has other uses.
228706f32e7eSjoerg
228806f32e7eSjoerg // Add an artificial use to this node so that we can keep track of
228906f32e7eSjoerg // it if it gets CSE'd with a different node.
229006f32e7eSjoerg HandleSDNode Handle(N);
229106f32e7eSjoerg
229206f32e7eSjoerg // Test if the LHS of the sub can be folded.
229306f32e7eSjoerg X86ISelAddressMode Backup = AM;
229406f32e7eSjoerg if (matchAddressRecursively(N.getOperand(0), AM, Depth+1)) {
229506f32e7eSjoerg N = Handle.getValue();
229606f32e7eSjoerg AM = Backup;
229706f32e7eSjoerg break;
229806f32e7eSjoerg }
229906f32e7eSjoerg N = Handle.getValue();
230006f32e7eSjoerg // Test if the index field is free for use.
230106f32e7eSjoerg if (AM.IndexReg.getNode() || AM.isRIPRelative()) {
230206f32e7eSjoerg AM = Backup;
230306f32e7eSjoerg break;
230406f32e7eSjoerg }
230506f32e7eSjoerg
230606f32e7eSjoerg int Cost = 0;
230706f32e7eSjoerg SDValue RHS = N.getOperand(1);
230806f32e7eSjoerg // If the RHS involves a register with multiple uses, this
230906f32e7eSjoerg // transformation incurs an extra mov, due to the neg instruction
231006f32e7eSjoerg // clobbering its operand.
231106f32e7eSjoerg if (!RHS.getNode()->hasOneUse() ||
231206f32e7eSjoerg RHS.getNode()->getOpcode() == ISD::CopyFromReg ||
231306f32e7eSjoerg RHS.getNode()->getOpcode() == ISD::TRUNCATE ||
231406f32e7eSjoerg RHS.getNode()->getOpcode() == ISD::ANY_EXTEND ||
231506f32e7eSjoerg (RHS.getNode()->getOpcode() == ISD::ZERO_EXTEND &&
231606f32e7eSjoerg RHS.getOperand(0).getValueType() == MVT::i32))
231706f32e7eSjoerg ++Cost;
231806f32e7eSjoerg // If the base is a register with multiple uses, this
231906f32e7eSjoerg // transformation may save a mov.
232006f32e7eSjoerg if ((AM.BaseType == X86ISelAddressMode::RegBase && AM.Base_Reg.getNode() &&
232106f32e7eSjoerg !AM.Base_Reg.getNode()->hasOneUse()) ||
232206f32e7eSjoerg AM.BaseType == X86ISelAddressMode::FrameIndexBase)
232306f32e7eSjoerg --Cost;
232406f32e7eSjoerg // If the folded LHS was interesting, this transformation saves
232506f32e7eSjoerg // address arithmetic.
232606f32e7eSjoerg if ((AM.hasSymbolicDisplacement() && !Backup.hasSymbolicDisplacement()) +
232706f32e7eSjoerg ((AM.Disp != 0) && (Backup.Disp == 0)) +
232806f32e7eSjoerg (AM.Segment.getNode() && !Backup.Segment.getNode()) >= 2)
232906f32e7eSjoerg --Cost;
233006f32e7eSjoerg // If it doesn't look like it may be an overall win, don't do it.
233106f32e7eSjoerg if (Cost >= 0) {
233206f32e7eSjoerg AM = Backup;
233306f32e7eSjoerg break;
233406f32e7eSjoerg }
233506f32e7eSjoerg
233606f32e7eSjoerg // Ok, the transformation is legal and appears profitable. Go for it.
233706f32e7eSjoerg // Negation will be emitted later to avoid creating dangling nodes if this
233806f32e7eSjoerg // was an unprofitable LEA.
233906f32e7eSjoerg AM.IndexReg = RHS;
234006f32e7eSjoerg AM.NegateIndex = true;
234106f32e7eSjoerg AM.Scale = 1;
234206f32e7eSjoerg return false;
234306f32e7eSjoerg }
234406f32e7eSjoerg
234506f32e7eSjoerg case ISD::ADD:
234606f32e7eSjoerg if (!matchAdd(N, AM, Depth))
234706f32e7eSjoerg return false;
234806f32e7eSjoerg break;
234906f32e7eSjoerg
235006f32e7eSjoerg case ISD::OR:
235106f32e7eSjoerg // We want to look through a transform in InstCombine and DAGCombiner that
235206f32e7eSjoerg // turns 'add' into 'or', so we can treat this 'or' exactly like an 'add'.
235306f32e7eSjoerg // Example: (or (and x, 1), (shl y, 3)) --> (add (and x, 1), (shl y, 3))
235406f32e7eSjoerg // An 'lea' can then be used to match the shift (multiply) and add:
235506f32e7eSjoerg // and $1, %esi
235606f32e7eSjoerg // lea (%rsi, %rdi, 8), %rax
235706f32e7eSjoerg if (CurDAG->haveNoCommonBitsSet(N.getOperand(0), N.getOperand(1)) &&
235806f32e7eSjoerg !matchAdd(N, AM, Depth))
235906f32e7eSjoerg return false;
236006f32e7eSjoerg break;
236106f32e7eSjoerg
236206f32e7eSjoerg case ISD::AND: {
236306f32e7eSjoerg // Perform some heroic transforms on an and of a constant-count shift
236406f32e7eSjoerg // with a constant to enable use of the scaled offset field.
236506f32e7eSjoerg
236606f32e7eSjoerg // Scale must not be used already.
236706f32e7eSjoerg if (AM.IndexReg.getNode() != nullptr || AM.Scale != 1) break;
236806f32e7eSjoerg
236906f32e7eSjoerg // We only handle up to 64-bit values here as those are what matter for
237006f32e7eSjoerg // addressing mode optimizations.
237106f32e7eSjoerg assert(N.getSimpleValueType().getSizeInBits() <= 64 &&
237206f32e7eSjoerg "Unexpected value size!");
237306f32e7eSjoerg
237406f32e7eSjoerg if (!isa<ConstantSDNode>(N.getOperand(1)))
237506f32e7eSjoerg break;
237606f32e7eSjoerg
237706f32e7eSjoerg if (N.getOperand(0).getOpcode() == ISD::SRL) {
237806f32e7eSjoerg SDValue Shift = N.getOperand(0);
237906f32e7eSjoerg SDValue X = Shift.getOperand(0);
238006f32e7eSjoerg
238106f32e7eSjoerg uint64_t Mask = N.getConstantOperandVal(1);
238206f32e7eSjoerg
238306f32e7eSjoerg // Try to fold the mask and shift into an extract and scale.
238406f32e7eSjoerg if (!foldMaskAndShiftToExtract(*CurDAG, N, Mask, Shift, X, AM))
238506f32e7eSjoerg return false;
238606f32e7eSjoerg
238706f32e7eSjoerg // Try to fold the mask and shift directly into the scale.
238806f32e7eSjoerg if (!foldMaskAndShiftToScale(*CurDAG, N, Mask, Shift, X, AM))
238906f32e7eSjoerg return false;
239006f32e7eSjoerg
239106f32e7eSjoerg // Try to fold the mask and shift into BEXTR and scale.
239206f32e7eSjoerg if (!foldMaskedShiftToBEXTR(*CurDAG, N, Mask, Shift, X, AM, *Subtarget))
239306f32e7eSjoerg return false;
239406f32e7eSjoerg }
239506f32e7eSjoerg
239606f32e7eSjoerg // Try to swap the mask and shift to place shifts which can be done as
239706f32e7eSjoerg // a scale on the outside of the mask.
239806f32e7eSjoerg if (!foldMaskedShiftToScaledMask(*CurDAG, N, AM))
239906f32e7eSjoerg return false;
240006f32e7eSjoerg
240106f32e7eSjoerg break;
240206f32e7eSjoerg }
240306f32e7eSjoerg case ISD::ZERO_EXTEND: {
240406f32e7eSjoerg // Try to widen a zexted shift left to the same size as its use, so we can
240506f32e7eSjoerg // match the shift as a scale factor.
240606f32e7eSjoerg if (AM.IndexReg.getNode() != nullptr || AM.Scale != 1)
240706f32e7eSjoerg break;
240806f32e7eSjoerg if (N.getOperand(0).getOpcode() != ISD::SHL || !N.getOperand(0).hasOneUse())
240906f32e7eSjoerg break;
241006f32e7eSjoerg
241106f32e7eSjoerg // Give up if the shift is not a valid scale factor [1,2,3].
241206f32e7eSjoerg SDValue Shl = N.getOperand(0);
241306f32e7eSjoerg auto *ShAmtC = dyn_cast<ConstantSDNode>(Shl.getOperand(1));
241406f32e7eSjoerg if (!ShAmtC || ShAmtC->getZExtValue() > 3)
241506f32e7eSjoerg break;
241606f32e7eSjoerg
241706f32e7eSjoerg // The narrow shift must only shift out zero bits (it must be 'nuw').
241806f32e7eSjoerg // That makes it safe to widen to the destination type.
241906f32e7eSjoerg APInt HighZeros = APInt::getHighBitsSet(Shl.getValueSizeInBits(),
242006f32e7eSjoerg ShAmtC->getZExtValue());
242106f32e7eSjoerg if (!CurDAG->MaskedValueIsZero(Shl.getOperand(0), HighZeros))
242206f32e7eSjoerg break;
242306f32e7eSjoerg
242406f32e7eSjoerg // zext (shl nuw i8 %x, C) to i32 --> shl (zext i8 %x to i32), (zext C)
242506f32e7eSjoerg MVT VT = N.getSimpleValueType();
242606f32e7eSjoerg SDLoc DL(N);
242706f32e7eSjoerg SDValue Zext = CurDAG->getNode(ISD::ZERO_EXTEND, DL, VT, Shl.getOperand(0));
242806f32e7eSjoerg SDValue NewShl = CurDAG->getNode(ISD::SHL, DL, VT, Zext, Shl.getOperand(1));
242906f32e7eSjoerg
243006f32e7eSjoerg // Convert the shift to scale factor.
243106f32e7eSjoerg AM.Scale = 1 << ShAmtC->getZExtValue();
243206f32e7eSjoerg AM.IndexReg = Zext;
243306f32e7eSjoerg
243406f32e7eSjoerg insertDAGNode(*CurDAG, N, Zext);
243506f32e7eSjoerg insertDAGNode(*CurDAG, N, NewShl);
243606f32e7eSjoerg CurDAG->ReplaceAllUsesWith(N, NewShl);
243706f32e7eSjoerg CurDAG->RemoveDeadNode(N.getNode());
243806f32e7eSjoerg return false;
243906f32e7eSjoerg }
244006f32e7eSjoerg }
244106f32e7eSjoerg
244206f32e7eSjoerg return matchAddressBase(N, AM);
244306f32e7eSjoerg }
244406f32e7eSjoerg
244506f32e7eSjoerg /// Helper for MatchAddress. Add the specified node to the
244606f32e7eSjoerg /// specified addressing mode without any further recursion.
matchAddressBase(SDValue N,X86ISelAddressMode & AM)244706f32e7eSjoerg bool X86DAGToDAGISel::matchAddressBase(SDValue N, X86ISelAddressMode &AM) {
244806f32e7eSjoerg // Is the base register already occupied?
244906f32e7eSjoerg if (AM.BaseType != X86ISelAddressMode::RegBase || AM.Base_Reg.getNode()) {
245006f32e7eSjoerg // If so, check to see if the scale index register is set.
245106f32e7eSjoerg if (!AM.IndexReg.getNode()) {
245206f32e7eSjoerg AM.IndexReg = N;
245306f32e7eSjoerg AM.Scale = 1;
245406f32e7eSjoerg return false;
245506f32e7eSjoerg }
245606f32e7eSjoerg
245706f32e7eSjoerg // Otherwise, we cannot select it.
245806f32e7eSjoerg return true;
245906f32e7eSjoerg }
246006f32e7eSjoerg
246106f32e7eSjoerg // Default, generate it as a register.
246206f32e7eSjoerg AM.BaseType = X86ISelAddressMode::RegBase;
246306f32e7eSjoerg AM.Base_Reg = N;
246406f32e7eSjoerg return false;
246506f32e7eSjoerg }
246606f32e7eSjoerg
246706f32e7eSjoerg /// Helper for selectVectorAddr. Handles things that can be folded into a
246806f32e7eSjoerg /// gather scatter address. The index register and scale should have already
246906f32e7eSjoerg /// been handled.
matchVectorAddress(SDValue N,X86ISelAddressMode & AM)247006f32e7eSjoerg bool X86DAGToDAGISel::matchVectorAddress(SDValue N, X86ISelAddressMode &AM) {
247106f32e7eSjoerg // TODO: Support other operations.
247206f32e7eSjoerg switch (N.getOpcode()) {
247306f32e7eSjoerg case ISD::Constant: {
247406f32e7eSjoerg uint64_t Val = cast<ConstantSDNode>(N)->getSExtValue();
247506f32e7eSjoerg if (!foldOffsetIntoAddress(Val, AM))
247606f32e7eSjoerg return false;
247706f32e7eSjoerg break;
247806f32e7eSjoerg }
247906f32e7eSjoerg case X86ISD::Wrapper:
248006f32e7eSjoerg if (!matchWrapper(N, AM))
248106f32e7eSjoerg return false;
248206f32e7eSjoerg break;
248306f32e7eSjoerg }
248406f32e7eSjoerg
248506f32e7eSjoerg return matchAddressBase(N, AM);
248606f32e7eSjoerg }
248706f32e7eSjoerg
selectVectorAddr(MemSDNode * Parent,SDValue BasePtr,SDValue IndexOp,SDValue ScaleOp,SDValue & Base,SDValue & Scale,SDValue & Index,SDValue & Disp,SDValue & Segment)2488*da58b97aSjoerg bool X86DAGToDAGISel::selectVectorAddr(MemSDNode *Parent, SDValue BasePtr,
2489*da58b97aSjoerg SDValue IndexOp, SDValue ScaleOp,
2490*da58b97aSjoerg SDValue &Base, SDValue &Scale,
2491*da58b97aSjoerg SDValue &Index, SDValue &Disp,
2492*da58b97aSjoerg SDValue &Segment) {
249306f32e7eSjoerg X86ISelAddressMode AM;
2494*da58b97aSjoerg AM.IndexReg = IndexOp;
2495*da58b97aSjoerg AM.Scale = cast<ConstantSDNode>(ScaleOp)->getZExtValue();
249606f32e7eSjoerg
2497*da58b97aSjoerg unsigned AddrSpace = Parent->getPointerInfo().getAddrSpace();
2498*da58b97aSjoerg if (AddrSpace == X86AS::GS)
249906f32e7eSjoerg AM.Segment = CurDAG->getRegister(X86::GS, MVT::i16);
2500*da58b97aSjoerg if (AddrSpace == X86AS::FS)
250106f32e7eSjoerg AM.Segment = CurDAG->getRegister(X86::FS, MVT::i16);
2502*da58b97aSjoerg if (AddrSpace == X86AS::SS)
250306f32e7eSjoerg AM.Segment = CurDAG->getRegister(X86::SS, MVT::i16);
250406f32e7eSjoerg
2505*da58b97aSjoerg SDLoc DL(BasePtr);
2506*da58b97aSjoerg MVT VT = BasePtr.getSimpleValueType();
250706f32e7eSjoerg
250806f32e7eSjoerg // Try to match into the base and displacement fields.
2509*da58b97aSjoerg if (matchVectorAddress(BasePtr, AM))
251006f32e7eSjoerg return false;
251106f32e7eSjoerg
251206f32e7eSjoerg getAddressOperands(AM, DL, VT, Base, Scale, Index, Disp, Segment);
251306f32e7eSjoerg return true;
251406f32e7eSjoerg }
251506f32e7eSjoerg
251606f32e7eSjoerg /// Returns true if it is able to pattern match an addressing mode.
251706f32e7eSjoerg /// It returns the operands which make up the maximal addressing mode it can
251806f32e7eSjoerg /// match by reference.
251906f32e7eSjoerg ///
252006f32e7eSjoerg /// Parent is the parent node of the addr operand that is being matched. It
252106f32e7eSjoerg /// is always a load, store, atomic node, or null. It is only null when
252206f32e7eSjoerg /// checking memory operands for inline asm nodes.
selectAddr(SDNode * Parent,SDValue N,SDValue & Base,SDValue & Scale,SDValue & Index,SDValue & Disp,SDValue & Segment)252306f32e7eSjoerg bool X86DAGToDAGISel::selectAddr(SDNode *Parent, SDValue N, SDValue &Base,
252406f32e7eSjoerg SDValue &Scale, SDValue &Index,
252506f32e7eSjoerg SDValue &Disp, SDValue &Segment) {
252606f32e7eSjoerg X86ISelAddressMode AM;
252706f32e7eSjoerg
252806f32e7eSjoerg if (Parent &&
252906f32e7eSjoerg // This list of opcodes are all the nodes that have an "addr:$ptr" operand
253006f32e7eSjoerg // that are not a MemSDNode, and thus don't have proper addrspace info.
253106f32e7eSjoerg Parent->getOpcode() != ISD::INTRINSIC_W_CHAIN && // unaligned loads, fixme
253206f32e7eSjoerg Parent->getOpcode() != ISD::INTRINSIC_VOID && // nontemporal stores
253306f32e7eSjoerg Parent->getOpcode() != X86ISD::TLSCALL && // Fixme
253406f32e7eSjoerg Parent->getOpcode() != X86ISD::ENQCMD && // Fixme
253506f32e7eSjoerg Parent->getOpcode() != X86ISD::ENQCMDS && // Fixme
253606f32e7eSjoerg Parent->getOpcode() != X86ISD::EH_SJLJ_SETJMP && // setjmp
253706f32e7eSjoerg Parent->getOpcode() != X86ISD::EH_SJLJ_LONGJMP) { // longjmp
253806f32e7eSjoerg unsigned AddrSpace =
253906f32e7eSjoerg cast<MemSDNode>(Parent)->getPointerInfo().getAddrSpace();
2540*da58b97aSjoerg if (AddrSpace == X86AS::GS)
254106f32e7eSjoerg AM.Segment = CurDAG->getRegister(X86::GS, MVT::i16);
2542*da58b97aSjoerg if (AddrSpace == X86AS::FS)
254306f32e7eSjoerg AM.Segment = CurDAG->getRegister(X86::FS, MVT::i16);
2544*da58b97aSjoerg if (AddrSpace == X86AS::SS)
254506f32e7eSjoerg AM.Segment = CurDAG->getRegister(X86::SS, MVT::i16);
254606f32e7eSjoerg }
254706f32e7eSjoerg
254806f32e7eSjoerg // Save the DL and VT before calling matchAddress, it can invalidate N.
254906f32e7eSjoerg SDLoc DL(N);
255006f32e7eSjoerg MVT VT = N.getSimpleValueType();
255106f32e7eSjoerg
255206f32e7eSjoerg if (matchAddress(N, AM))
255306f32e7eSjoerg return false;
255406f32e7eSjoerg
255506f32e7eSjoerg getAddressOperands(AM, DL, VT, Base, Scale, Index, Disp, Segment);
255606f32e7eSjoerg return true;
255706f32e7eSjoerg }
255806f32e7eSjoerg
selectMOV64Imm32(SDValue N,SDValue & Imm)255906f32e7eSjoerg bool X86DAGToDAGISel::selectMOV64Imm32(SDValue N, SDValue &Imm) {
256006f32e7eSjoerg // In static codegen with small code model, we can get the address of a label
256106f32e7eSjoerg // into a register with 'movl'
256206f32e7eSjoerg if (N->getOpcode() != X86ISD::Wrapper)
256306f32e7eSjoerg return false;
256406f32e7eSjoerg
256506f32e7eSjoerg N = N.getOperand(0);
256606f32e7eSjoerg
256706f32e7eSjoerg // At least GNU as does not accept 'movl' for TPOFF relocations.
256806f32e7eSjoerg // FIXME: We could use 'movl' when we know we are targeting MC.
256906f32e7eSjoerg if (N->getOpcode() == ISD::TargetGlobalTLSAddress)
257006f32e7eSjoerg return false;
257106f32e7eSjoerg
257206f32e7eSjoerg Imm = N;
257306f32e7eSjoerg if (N->getOpcode() != ISD::TargetGlobalAddress)
257406f32e7eSjoerg return TM.getCodeModel() == CodeModel::Small;
257506f32e7eSjoerg
257606f32e7eSjoerg Optional<ConstantRange> CR =
257706f32e7eSjoerg cast<GlobalAddressSDNode>(N)->getGlobal()->getAbsoluteSymbolRange();
257806f32e7eSjoerg if (!CR)
257906f32e7eSjoerg return TM.getCodeModel() == CodeModel::Small;
258006f32e7eSjoerg
258106f32e7eSjoerg return CR->getUnsignedMax().ult(1ull << 32);
258206f32e7eSjoerg }
258306f32e7eSjoerg
selectLEA64_32Addr(SDValue N,SDValue & Base,SDValue & Scale,SDValue & Index,SDValue & Disp,SDValue & Segment)258406f32e7eSjoerg bool X86DAGToDAGISel::selectLEA64_32Addr(SDValue N, SDValue &Base,
258506f32e7eSjoerg SDValue &Scale, SDValue &Index,
258606f32e7eSjoerg SDValue &Disp, SDValue &Segment) {
258706f32e7eSjoerg // Save the debug loc before calling selectLEAAddr, in case it invalidates N.
258806f32e7eSjoerg SDLoc DL(N);
258906f32e7eSjoerg
259006f32e7eSjoerg if (!selectLEAAddr(N, Base, Scale, Index, Disp, Segment))
259106f32e7eSjoerg return false;
259206f32e7eSjoerg
259306f32e7eSjoerg RegisterSDNode *RN = dyn_cast<RegisterSDNode>(Base);
259406f32e7eSjoerg if (RN && RN->getReg() == 0)
259506f32e7eSjoerg Base = CurDAG->getRegister(0, MVT::i64);
259606f32e7eSjoerg else if (Base.getValueType() == MVT::i32 && !isa<FrameIndexSDNode>(Base)) {
259706f32e7eSjoerg // Base could already be %rip, particularly in the x32 ABI.
259806f32e7eSjoerg SDValue ImplDef = SDValue(CurDAG->getMachineNode(X86::IMPLICIT_DEF, DL,
259906f32e7eSjoerg MVT::i64), 0);
260006f32e7eSjoerg Base = CurDAG->getTargetInsertSubreg(X86::sub_32bit, DL, MVT::i64, ImplDef,
260106f32e7eSjoerg Base);
260206f32e7eSjoerg }
260306f32e7eSjoerg
260406f32e7eSjoerg RN = dyn_cast<RegisterSDNode>(Index);
260506f32e7eSjoerg if (RN && RN->getReg() == 0)
260606f32e7eSjoerg Index = CurDAG->getRegister(0, MVT::i64);
260706f32e7eSjoerg else {
260806f32e7eSjoerg assert(Index.getValueType() == MVT::i32 &&
260906f32e7eSjoerg "Expect to be extending 32-bit registers for use in LEA");
261006f32e7eSjoerg SDValue ImplDef = SDValue(CurDAG->getMachineNode(X86::IMPLICIT_DEF, DL,
261106f32e7eSjoerg MVT::i64), 0);
261206f32e7eSjoerg Index = CurDAG->getTargetInsertSubreg(X86::sub_32bit, DL, MVT::i64, ImplDef,
261306f32e7eSjoerg Index);
261406f32e7eSjoerg }
261506f32e7eSjoerg
261606f32e7eSjoerg return true;
261706f32e7eSjoerg }
261806f32e7eSjoerg
261906f32e7eSjoerg /// Calls SelectAddr and determines if the maximal addressing
262006f32e7eSjoerg /// mode it matches can be cost effectively emitted as an LEA instruction.
selectLEAAddr(SDValue N,SDValue & Base,SDValue & Scale,SDValue & Index,SDValue & Disp,SDValue & Segment)262106f32e7eSjoerg bool X86DAGToDAGISel::selectLEAAddr(SDValue N,
262206f32e7eSjoerg SDValue &Base, SDValue &Scale,
262306f32e7eSjoerg SDValue &Index, SDValue &Disp,
262406f32e7eSjoerg SDValue &Segment) {
262506f32e7eSjoerg X86ISelAddressMode AM;
262606f32e7eSjoerg
262706f32e7eSjoerg // Save the DL and VT before calling matchAddress, it can invalidate N.
262806f32e7eSjoerg SDLoc DL(N);
262906f32e7eSjoerg MVT VT = N.getSimpleValueType();
263006f32e7eSjoerg
263106f32e7eSjoerg // Set AM.Segment to prevent MatchAddress from using one. LEA doesn't support
263206f32e7eSjoerg // segments.
263306f32e7eSjoerg SDValue Copy = AM.Segment;
263406f32e7eSjoerg SDValue T = CurDAG->getRegister(0, MVT::i32);
263506f32e7eSjoerg AM.Segment = T;
263606f32e7eSjoerg if (matchAddress(N, AM))
263706f32e7eSjoerg return false;
263806f32e7eSjoerg assert (T == AM.Segment);
263906f32e7eSjoerg AM.Segment = Copy;
264006f32e7eSjoerg
264106f32e7eSjoerg unsigned Complexity = 0;
264206f32e7eSjoerg if (AM.BaseType == X86ISelAddressMode::RegBase && AM.Base_Reg.getNode())
264306f32e7eSjoerg Complexity = 1;
264406f32e7eSjoerg else if (AM.BaseType == X86ISelAddressMode::FrameIndexBase)
264506f32e7eSjoerg Complexity = 4;
264606f32e7eSjoerg
264706f32e7eSjoerg if (AM.IndexReg.getNode())
264806f32e7eSjoerg Complexity++;
264906f32e7eSjoerg
265006f32e7eSjoerg // Don't match just leal(,%reg,2). It's cheaper to do addl %reg, %reg, or with
265106f32e7eSjoerg // a simple shift.
265206f32e7eSjoerg if (AM.Scale > 1)
265306f32e7eSjoerg Complexity++;
265406f32e7eSjoerg
265506f32e7eSjoerg // FIXME: We are artificially lowering the criteria to turn ADD %reg, $GA
265606f32e7eSjoerg // to a LEA. This is determined with some experimentation but is by no means
265706f32e7eSjoerg // optimal (especially for code size consideration). LEA is nice because of
265806f32e7eSjoerg // its three-address nature. Tweak the cost function again when we can run
265906f32e7eSjoerg // convertToThreeAddress() at register allocation time.
266006f32e7eSjoerg if (AM.hasSymbolicDisplacement()) {
266106f32e7eSjoerg // For X86-64, always use LEA to materialize RIP-relative addresses.
266206f32e7eSjoerg if (Subtarget->is64Bit())
266306f32e7eSjoerg Complexity = 4;
266406f32e7eSjoerg else
266506f32e7eSjoerg Complexity += 2;
266606f32e7eSjoerg }
266706f32e7eSjoerg
266806f32e7eSjoerg // Heuristic: try harder to form an LEA from ADD if the operands set flags.
266906f32e7eSjoerg // Unlike ADD, LEA does not affect flags, so we will be less likely to require
267006f32e7eSjoerg // duplicating flag-producing instructions later in the pipeline.
267106f32e7eSjoerg if (N.getOpcode() == ISD::ADD) {
267206f32e7eSjoerg auto isMathWithFlags = [](SDValue V) {
267306f32e7eSjoerg switch (V.getOpcode()) {
267406f32e7eSjoerg case X86ISD::ADD:
267506f32e7eSjoerg case X86ISD::SUB:
267606f32e7eSjoerg case X86ISD::ADC:
267706f32e7eSjoerg case X86ISD::SBB:
267806f32e7eSjoerg /* TODO: These opcodes can be added safely, but we may want to justify
267906f32e7eSjoerg their inclusion for different reasons (better for reg-alloc).
268006f32e7eSjoerg case X86ISD::SMUL:
268106f32e7eSjoerg case X86ISD::UMUL:
268206f32e7eSjoerg case X86ISD::OR:
268306f32e7eSjoerg case X86ISD::XOR:
268406f32e7eSjoerg case X86ISD::AND:
268506f32e7eSjoerg */
268606f32e7eSjoerg // Value 1 is the flag output of the node - verify it's not dead.
268706f32e7eSjoerg return !SDValue(V.getNode(), 1).use_empty();
268806f32e7eSjoerg default:
268906f32e7eSjoerg return false;
269006f32e7eSjoerg }
269106f32e7eSjoerg };
269206f32e7eSjoerg // TODO: This could be an 'or' rather than 'and' to make the transform more
269306f32e7eSjoerg // likely to happen. We might want to factor in whether there's a
269406f32e7eSjoerg // load folding opportunity for the math op that disappears with LEA.
269506f32e7eSjoerg if (isMathWithFlags(N.getOperand(0)) && isMathWithFlags(N.getOperand(1)))
269606f32e7eSjoerg Complexity++;
269706f32e7eSjoerg }
269806f32e7eSjoerg
269906f32e7eSjoerg if (AM.Disp)
270006f32e7eSjoerg Complexity++;
270106f32e7eSjoerg
270206f32e7eSjoerg // If it isn't worth using an LEA, reject it.
270306f32e7eSjoerg if (Complexity <= 2)
270406f32e7eSjoerg return false;
270506f32e7eSjoerg
270606f32e7eSjoerg getAddressOperands(AM, DL, VT, Base, Scale, Index, Disp, Segment);
270706f32e7eSjoerg return true;
270806f32e7eSjoerg }
270906f32e7eSjoerg
271006f32e7eSjoerg /// This is only run on TargetGlobalTLSAddress nodes.
selectTLSADDRAddr(SDValue N,SDValue & Base,SDValue & Scale,SDValue & Index,SDValue & Disp,SDValue & Segment)271106f32e7eSjoerg bool X86DAGToDAGISel::selectTLSADDRAddr(SDValue N, SDValue &Base,
271206f32e7eSjoerg SDValue &Scale, SDValue &Index,
271306f32e7eSjoerg SDValue &Disp, SDValue &Segment) {
271406f32e7eSjoerg assert(N.getOpcode() == ISD::TargetGlobalTLSAddress);
271506f32e7eSjoerg const GlobalAddressSDNode *GA = cast<GlobalAddressSDNode>(N);
271606f32e7eSjoerg
271706f32e7eSjoerg X86ISelAddressMode AM;
271806f32e7eSjoerg AM.GV = GA->getGlobal();
271906f32e7eSjoerg AM.Disp += GA->getOffset();
272006f32e7eSjoerg AM.SymbolFlags = GA->getTargetFlags();
272106f32e7eSjoerg
2722*da58b97aSjoerg if (Subtarget->is32Bit()) {
272306f32e7eSjoerg AM.Scale = 1;
272406f32e7eSjoerg AM.IndexReg = CurDAG->getRegister(X86::EBX, MVT::i32);
272506f32e7eSjoerg }
272606f32e7eSjoerg
2727*da58b97aSjoerg MVT VT = N.getSimpleValueType();
272806f32e7eSjoerg getAddressOperands(AM, SDLoc(N), VT, Base, Scale, Index, Disp, Segment);
272906f32e7eSjoerg return true;
273006f32e7eSjoerg }
273106f32e7eSjoerg
selectRelocImm(SDValue N,SDValue & Op)273206f32e7eSjoerg bool X86DAGToDAGISel::selectRelocImm(SDValue N, SDValue &Op) {
273306f32e7eSjoerg // Keep track of the original value type and whether this value was
273406f32e7eSjoerg // truncated. If we see a truncation from pointer type to VT that truncates
273506f32e7eSjoerg // bits that are known to be zero, we can use a narrow reference.
273606f32e7eSjoerg EVT VT = N.getValueType();
273706f32e7eSjoerg bool WasTruncated = false;
273806f32e7eSjoerg if (N.getOpcode() == ISD::TRUNCATE) {
273906f32e7eSjoerg WasTruncated = true;
274006f32e7eSjoerg N = N.getOperand(0);
274106f32e7eSjoerg }
274206f32e7eSjoerg
274306f32e7eSjoerg if (N.getOpcode() != X86ISD::Wrapper)
274406f32e7eSjoerg return false;
274506f32e7eSjoerg
274606f32e7eSjoerg // We can only use non-GlobalValues as immediates if they were not truncated,
274706f32e7eSjoerg // as we do not have any range information. If we have a GlobalValue and the
274806f32e7eSjoerg // address was not truncated, we can select it as an operand directly.
274906f32e7eSjoerg unsigned Opc = N.getOperand(0)->getOpcode();
275006f32e7eSjoerg if (Opc != ISD::TargetGlobalAddress || !WasTruncated) {
275106f32e7eSjoerg Op = N.getOperand(0);
275206f32e7eSjoerg // We can only select the operand directly if we didn't have to look past a
275306f32e7eSjoerg // truncate.
275406f32e7eSjoerg return !WasTruncated;
275506f32e7eSjoerg }
275606f32e7eSjoerg
275706f32e7eSjoerg // Check that the global's range fits into VT.
275806f32e7eSjoerg auto *GA = cast<GlobalAddressSDNode>(N.getOperand(0));
275906f32e7eSjoerg Optional<ConstantRange> CR = GA->getGlobal()->getAbsoluteSymbolRange();
276006f32e7eSjoerg if (!CR || CR->getUnsignedMax().uge(1ull << VT.getSizeInBits()))
276106f32e7eSjoerg return false;
276206f32e7eSjoerg
276306f32e7eSjoerg // Okay, we can use a narrow reference.
276406f32e7eSjoerg Op = CurDAG->getTargetGlobalAddress(GA->getGlobal(), SDLoc(N), VT,
276506f32e7eSjoerg GA->getOffset(), GA->getTargetFlags());
276606f32e7eSjoerg return true;
276706f32e7eSjoerg }
276806f32e7eSjoerg
tryFoldLoad(SDNode * Root,SDNode * P,SDValue N,SDValue & Base,SDValue & Scale,SDValue & Index,SDValue & Disp,SDValue & Segment)276906f32e7eSjoerg bool X86DAGToDAGISel::tryFoldLoad(SDNode *Root, SDNode *P, SDValue N,
277006f32e7eSjoerg SDValue &Base, SDValue &Scale,
277106f32e7eSjoerg SDValue &Index, SDValue &Disp,
277206f32e7eSjoerg SDValue &Segment) {
277306f32e7eSjoerg assert(Root && P && "Unknown root/parent nodes");
277406f32e7eSjoerg if (!ISD::isNON_EXTLoad(N.getNode()) ||
277506f32e7eSjoerg !IsProfitableToFold(N, P, Root) ||
277606f32e7eSjoerg !IsLegalToFold(N, P, Root, OptLevel))
277706f32e7eSjoerg return false;
277806f32e7eSjoerg
277906f32e7eSjoerg return selectAddr(N.getNode(),
278006f32e7eSjoerg N.getOperand(1), Base, Scale, Index, Disp, Segment);
278106f32e7eSjoerg }
278206f32e7eSjoerg
tryFoldBroadcast(SDNode * Root,SDNode * P,SDValue N,SDValue & Base,SDValue & Scale,SDValue & Index,SDValue & Disp,SDValue & Segment)278306f32e7eSjoerg bool X86DAGToDAGISel::tryFoldBroadcast(SDNode *Root, SDNode *P, SDValue N,
278406f32e7eSjoerg SDValue &Base, SDValue &Scale,
278506f32e7eSjoerg SDValue &Index, SDValue &Disp,
278606f32e7eSjoerg SDValue &Segment) {
278706f32e7eSjoerg assert(Root && P && "Unknown root/parent nodes");
278806f32e7eSjoerg if (N->getOpcode() != X86ISD::VBROADCAST_LOAD ||
278906f32e7eSjoerg !IsProfitableToFold(N, P, Root) ||
279006f32e7eSjoerg !IsLegalToFold(N, P, Root, OptLevel))
279106f32e7eSjoerg return false;
279206f32e7eSjoerg
279306f32e7eSjoerg return selectAddr(N.getNode(),
279406f32e7eSjoerg N.getOperand(1), Base, Scale, Index, Disp, Segment);
279506f32e7eSjoerg }
279606f32e7eSjoerg
279706f32e7eSjoerg /// Return an SDNode that returns the value of the global base register.
279806f32e7eSjoerg /// Output instructions required to initialize the global base register,
279906f32e7eSjoerg /// if necessary.
getGlobalBaseReg()280006f32e7eSjoerg SDNode *X86DAGToDAGISel::getGlobalBaseReg() {
280106f32e7eSjoerg unsigned GlobalBaseReg = getInstrInfo()->getGlobalBaseReg(MF);
280206f32e7eSjoerg auto &DL = MF->getDataLayout();
280306f32e7eSjoerg return CurDAG->getRegister(GlobalBaseReg, TLI->getPointerTy(DL)).getNode();
280406f32e7eSjoerg }
280506f32e7eSjoerg
isSExtAbsoluteSymbolRef(unsigned Width,SDNode * N) const280606f32e7eSjoerg bool X86DAGToDAGISel::isSExtAbsoluteSymbolRef(unsigned Width, SDNode *N) const {
280706f32e7eSjoerg if (N->getOpcode() == ISD::TRUNCATE)
280806f32e7eSjoerg N = N->getOperand(0).getNode();
280906f32e7eSjoerg if (N->getOpcode() != X86ISD::Wrapper)
281006f32e7eSjoerg return false;
281106f32e7eSjoerg
281206f32e7eSjoerg auto *GA = dyn_cast<GlobalAddressSDNode>(N->getOperand(0));
281306f32e7eSjoerg if (!GA)
281406f32e7eSjoerg return false;
281506f32e7eSjoerg
281606f32e7eSjoerg Optional<ConstantRange> CR = GA->getGlobal()->getAbsoluteSymbolRange();
2817*da58b97aSjoerg if (!CR)
2818*da58b97aSjoerg return Width == 32 && TM.getCodeModel() == CodeModel::Small;
2819*da58b97aSjoerg
2820*da58b97aSjoerg return CR->getSignedMin().sge(-1ull << Width) &&
282106f32e7eSjoerg CR->getSignedMax().slt(1ull << Width);
282206f32e7eSjoerg }
282306f32e7eSjoerg
getCondFromNode(SDNode * N)282406f32e7eSjoerg static X86::CondCode getCondFromNode(SDNode *N) {
282506f32e7eSjoerg assert(N->isMachineOpcode() && "Unexpected node");
282606f32e7eSjoerg X86::CondCode CC = X86::COND_INVALID;
282706f32e7eSjoerg unsigned Opc = N->getMachineOpcode();
282806f32e7eSjoerg if (Opc == X86::JCC_1)
282906f32e7eSjoerg CC = static_cast<X86::CondCode>(N->getConstantOperandVal(1));
283006f32e7eSjoerg else if (Opc == X86::SETCCr)
283106f32e7eSjoerg CC = static_cast<X86::CondCode>(N->getConstantOperandVal(0));
283206f32e7eSjoerg else if (Opc == X86::SETCCm)
283306f32e7eSjoerg CC = static_cast<X86::CondCode>(N->getConstantOperandVal(5));
283406f32e7eSjoerg else if (Opc == X86::CMOV16rr || Opc == X86::CMOV32rr ||
283506f32e7eSjoerg Opc == X86::CMOV64rr)
283606f32e7eSjoerg CC = static_cast<X86::CondCode>(N->getConstantOperandVal(2));
283706f32e7eSjoerg else if (Opc == X86::CMOV16rm || Opc == X86::CMOV32rm ||
283806f32e7eSjoerg Opc == X86::CMOV64rm)
283906f32e7eSjoerg CC = static_cast<X86::CondCode>(N->getConstantOperandVal(6));
284006f32e7eSjoerg
284106f32e7eSjoerg return CC;
284206f32e7eSjoerg }
284306f32e7eSjoerg
284406f32e7eSjoerg /// Test whether the given X86ISD::CMP node has any users that use a flag
284506f32e7eSjoerg /// other than ZF.
onlyUsesZeroFlag(SDValue Flags) const284606f32e7eSjoerg bool X86DAGToDAGISel::onlyUsesZeroFlag(SDValue Flags) const {
284706f32e7eSjoerg // Examine each user of the node.
284806f32e7eSjoerg for (SDNode::use_iterator UI = Flags->use_begin(), UE = Flags->use_end();
284906f32e7eSjoerg UI != UE; ++UI) {
285006f32e7eSjoerg // Only check things that use the flags.
285106f32e7eSjoerg if (UI.getUse().getResNo() != Flags.getResNo())
285206f32e7eSjoerg continue;
285306f32e7eSjoerg // Only examine CopyToReg uses that copy to EFLAGS.
285406f32e7eSjoerg if (UI->getOpcode() != ISD::CopyToReg ||
285506f32e7eSjoerg cast<RegisterSDNode>(UI->getOperand(1))->getReg() != X86::EFLAGS)
285606f32e7eSjoerg return false;
285706f32e7eSjoerg // Examine each user of the CopyToReg use.
285806f32e7eSjoerg for (SDNode::use_iterator FlagUI = UI->use_begin(),
285906f32e7eSjoerg FlagUE = UI->use_end(); FlagUI != FlagUE; ++FlagUI) {
286006f32e7eSjoerg // Only examine the Flag result.
286106f32e7eSjoerg if (FlagUI.getUse().getResNo() != 1) continue;
286206f32e7eSjoerg // Anything unusual: assume conservatively.
286306f32e7eSjoerg if (!FlagUI->isMachineOpcode()) return false;
286406f32e7eSjoerg // Examine the condition code of the user.
286506f32e7eSjoerg X86::CondCode CC = getCondFromNode(*FlagUI);
286606f32e7eSjoerg
286706f32e7eSjoerg switch (CC) {
286806f32e7eSjoerg // Comparisons which only use the zero flag.
286906f32e7eSjoerg case X86::COND_E: case X86::COND_NE:
287006f32e7eSjoerg continue;
287106f32e7eSjoerg // Anything else: assume conservatively.
287206f32e7eSjoerg default:
287306f32e7eSjoerg return false;
287406f32e7eSjoerg }
287506f32e7eSjoerg }
287606f32e7eSjoerg }
287706f32e7eSjoerg return true;
287806f32e7eSjoerg }
287906f32e7eSjoerg
288006f32e7eSjoerg /// Test whether the given X86ISD::CMP node has any uses which require the SF
288106f32e7eSjoerg /// flag to be accurate.
hasNoSignFlagUses(SDValue Flags) const288206f32e7eSjoerg bool X86DAGToDAGISel::hasNoSignFlagUses(SDValue Flags) const {
288306f32e7eSjoerg // Examine each user of the node.
288406f32e7eSjoerg for (SDNode::use_iterator UI = Flags->use_begin(), UE = Flags->use_end();
288506f32e7eSjoerg UI != UE; ++UI) {
288606f32e7eSjoerg // Only check things that use the flags.
288706f32e7eSjoerg if (UI.getUse().getResNo() != Flags.getResNo())
288806f32e7eSjoerg continue;
288906f32e7eSjoerg // Only examine CopyToReg uses that copy to EFLAGS.
289006f32e7eSjoerg if (UI->getOpcode() != ISD::CopyToReg ||
289106f32e7eSjoerg cast<RegisterSDNode>(UI->getOperand(1))->getReg() != X86::EFLAGS)
289206f32e7eSjoerg return false;
289306f32e7eSjoerg // Examine each user of the CopyToReg use.
289406f32e7eSjoerg for (SDNode::use_iterator FlagUI = UI->use_begin(),
289506f32e7eSjoerg FlagUE = UI->use_end(); FlagUI != FlagUE; ++FlagUI) {
289606f32e7eSjoerg // Only examine the Flag result.
289706f32e7eSjoerg if (FlagUI.getUse().getResNo() != 1) continue;
289806f32e7eSjoerg // Anything unusual: assume conservatively.
289906f32e7eSjoerg if (!FlagUI->isMachineOpcode()) return false;
290006f32e7eSjoerg // Examine the condition code of the user.
290106f32e7eSjoerg X86::CondCode CC = getCondFromNode(*FlagUI);
290206f32e7eSjoerg
290306f32e7eSjoerg switch (CC) {
290406f32e7eSjoerg // Comparisons which don't examine the SF flag.
290506f32e7eSjoerg case X86::COND_A: case X86::COND_AE:
290606f32e7eSjoerg case X86::COND_B: case X86::COND_BE:
290706f32e7eSjoerg case X86::COND_E: case X86::COND_NE:
290806f32e7eSjoerg case X86::COND_O: case X86::COND_NO:
290906f32e7eSjoerg case X86::COND_P: case X86::COND_NP:
291006f32e7eSjoerg continue;
291106f32e7eSjoerg // Anything else: assume conservatively.
291206f32e7eSjoerg default:
291306f32e7eSjoerg return false;
291406f32e7eSjoerg }
291506f32e7eSjoerg }
291606f32e7eSjoerg }
291706f32e7eSjoerg return true;
291806f32e7eSjoerg }
291906f32e7eSjoerg
mayUseCarryFlag(X86::CondCode CC)292006f32e7eSjoerg static bool mayUseCarryFlag(X86::CondCode CC) {
292106f32e7eSjoerg switch (CC) {
292206f32e7eSjoerg // Comparisons which don't examine the CF flag.
292306f32e7eSjoerg case X86::COND_O: case X86::COND_NO:
292406f32e7eSjoerg case X86::COND_E: case X86::COND_NE:
292506f32e7eSjoerg case X86::COND_S: case X86::COND_NS:
292606f32e7eSjoerg case X86::COND_P: case X86::COND_NP:
292706f32e7eSjoerg case X86::COND_L: case X86::COND_GE:
292806f32e7eSjoerg case X86::COND_G: case X86::COND_LE:
292906f32e7eSjoerg return false;
293006f32e7eSjoerg // Anything else: assume conservatively.
293106f32e7eSjoerg default:
293206f32e7eSjoerg return true;
293306f32e7eSjoerg }
293406f32e7eSjoerg }
293506f32e7eSjoerg
293606f32e7eSjoerg /// Test whether the given node which sets flags has any uses which require the
293706f32e7eSjoerg /// CF flag to be accurate.
hasNoCarryFlagUses(SDValue Flags) const293806f32e7eSjoerg bool X86DAGToDAGISel::hasNoCarryFlagUses(SDValue Flags) const {
293906f32e7eSjoerg // Examine each user of the node.
294006f32e7eSjoerg for (SDNode::use_iterator UI = Flags->use_begin(), UE = Flags->use_end();
294106f32e7eSjoerg UI != UE; ++UI) {
294206f32e7eSjoerg // Only check things that use the flags.
294306f32e7eSjoerg if (UI.getUse().getResNo() != Flags.getResNo())
294406f32e7eSjoerg continue;
294506f32e7eSjoerg
294606f32e7eSjoerg unsigned UIOpc = UI->getOpcode();
294706f32e7eSjoerg
294806f32e7eSjoerg if (UIOpc == ISD::CopyToReg) {
294906f32e7eSjoerg // Only examine CopyToReg uses that copy to EFLAGS.
295006f32e7eSjoerg if (cast<RegisterSDNode>(UI->getOperand(1))->getReg() != X86::EFLAGS)
295106f32e7eSjoerg return false;
295206f32e7eSjoerg // Examine each user of the CopyToReg use.
295306f32e7eSjoerg for (SDNode::use_iterator FlagUI = UI->use_begin(), FlagUE = UI->use_end();
295406f32e7eSjoerg FlagUI != FlagUE; ++FlagUI) {
295506f32e7eSjoerg // Only examine the Flag result.
295606f32e7eSjoerg if (FlagUI.getUse().getResNo() != 1)
295706f32e7eSjoerg continue;
295806f32e7eSjoerg // Anything unusual: assume conservatively.
295906f32e7eSjoerg if (!FlagUI->isMachineOpcode())
296006f32e7eSjoerg return false;
296106f32e7eSjoerg // Examine the condition code of the user.
296206f32e7eSjoerg X86::CondCode CC = getCondFromNode(*FlagUI);
296306f32e7eSjoerg
296406f32e7eSjoerg if (mayUseCarryFlag(CC))
296506f32e7eSjoerg return false;
296606f32e7eSjoerg }
296706f32e7eSjoerg
296806f32e7eSjoerg // This CopyToReg is ok. Move on to the next user.
296906f32e7eSjoerg continue;
297006f32e7eSjoerg }
297106f32e7eSjoerg
297206f32e7eSjoerg // This might be an unselected node. So look for the pre-isel opcodes that
297306f32e7eSjoerg // use flags.
297406f32e7eSjoerg unsigned CCOpNo;
297506f32e7eSjoerg switch (UIOpc) {
297606f32e7eSjoerg default:
297706f32e7eSjoerg // Something unusual. Be conservative.
297806f32e7eSjoerg return false;
297906f32e7eSjoerg case X86ISD::SETCC: CCOpNo = 0; break;
298006f32e7eSjoerg case X86ISD::SETCC_CARRY: CCOpNo = 0; break;
298106f32e7eSjoerg case X86ISD::CMOV: CCOpNo = 2; break;
298206f32e7eSjoerg case X86ISD::BRCOND: CCOpNo = 2; break;
298306f32e7eSjoerg }
298406f32e7eSjoerg
298506f32e7eSjoerg X86::CondCode CC = (X86::CondCode)UI->getConstantOperandVal(CCOpNo);
298606f32e7eSjoerg if (mayUseCarryFlag(CC))
298706f32e7eSjoerg return false;
298806f32e7eSjoerg }
298906f32e7eSjoerg return true;
299006f32e7eSjoerg }
299106f32e7eSjoerg
299206f32e7eSjoerg /// Check whether or not the chain ending in StoreNode is suitable for doing
299306f32e7eSjoerg /// the {load; op; store} to modify transformation.
isFusableLoadOpStorePattern(StoreSDNode * StoreNode,SDValue StoredVal,SelectionDAG * CurDAG,unsigned LoadOpNo,LoadSDNode * & LoadNode,SDValue & InputChain)299406f32e7eSjoerg static bool isFusableLoadOpStorePattern(StoreSDNode *StoreNode,
299506f32e7eSjoerg SDValue StoredVal, SelectionDAG *CurDAG,
299606f32e7eSjoerg unsigned LoadOpNo,
299706f32e7eSjoerg LoadSDNode *&LoadNode,
299806f32e7eSjoerg SDValue &InputChain) {
299906f32e7eSjoerg // Is the stored value result 0 of the operation?
300006f32e7eSjoerg if (StoredVal.getResNo() != 0) return false;
300106f32e7eSjoerg
300206f32e7eSjoerg // Are there other uses of the operation other than the store?
300306f32e7eSjoerg if (!StoredVal.getNode()->hasNUsesOfValue(1, 0)) return false;
300406f32e7eSjoerg
300506f32e7eSjoerg // Is the store non-extending and non-indexed?
300606f32e7eSjoerg if (!ISD::isNormalStore(StoreNode) || StoreNode->isNonTemporal())
300706f32e7eSjoerg return false;
300806f32e7eSjoerg
300906f32e7eSjoerg SDValue Load = StoredVal->getOperand(LoadOpNo);
301006f32e7eSjoerg // Is the stored value a non-extending and non-indexed load?
301106f32e7eSjoerg if (!ISD::isNormalLoad(Load.getNode())) return false;
301206f32e7eSjoerg
301306f32e7eSjoerg // Return LoadNode by reference.
301406f32e7eSjoerg LoadNode = cast<LoadSDNode>(Load);
301506f32e7eSjoerg
301606f32e7eSjoerg // Is store the only read of the loaded value?
301706f32e7eSjoerg if (!Load.hasOneUse())
301806f32e7eSjoerg return false;
301906f32e7eSjoerg
302006f32e7eSjoerg // Is the address of the store the same as the load?
302106f32e7eSjoerg if (LoadNode->getBasePtr() != StoreNode->getBasePtr() ||
302206f32e7eSjoerg LoadNode->getOffset() != StoreNode->getOffset())
302306f32e7eSjoerg return false;
302406f32e7eSjoerg
302506f32e7eSjoerg bool FoundLoad = false;
302606f32e7eSjoerg SmallVector<SDValue, 4> ChainOps;
302706f32e7eSjoerg SmallVector<const SDNode *, 4> LoopWorklist;
302806f32e7eSjoerg SmallPtrSet<const SDNode *, 16> Visited;
302906f32e7eSjoerg const unsigned int Max = 1024;
303006f32e7eSjoerg
303106f32e7eSjoerg // Visualization of Load-Op-Store fusion:
303206f32e7eSjoerg // -------------------------
303306f32e7eSjoerg // Legend:
303406f32e7eSjoerg // *-lines = Chain operand dependencies.
303506f32e7eSjoerg // |-lines = Normal operand dependencies.
303606f32e7eSjoerg // Dependencies flow down and right. n-suffix references multiple nodes.
303706f32e7eSjoerg //
303806f32e7eSjoerg // C Xn C
303906f32e7eSjoerg // * * *
304006f32e7eSjoerg // * * *
304106f32e7eSjoerg // Xn A-LD Yn TF Yn
304206f32e7eSjoerg // * * \ | * |
304306f32e7eSjoerg // * * \ | * |
304406f32e7eSjoerg // * * \ | => A--LD_OP_ST
304506f32e7eSjoerg // * * \| \
304606f32e7eSjoerg // TF OP \
304706f32e7eSjoerg // * | \ Zn
304806f32e7eSjoerg // * | \
304906f32e7eSjoerg // A-ST Zn
305006f32e7eSjoerg //
305106f32e7eSjoerg
305206f32e7eSjoerg // This merge induced dependences from: #1: Xn -> LD, OP, Zn
305306f32e7eSjoerg // #2: Yn -> LD
305406f32e7eSjoerg // #3: ST -> Zn
305506f32e7eSjoerg
305606f32e7eSjoerg // Ensure the transform is safe by checking for the dual
305706f32e7eSjoerg // dependencies to make sure we do not induce a loop.
305806f32e7eSjoerg
305906f32e7eSjoerg // As LD is a predecessor to both OP and ST we can do this by checking:
306006f32e7eSjoerg // a). if LD is a predecessor to a member of Xn or Yn.
306106f32e7eSjoerg // b). if a Zn is a predecessor to ST.
306206f32e7eSjoerg
306306f32e7eSjoerg // However, (b) can only occur through being a chain predecessor to
306406f32e7eSjoerg // ST, which is the same as Zn being a member or predecessor of Xn,
306506f32e7eSjoerg // which is a subset of LD being a predecessor of Xn. So it's
306606f32e7eSjoerg // subsumed by check (a).
306706f32e7eSjoerg
306806f32e7eSjoerg SDValue Chain = StoreNode->getChain();
306906f32e7eSjoerg
307006f32e7eSjoerg // Gather X elements in ChainOps.
307106f32e7eSjoerg if (Chain == Load.getValue(1)) {
307206f32e7eSjoerg FoundLoad = true;
307306f32e7eSjoerg ChainOps.push_back(Load.getOperand(0));
307406f32e7eSjoerg } else if (Chain.getOpcode() == ISD::TokenFactor) {
307506f32e7eSjoerg for (unsigned i = 0, e = Chain.getNumOperands(); i != e; ++i) {
307606f32e7eSjoerg SDValue Op = Chain.getOperand(i);
307706f32e7eSjoerg if (Op == Load.getValue(1)) {
307806f32e7eSjoerg FoundLoad = true;
307906f32e7eSjoerg // Drop Load, but keep its chain. No cycle check necessary.
308006f32e7eSjoerg ChainOps.push_back(Load.getOperand(0));
308106f32e7eSjoerg continue;
308206f32e7eSjoerg }
308306f32e7eSjoerg LoopWorklist.push_back(Op.getNode());
308406f32e7eSjoerg ChainOps.push_back(Op);
308506f32e7eSjoerg }
308606f32e7eSjoerg }
308706f32e7eSjoerg
308806f32e7eSjoerg if (!FoundLoad)
308906f32e7eSjoerg return false;
309006f32e7eSjoerg
309106f32e7eSjoerg // Worklist is currently Xn. Add Yn to worklist.
309206f32e7eSjoerg for (SDValue Op : StoredVal->ops())
309306f32e7eSjoerg if (Op.getNode() != LoadNode)
309406f32e7eSjoerg LoopWorklist.push_back(Op.getNode());
309506f32e7eSjoerg
309606f32e7eSjoerg // Check (a) if Load is a predecessor to Xn + Yn
309706f32e7eSjoerg if (SDNode::hasPredecessorHelper(Load.getNode(), Visited, LoopWorklist, Max,
309806f32e7eSjoerg true))
309906f32e7eSjoerg return false;
310006f32e7eSjoerg
310106f32e7eSjoerg InputChain =
310206f32e7eSjoerg CurDAG->getNode(ISD::TokenFactor, SDLoc(Chain), MVT::Other, ChainOps);
310306f32e7eSjoerg return true;
310406f32e7eSjoerg }
310506f32e7eSjoerg
310606f32e7eSjoerg // Change a chain of {load; op; store} of the same value into a simple op
310706f32e7eSjoerg // through memory of that value, if the uses of the modified value and its
310806f32e7eSjoerg // address are suitable.
310906f32e7eSjoerg //
311006f32e7eSjoerg // The tablegen pattern memory operand pattern is currently not able to match
311106f32e7eSjoerg // the case where the EFLAGS on the original operation are used.
311206f32e7eSjoerg //
311306f32e7eSjoerg // To move this to tablegen, we'll need to improve tablegen to allow flags to
311406f32e7eSjoerg // be transferred from a node in the pattern to the result node, probably with
311506f32e7eSjoerg // a new keyword. For example, we have this
311606f32e7eSjoerg // def DEC64m : RI<0xFF, MRM1m, (outs), (ins i64mem:$dst), "dec{q}\t$dst",
311706f32e7eSjoerg // [(store (add (loadi64 addr:$dst), -1), addr:$dst),
311806f32e7eSjoerg // (implicit EFLAGS)]>;
311906f32e7eSjoerg // but maybe need something like this
312006f32e7eSjoerg // def DEC64m : RI<0xFF, MRM1m, (outs), (ins i64mem:$dst), "dec{q}\t$dst",
312106f32e7eSjoerg // [(store (add (loadi64 addr:$dst), -1), addr:$dst),
312206f32e7eSjoerg // (transferrable EFLAGS)]>;
312306f32e7eSjoerg //
312406f32e7eSjoerg // Until then, we manually fold these and instruction select the operation
312506f32e7eSjoerg // here.
foldLoadStoreIntoMemOperand(SDNode * Node)312606f32e7eSjoerg bool X86DAGToDAGISel::foldLoadStoreIntoMemOperand(SDNode *Node) {
312706f32e7eSjoerg StoreSDNode *StoreNode = cast<StoreSDNode>(Node);
312806f32e7eSjoerg SDValue StoredVal = StoreNode->getOperand(1);
312906f32e7eSjoerg unsigned Opc = StoredVal->getOpcode();
313006f32e7eSjoerg
313106f32e7eSjoerg // Before we try to select anything, make sure this is memory operand size
313206f32e7eSjoerg // and opcode we can handle. Note that this must match the code below that
313306f32e7eSjoerg // actually lowers the opcodes.
313406f32e7eSjoerg EVT MemVT = StoreNode->getMemoryVT();
313506f32e7eSjoerg if (MemVT != MVT::i64 && MemVT != MVT::i32 && MemVT != MVT::i16 &&
313606f32e7eSjoerg MemVT != MVT::i8)
313706f32e7eSjoerg return false;
313806f32e7eSjoerg
313906f32e7eSjoerg bool IsCommutable = false;
314006f32e7eSjoerg bool IsNegate = false;
314106f32e7eSjoerg switch (Opc) {
314206f32e7eSjoerg default:
314306f32e7eSjoerg return false;
314406f32e7eSjoerg case X86ISD::SUB:
314506f32e7eSjoerg IsNegate = isNullConstant(StoredVal.getOperand(0));
314606f32e7eSjoerg break;
314706f32e7eSjoerg case X86ISD::SBB:
314806f32e7eSjoerg break;
314906f32e7eSjoerg case X86ISD::ADD:
315006f32e7eSjoerg case X86ISD::ADC:
315106f32e7eSjoerg case X86ISD::AND:
315206f32e7eSjoerg case X86ISD::OR:
315306f32e7eSjoerg case X86ISD::XOR:
315406f32e7eSjoerg IsCommutable = true;
315506f32e7eSjoerg break;
315606f32e7eSjoerg }
315706f32e7eSjoerg
315806f32e7eSjoerg unsigned LoadOpNo = IsNegate ? 1 : 0;
315906f32e7eSjoerg LoadSDNode *LoadNode = nullptr;
316006f32e7eSjoerg SDValue InputChain;
316106f32e7eSjoerg if (!isFusableLoadOpStorePattern(StoreNode, StoredVal, CurDAG, LoadOpNo,
316206f32e7eSjoerg LoadNode, InputChain)) {
316306f32e7eSjoerg if (!IsCommutable)
316406f32e7eSjoerg return false;
316506f32e7eSjoerg
316606f32e7eSjoerg // This operation is commutable, try the other operand.
316706f32e7eSjoerg LoadOpNo = 1;
316806f32e7eSjoerg if (!isFusableLoadOpStorePattern(StoreNode, StoredVal, CurDAG, LoadOpNo,
316906f32e7eSjoerg LoadNode, InputChain))
317006f32e7eSjoerg return false;
317106f32e7eSjoerg }
317206f32e7eSjoerg
317306f32e7eSjoerg SDValue Base, Scale, Index, Disp, Segment;
317406f32e7eSjoerg if (!selectAddr(LoadNode, LoadNode->getBasePtr(), Base, Scale, Index, Disp,
317506f32e7eSjoerg Segment))
317606f32e7eSjoerg return false;
317706f32e7eSjoerg
317806f32e7eSjoerg auto SelectOpcode = [&](unsigned Opc64, unsigned Opc32, unsigned Opc16,
317906f32e7eSjoerg unsigned Opc8) {
318006f32e7eSjoerg switch (MemVT.getSimpleVT().SimpleTy) {
318106f32e7eSjoerg case MVT::i64:
318206f32e7eSjoerg return Opc64;
318306f32e7eSjoerg case MVT::i32:
318406f32e7eSjoerg return Opc32;
318506f32e7eSjoerg case MVT::i16:
318606f32e7eSjoerg return Opc16;
318706f32e7eSjoerg case MVT::i8:
318806f32e7eSjoerg return Opc8;
318906f32e7eSjoerg default:
319006f32e7eSjoerg llvm_unreachable("Invalid size!");
319106f32e7eSjoerg }
319206f32e7eSjoerg };
319306f32e7eSjoerg
319406f32e7eSjoerg MachineSDNode *Result;
319506f32e7eSjoerg switch (Opc) {
319606f32e7eSjoerg case X86ISD::SUB:
319706f32e7eSjoerg // Handle negate.
319806f32e7eSjoerg if (IsNegate) {
319906f32e7eSjoerg unsigned NewOpc = SelectOpcode(X86::NEG64m, X86::NEG32m, X86::NEG16m,
320006f32e7eSjoerg X86::NEG8m);
320106f32e7eSjoerg const SDValue Ops[] = {Base, Scale, Index, Disp, Segment, InputChain};
320206f32e7eSjoerg Result = CurDAG->getMachineNode(NewOpc, SDLoc(Node), MVT::i32,
320306f32e7eSjoerg MVT::Other, Ops);
320406f32e7eSjoerg break;
320506f32e7eSjoerg }
320606f32e7eSjoerg LLVM_FALLTHROUGH;
320706f32e7eSjoerg case X86ISD::ADD:
320806f32e7eSjoerg // Try to match inc/dec.
3209*da58b97aSjoerg if (!Subtarget->slowIncDec() || CurDAG->shouldOptForSize()) {
321006f32e7eSjoerg bool IsOne = isOneConstant(StoredVal.getOperand(1));
321106f32e7eSjoerg bool IsNegOne = isAllOnesConstant(StoredVal.getOperand(1));
321206f32e7eSjoerg // ADD/SUB with 1/-1 and carry flag isn't used can use inc/dec.
321306f32e7eSjoerg if ((IsOne || IsNegOne) && hasNoCarryFlagUses(StoredVal.getValue(1))) {
321406f32e7eSjoerg unsigned NewOpc =
321506f32e7eSjoerg ((Opc == X86ISD::ADD) == IsOne)
321606f32e7eSjoerg ? SelectOpcode(X86::INC64m, X86::INC32m, X86::INC16m, X86::INC8m)
321706f32e7eSjoerg : SelectOpcode(X86::DEC64m, X86::DEC32m, X86::DEC16m, X86::DEC8m);
321806f32e7eSjoerg const SDValue Ops[] = {Base, Scale, Index, Disp, Segment, InputChain};
321906f32e7eSjoerg Result = CurDAG->getMachineNode(NewOpc, SDLoc(Node), MVT::i32,
322006f32e7eSjoerg MVT::Other, Ops);
322106f32e7eSjoerg break;
322206f32e7eSjoerg }
322306f32e7eSjoerg }
322406f32e7eSjoerg LLVM_FALLTHROUGH;
322506f32e7eSjoerg case X86ISD::ADC:
322606f32e7eSjoerg case X86ISD::SBB:
322706f32e7eSjoerg case X86ISD::AND:
322806f32e7eSjoerg case X86ISD::OR:
322906f32e7eSjoerg case X86ISD::XOR: {
323006f32e7eSjoerg auto SelectRegOpcode = [SelectOpcode](unsigned Opc) {
323106f32e7eSjoerg switch (Opc) {
323206f32e7eSjoerg case X86ISD::ADD:
323306f32e7eSjoerg return SelectOpcode(X86::ADD64mr, X86::ADD32mr, X86::ADD16mr,
323406f32e7eSjoerg X86::ADD8mr);
323506f32e7eSjoerg case X86ISD::ADC:
323606f32e7eSjoerg return SelectOpcode(X86::ADC64mr, X86::ADC32mr, X86::ADC16mr,
323706f32e7eSjoerg X86::ADC8mr);
323806f32e7eSjoerg case X86ISD::SUB:
323906f32e7eSjoerg return SelectOpcode(X86::SUB64mr, X86::SUB32mr, X86::SUB16mr,
324006f32e7eSjoerg X86::SUB8mr);
324106f32e7eSjoerg case X86ISD::SBB:
324206f32e7eSjoerg return SelectOpcode(X86::SBB64mr, X86::SBB32mr, X86::SBB16mr,
324306f32e7eSjoerg X86::SBB8mr);
324406f32e7eSjoerg case X86ISD::AND:
324506f32e7eSjoerg return SelectOpcode(X86::AND64mr, X86::AND32mr, X86::AND16mr,
324606f32e7eSjoerg X86::AND8mr);
324706f32e7eSjoerg case X86ISD::OR:
324806f32e7eSjoerg return SelectOpcode(X86::OR64mr, X86::OR32mr, X86::OR16mr, X86::OR8mr);
324906f32e7eSjoerg case X86ISD::XOR:
325006f32e7eSjoerg return SelectOpcode(X86::XOR64mr, X86::XOR32mr, X86::XOR16mr,
325106f32e7eSjoerg X86::XOR8mr);
325206f32e7eSjoerg default:
325306f32e7eSjoerg llvm_unreachable("Invalid opcode!");
325406f32e7eSjoerg }
325506f32e7eSjoerg };
325606f32e7eSjoerg auto SelectImm8Opcode = [SelectOpcode](unsigned Opc) {
325706f32e7eSjoerg switch (Opc) {
325806f32e7eSjoerg case X86ISD::ADD:
325906f32e7eSjoerg return SelectOpcode(X86::ADD64mi8, X86::ADD32mi8, X86::ADD16mi8, 0);
326006f32e7eSjoerg case X86ISD::ADC:
326106f32e7eSjoerg return SelectOpcode(X86::ADC64mi8, X86::ADC32mi8, X86::ADC16mi8, 0);
326206f32e7eSjoerg case X86ISD::SUB:
326306f32e7eSjoerg return SelectOpcode(X86::SUB64mi8, X86::SUB32mi8, X86::SUB16mi8, 0);
326406f32e7eSjoerg case X86ISD::SBB:
326506f32e7eSjoerg return SelectOpcode(X86::SBB64mi8, X86::SBB32mi8, X86::SBB16mi8, 0);
326606f32e7eSjoerg case X86ISD::AND:
326706f32e7eSjoerg return SelectOpcode(X86::AND64mi8, X86::AND32mi8, X86::AND16mi8, 0);
326806f32e7eSjoerg case X86ISD::OR:
326906f32e7eSjoerg return SelectOpcode(X86::OR64mi8, X86::OR32mi8, X86::OR16mi8, 0);
327006f32e7eSjoerg case X86ISD::XOR:
327106f32e7eSjoerg return SelectOpcode(X86::XOR64mi8, X86::XOR32mi8, X86::XOR16mi8, 0);
327206f32e7eSjoerg default:
327306f32e7eSjoerg llvm_unreachable("Invalid opcode!");
327406f32e7eSjoerg }
327506f32e7eSjoerg };
327606f32e7eSjoerg auto SelectImmOpcode = [SelectOpcode](unsigned Opc) {
327706f32e7eSjoerg switch (Opc) {
327806f32e7eSjoerg case X86ISD::ADD:
327906f32e7eSjoerg return SelectOpcode(X86::ADD64mi32, X86::ADD32mi, X86::ADD16mi,
328006f32e7eSjoerg X86::ADD8mi);
328106f32e7eSjoerg case X86ISD::ADC:
328206f32e7eSjoerg return SelectOpcode(X86::ADC64mi32, X86::ADC32mi, X86::ADC16mi,
328306f32e7eSjoerg X86::ADC8mi);
328406f32e7eSjoerg case X86ISD::SUB:
328506f32e7eSjoerg return SelectOpcode(X86::SUB64mi32, X86::SUB32mi, X86::SUB16mi,
328606f32e7eSjoerg X86::SUB8mi);
328706f32e7eSjoerg case X86ISD::SBB:
328806f32e7eSjoerg return SelectOpcode(X86::SBB64mi32, X86::SBB32mi, X86::SBB16mi,
328906f32e7eSjoerg X86::SBB8mi);
329006f32e7eSjoerg case X86ISD::AND:
329106f32e7eSjoerg return SelectOpcode(X86::AND64mi32, X86::AND32mi, X86::AND16mi,
329206f32e7eSjoerg X86::AND8mi);
329306f32e7eSjoerg case X86ISD::OR:
329406f32e7eSjoerg return SelectOpcode(X86::OR64mi32, X86::OR32mi, X86::OR16mi,
329506f32e7eSjoerg X86::OR8mi);
329606f32e7eSjoerg case X86ISD::XOR:
329706f32e7eSjoerg return SelectOpcode(X86::XOR64mi32, X86::XOR32mi, X86::XOR16mi,
329806f32e7eSjoerg X86::XOR8mi);
329906f32e7eSjoerg default:
330006f32e7eSjoerg llvm_unreachable("Invalid opcode!");
330106f32e7eSjoerg }
330206f32e7eSjoerg };
330306f32e7eSjoerg
330406f32e7eSjoerg unsigned NewOpc = SelectRegOpcode(Opc);
330506f32e7eSjoerg SDValue Operand = StoredVal->getOperand(1-LoadOpNo);
330606f32e7eSjoerg
330706f32e7eSjoerg // See if the operand is a constant that we can fold into an immediate
330806f32e7eSjoerg // operand.
330906f32e7eSjoerg if (auto *OperandC = dyn_cast<ConstantSDNode>(Operand)) {
331006f32e7eSjoerg int64_t OperandV = OperandC->getSExtValue();
331106f32e7eSjoerg
331206f32e7eSjoerg // Check if we can shrink the operand enough to fit in an immediate (or
331306f32e7eSjoerg // fit into a smaller immediate) by negating it and switching the
331406f32e7eSjoerg // operation.
331506f32e7eSjoerg if ((Opc == X86ISD::ADD || Opc == X86ISD::SUB) &&
331606f32e7eSjoerg ((MemVT != MVT::i8 && !isInt<8>(OperandV) && isInt<8>(-OperandV)) ||
331706f32e7eSjoerg (MemVT == MVT::i64 && !isInt<32>(OperandV) &&
331806f32e7eSjoerg isInt<32>(-OperandV))) &&
331906f32e7eSjoerg hasNoCarryFlagUses(StoredVal.getValue(1))) {
332006f32e7eSjoerg OperandV = -OperandV;
332106f32e7eSjoerg Opc = Opc == X86ISD::ADD ? X86ISD::SUB : X86ISD::ADD;
332206f32e7eSjoerg }
332306f32e7eSjoerg
332406f32e7eSjoerg // First try to fit this into an Imm8 operand. If it doesn't fit, then try
332506f32e7eSjoerg // the larger immediate operand.
332606f32e7eSjoerg if (MemVT != MVT::i8 && isInt<8>(OperandV)) {
332706f32e7eSjoerg Operand = CurDAG->getTargetConstant(OperandV, SDLoc(Node), MemVT);
332806f32e7eSjoerg NewOpc = SelectImm8Opcode(Opc);
332906f32e7eSjoerg } else if (MemVT != MVT::i64 || isInt<32>(OperandV)) {
333006f32e7eSjoerg Operand = CurDAG->getTargetConstant(OperandV, SDLoc(Node), MemVT);
333106f32e7eSjoerg NewOpc = SelectImmOpcode(Opc);
333206f32e7eSjoerg }
333306f32e7eSjoerg }
333406f32e7eSjoerg
333506f32e7eSjoerg if (Opc == X86ISD::ADC || Opc == X86ISD::SBB) {
333606f32e7eSjoerg SDValue CopyTo =
333706f32e7eSjoerg CurDAG->getCopyToReg(InputChain, SDLoc(Node), X86::EFLAGS,
333806f32e7eSjoerg StoredVal.getOperand(2), SDValue());
333906f32e7eSjoerg
334006f32e7eSjoerg const SDValue Ops[] = {Base, Scale, Index, Disp,
334106f32e7eSjoerg Segment, Operand, CopyTo, CopyTo.getValue(1)};
334206f32e7eSjoerg Result = CurDAG->getMachineNode(NewOpc, SDLoc(Node), MVT::i32, MVT::Other,
334306f32e7eSjoerg Ops);
334406f32e7eSjoerg } else {
334506f32e7eSjoerg const SDValue Ops[] = {Base, Scale, Index, Disp,
334606f32e7eSjoerg Segment, Operand, InputChain};
334706f32e7eSjoerg Result = CurDAG->getMachineNode(NewOpc, SDLoc(Node), MVT::i32, MVT::Other,
334806f32e7eSjoerg Ops);
334906f32e7eSjoerg }
335006f32e7eSjoerg break;
335106f32e7eSjoerg }
335206f32e7eSjoerg default:
335306f32e7eSjoerg llvm_unreachable("Invalid opcode!");
335406f32e7eSjoerg }
335506f32e7eSjoerg
335606f32e7eSjoerg MachineMemOperand *MemOps[] = {StoreNode->getMemOperand(),
335706f32e7eSjoerg LoadNode->getMemOperand()};
335806f32e7eSjoerg CurDAG->setNodeMemRefs(Result, MemOps);
335906f32e7eSjoerg
336006f32e7eSjoerg // Update Load Chain uses as well.
336106f32e7eSjoerg ReplaceUses(SDValue(LoadNode, 1), SDValue(Result, 1));
336206f32e7eSjoerg ReplaceUses(SDValue(StoreNode, 0), SDValue(Result, 1));
336306f32e7eSjoerg ReplaceUses(SDValue(StoredVal.getNode(), 1), SDValue(Result, 0));
336406f32e7eSjoerg CurDAG->RemoveDeadNode(Node);
336506f32e7eSjoerg return true;
336606f32e7eSjoerg }
336706f32e7eSjoerg
336806f32e7eSjoerg // See if this is an X & Mask that we can match to BEXTR/BZHI.
336906f32e7eSjoerg // Where Mask is one of the following patterns:
337006f32e7eSjoerg // a) x & (1 << nbits) - 1
337106f32e7eSjoerg // b) x & ~(-1 << nbits)
337206f32e7eSjoerg // c) x & (-1 >> (32 - y))
337306f32e7eSjoerg // d) x << (32 - y) >> (32 - y)
matchBitExtract(SDNode * Node)337406f32e7eSjoerg bool X86DAGToDAGISel::matchBitExtract(SDNode *Node) {
337506f32e7eSjoerg assert(
337606f32e7eSjoerg (Node->getOpcode() == ISD::AND || Node->getOpcode() == ISD::SRL) &&
337706f32e7eSjoerg "Should be either an and-mask, or right-shift after clearing high bits.");
337806f32e7eSjoerg
337906f32e7eSjoerg // BEXTR is BMI instruction, BZHI is BMI2 instruction. We need at least one.
338006f32e7eSjoerg if (!Subtarget->hasBMI() && !Subtarget->hasBMI2())
338106f32e7eSjoerg return false;
338206f32e7eSjoerg
338306f32e7eSjoerg MVT NVT = Node->getSimpleValueType(0);
338406f32e7eSjoerg
338506f32e7eSjoerg // Only supported for 32 and 64 bits.
338606f32e7eSjoerg if (NVT != MVT::i32 && NVT != MVT::i64)
338706f32e7eSjoerg return false;
338806f32e7eSjoerg
338906f32e7eSjoerg SDValue NBits;
339006f32e7eSjoerg
339106f32e7eSjoerg // If we have BMI2's BZHI, we are ok with muti-use patterns.
339206f32e7eSjoerg // Else, if we only have BMI1's BEXTR, we require one-use.
339306f32e7eSjoerg const bool CanHaveExtraUses = Subtarget->hasBMI2();
339406f32e7eSjoerg auto checkUses = [CanHaveExtraUses](SDValue Op, unsigned NUses) {
339506f32e7eSjoerg return CanHaveExtraUses ||
339606f32e7eSjoerg Op.getNode()->hasNUsesOfValue(NUses, Op.getResNo());
339706f32e7eSjoerg };
339806f32e7eSjoerg auto checkOneUse = [checkUses](SDValue Op) { return checkUses(Op, 1); };
339906f32e7eSjoerg auto checkTwoUse = [checkUses](SDValue Op) { return checkUses(Op, 2); };
340006f32e7eSjoerg
340106f32e7eSjoerg auto peekThroughOneUseTruncation = [checkOneUse](SDValue V) {
340206f32e7eSjoerg if (V->getOpcode() == ISD::TRUNCATE && checkOneUse(V)) {
340306f32e7eSjoerg assert(V.getSimpleValueType() == MVT::i32 &&
340406f32e7eSjoerg V.getOperand(0).getSimpleValueType() == MVT::i64 &&
340506f32e7eSjoerg "Expected i64 -> i32 truncation");
340606f32e7eSjoerg V = V.getOperand(0);
340706f32e7eSjoerg }
340806f32e7eSjoerg return V;
340906f32e7eSjoerg };
341006f32e7eSjoerg
341106f32e7eSjoerg // a) x & ((1 << nbits) + (-1))
341206f32e7eSjoerg auto matchPatternA = [checkOneUse, peekThroughOneUseTruncation,
341306f32e7eSjoerg &NBits](SDValue Mask) -> bool {
341406f32e7eSjoerg // Match `add`. Must only have one use!
341506f32e7eSjoerg if (Mask->getOpcode() != ISD::ADD || !checkOneUse(Mask))
341606f32e7eSjoerg return false;
341706f32e7eSjoerg // We should be adding all-ones constant (i.e. subtracting one.)
341806f32e7eSjoerg if (!isAllOnesConstant(Mask->getOperand(1)))
341906f32e7eSjoerg return false;
342006f32e7eSjoerg // Match `1 << nbits`. Might be truncated. Must only have one use!
342106f32e7eSjoerg SDValue M0 = peekThroughOneUseTruncation(Mask->getOperand(0));
342206f32e7eSjoerg if (M0->getOpcode() != ISD::SHL || !checkOneUse(M0))
342306f32e7eSjoerg return false;
342406f32e7eSjoerg if (!isOneConstant(M0->getOperand(0)))
342506f32e7eSjoerg return false;
342606f32e7eSjoerg NBits = M0->getOperand(1);
342706f32e7eSjoerg return true;
342806f32e7eSjoerg };
342906f32e7eSjoerg
343006f32e7eSjoerg auto isAllOnes = [this, peekThroughOneUseTruncation, NVT](SDValue V) {
343106f32e7eSjoerg V = peekThroughOneUseTruncation(V);
343206f32e7eSjoerg return CurDAG->MaskedValueIsAllOnes(
343306f32e7eSjoerg V, APInt::getLowBitsSet(V.getSimpleValueType().getSizeInBits(),
343406f32e7eSjoerg NVT.getSizeInBits()));
343506f32e7eSjoerg };
343606f32e7eSjoerg
343706f32e7eSjoerg // b) x & ~(-1 << nbits)
343806f32e7eSjoerg auto matchPatternB = [checkOneUse, isAllOnes, peekThroughOneUseTruncation,
343906f32e7eSjoerg &NBits](SDValue Mask) -> bool {
344006f32e7eSjoerg // Match `~()`. Must only have one use!
344106f32e7eSjoerg if (Mask.getOpcode() != ISD::XOR || !checkOneUse(Mask))
344206f32e7eSjoerg return false;
344306f32e7eSjoerg // The -1 only has to be all-ones for the final Node's NVT.
344406f32e7eSjoerg if (!isAllOnes(Mask->getOperand(1)))
344506f32e7eSjoerg return false;
344606f32e7eSjoerg // Match `-1 << nbits`. Might be truncated. Must only have one use!
344706f32e7eSjoerg SDValue M0 = peekThroughOneUseTruncation(Mask->getOperand(0));
344806f32e7eSjoerg if (M0->getOpcode() != ISD::SHL || !checkOneUse(M0))
344906f32e7eSjoerg return false;
345006f32e7eSjoerg // The -1 only has to be all-ones for the final Node's NVT.
345106f32e7eSjoerg if (!isAllOnes(M0->getOperand(0)))
345206f32e7eSjoerg return false;
345306f32e7eSjoerg NBits = M0->getOperand(1);
345406f32e7eSjoerg return true;
345506f32e7eSjoerg };
345606f32e7eSjoerg
345706f32e7eSjoerg // Match potentially-truncated (bitwidth - y)
345806f32e7eSjoerg auto matchShiftAmt = [checkOneUse, &NBits](SDValue ShiftAmt,
345906f32e7eSjoerg unsigned Bitwidth) {
346006f32e7eSjoerg // Skip over a truncate of the shift amount.
346106f32e7eSjoerg if (ShiftAmt.getOpcode() == ISD::TRUNCATE) {
346206f32e7eSjoerg ShiftAmt = ShiftAmt.getOperand(0);
346306f32e7eSjoerg // The trunc should have been the only user of the real shift amount.
346406f32e7eSjoerg if (!checkOneUse(ShiftAmt))
346506f32e7eSjoerg return false;
346606f32e7eSjoerg }
346706f32e7eSjoerg // Match the shift amount as: (bitwidth - y). It should go away, too.
346806f32e7eSjoerg if (ShiftAmt.getOpcode() != ISD::SUB)
346906f32e7eSjoerg return false;
3470*da58b97aSjoerg auto *V0 = dyn_cast<ConstantSDNode>(ShiftAmt.getOperand(0));
347106f32e7eSjoerg if (!V0 || V0->getZExtValue() != Bitwidth)
347206f32e7eSjoerg return false;
347306f32e7eSjoerg NBits = ShiftAmt.getOperand(1);
347406f32e7eSjoerg return true;
347506f32e7eSjoerg };
347606f32e7eSjoerg
347706f32e7eSjoerg // c) x & (-1 >> (32 - y))
347806f32e7eSjoerg auto matchPatternC = [checkOneUse, peekThroughOneUseTruncation,
347906f32e7eSjoerg matchShiftAmt](SDValue Mask) -> bool {
348006f32e7eSjoerg // The mask itself may be truncated.
348106f32e7eSjoerg Mask = peekThroughOneUseTruncation(Mask);
348206f32e7eSjoerg unsigned Bitwidth = Mask.getSimpleValueType().getSizeInBits();
348306f32e7eSjoerg // Match `l>>`. Must only have one use!
348406f32e7eSjoerg if (Mask.getOpcode() != ISD::SRL || !checkOneUse(Mask))
348506f32e7eSjoerg return false;
348606f32e7eSjoerg // We should be shifting truly all-ones constant.
348706f32e7eSjoerg if (!isAllOnesConstant(Mask.getOperand(0)))
348806f32e7eSjoerg return false;
348906f32e7eSjoerg SDValue M1 = Mask.getOperand(1);
349006f32e7eSjoerg // The shift amount should not be used externally.
349106f32e7eSjoerg if (!checkOneUse(M1))
349206f32e7eSjoerg return false;
349306f32e7eSjoerg return matchShiftAmt(M1, Bitwidth);
349406f32e7eSjoerg };
349506f32e7eSjoerg
349606f32e7eSjoerg SDValue X;
349706f32e7eSjoerg
349806f32e7eSjoerg // d) x << (32 - y) >> (32 - y)
349906f32e7eSjoerg auto matchPatternD = [checkOneUse, checkTwoUse, matchShiftAmt,
350006f32e7eSjoerg &X](SDNode *Node) -> bool {
350106f32e7eSjoerg if (Node->getOpcode() != ISD::SRL)
350206f32e7eSjoerg return false;
350306f32e7eSjoerg SDValue N0 = Node->getOperand(0);
350406f32e7eSjoerg if (N0->getOpcode() != ISD::SHL || !checkOneUse(N0))
350506f32e7eSjoerg return false;
350606f32e7eSjoerg unsigned Bitwidth = N0.getSimpleValueType().getSizeInBits();
350706f32e7eSjoerg SDValue N1 = Node->getOperand(1);
350806f32e7eSjoerg SDValue N01 = N0->getOperand(1);
350906f32e7eSjoerg // Both of the shifts must be by the exact same value.
351006f32e7eSjoerg // There should not be any uses of the shift amount outside of the pattern.
351106f32e7eSjoerg if (N1 != N01 || !checkTwoUse(N1))
351206f32e7eSjoerg return false;
351306f32e7eSjoerg if (!matchShiftAmt(N1, Bitwidth))
351406f32e7eSjoerg return false;
351506f32e7eSjoerg X = N0->getOperand(0);
351606f32e7eSjoerg return true;
351706f32e7eSjoerg };
351806f32e7eSjoerg
351906f32e7eSjoerg auto matchLowBitMask = [matchPatternA, matchPatternB,
352006f32e7eSjoerg matchPatternC](SDValue Mask) -> bool {
352106f32e7eSjoerg return matchPatternA(Mask) || matchPatternB(Mask) || matchPatternC(Mask);
352206f32e7eSjoerg };
352306f32e7eSjoerg
352406f32e7eSjoerg if (Node->getOpcode() == ISD::AND) {
352506f32e7eSjoerg X = Node->getOperand(0);
352606f32e7eSjoerg SDValue Mask = Node->getOperand(1);
352706f32e7eSjoerg
352806f32e7eSjoerg if (matchLowBitMask(Mask)) {
352906f32e7eSjoerg // Great.
353006f32e7eSjoerg } else {
353106f32e7eSjoerg std::swap(X, Mask);
353206f32e7eSjoerg if (!matchLowBitMask(Mask))
353306f32e7eSjoerg return false;
353406f32e7eSjoerg }
353506f32e7eSjoerg } else if (!matchPatternD(Node))
353606f32e7eSjoerg return false;
353706f32e7eSjoerg
353806f32e7eSjoerg SDLoc DL(Node);
353906f32e7eSjoerg
354006f32e7eSjoerg // Truncate the shift amount.
354106f32e7eSjoerg NBits = CurDAG->getNode(ISD::TRUNCATE, DL, MVT::i8, NBits);
354206f32e7eSjoerg insertDAGNode(*CurDAG, SDValue(Node, 0), NBits);
354306f32e7eSjoerg
354406f32e7eSjoerg // Insert 8-bit NBits into lowest 8 bits of 32-bit register.
354506f32e7eSjoerg // All the other bits are undefined, we do not care about them.
354606f32e7eSjoerg SDValue ImplDef = SDValue(
354706f32e7eSjoerg CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF, DL, MVT::i32), 0);
354806f32e7eSjoerg insertDAGNode(*CurDAG, SDValue(Node, 0), ImplDef);
354906f32e7eSjoerg
355006f32e7eSjoerg SDValue SRIdxVal = CurDAG->getTargetConstant(X86::sub_8bit, DL, MVT::i32);
355106f32e7eSjoerg insertDAGNode(*CurDAG, SDValue(Node, 0), SRIdxVal);
355206f32e7eSjoerg NBits = SDValue(
355306f32e7eSjoerg CurDAG->getMachineNode(TargetOpcode::INSERT_SUBREG, DL, MVT::i32, ImplDef,
355406f32e7eSjoerg NBits, SRIdxVal), 0);
355506f32e7eSjoerg insertDAGNode(*CurDAG, SDValue(Node, 0), NBits);
355606f32e7eSjoerg
355706f32e7eSjoerg if (Subtarget->hasBMI2()) {
355806f32e7eSjoerg // Great, just emit the the BZHI..
355906f32e7eSjoerg if (NVT != MVT::i32) {
356006f32e7eSjoerg // But have to place the bit count into the wide-enough register first.
356106f32e7eSjoerg NBits = CurDAG->getNode(ISD::ANY_EXTEND, DL, NVT, NBits);
356206f32e7eSjoerg insertDAGNode(*CurDAG, SDValue(Node, 0), NBits);
356306f32e7eSjoerg }
356406f32e7eSjoerg
356506f32e7eSjoerg SDValue Extract = CurDAG->getNode(X86ISD::BZHI, DL, NVT, X, NBits);
356606f32e7eSjoerg ReplaceNode(Node, Extract.getNode());
356706f32e7eSjoerg SelectCode(Extract.getNode());
356806f32e7eSjoerg return true;
356906f32e7eSjoerg }
357006f32e7eSjoerg
357106f32e7eSjoerg // Else, if we do *NOT* have BMI2, let's find out if the if the 'X' is
357206f32e7eSjoerg // *logically* shifted (potentially with one-use trunc inbetween),
357306f32e7eSjoerg // and the truncation was the only use of the shift,
357406f32e7eSjoerg // and if so look past one-use truncation.
357506f32e7eSjoerg {
357606f32e7eSjoerg SDValue RealX = peekThroughOneUseTruncation(X);
357706f32e7eSjoerg // FIXME: only if the shift is one-use?
357806f32e7eSjoerg if (RealX != X && RealX.getOpcode() == ISD::SRL)
357906f32e7eSjoerg X = RealX;
358006f32e7eSjoerg }
358106f32e7eSjoerg
358206f32e7eSjoerg MVT XVT = X.getSimpleValueType();
358306f32e7eSjoerg
358406f32e7eSjoerg // Else, emitting BEXTR requires one more step.
358506f32e7eSjoerg // The 'control' of BEXTR has the pattern of:
358606f32e7eSjoerg // [15...8 bit][ 7...0 bit] location
358706f32e7eSjoerg // [ bit count][ shift] name
358806f32e7eSjoerg // I.e. 0b000000011'00000001 means (x >> 0b1) & 0b11
358906f32e7eSjoerg
359006f32e7eSjoerg // Shift NBits left by 8 bits, thus producing 'control'.
359106f32e7eSjoerg // This makes the low 8 bits to be zero.
359206f32e7eSjoerg SDValue C8 = CurDAG->getConstant(8, DL, MVT::i8);
3593*da58b97aSjoerg insertDAGNode(*CurDAG, SDValue(Node, 0), C8);
359406f32e7eSjoerg SDValue Control = CurDAG->getNode(ISD::SHL, DL, MVT::i32, NBits, C8);
359506f32e7eSjoerg insertDAGNode(*CurDAG, SDValue(Node, 0), Control);
359606f32e7eSjoerg
359706f32e7eSjoerg // If the 'X' is *logically* shifted, we can fold that shift into 'control'.
359806f32e7eSjoerg // FIXME: only if the shift is one-use?
359906f32e7eSjoerg if (X.getOpcode() == ISD::SRL) {
360006f32e7eSjoerg SDValue ShiftAmt = X.getOperand(1);
360106f32e7eSjoerg X = X.getOperand(0);
360206f32e7eSjoerg
360306f32e7eSjoerg assert(ShiftAmt.getValueType() == MVT::i8 &&
360406f32e7eSjoerg "Expected shift amount to be i8");
360506f32e7eSjoerg
360606f32e7eSjoerg // Now, *zero*-extend the shift amount. The bits 8...15 *must* be zero!
360706f32e7eSjoerg // We could zext to i16 in some form, but we intentionally don't do that.
360806f32e7eSjoerg SDValue OrigShiftAmt = ShiftAmt;
360906f32e7eSjoerg ShiftAmt = CurDAG->getNode(ISD::ZERO_EXTEND, DL, MVT::i32, ShiftAmt);
361006f32e7eSjoerg insertDAGNode(*CurDAG, OrigShiftAmt, ShiftAmt);
361106f32e7eSjoerg
361206f32e7eSjoerg // And now 'or' these low 8 bits of shift amount into the 'control'.
361306f32e7eSjoerg Control = CurDAG->getNode(ISD::OR, DL, MVT::i32, Control, ShiftAmt);
361406f32e7eSjoerg insertDAGNode(*CurDAG, SDValue(Node, 0), Control);
361506f32e7eSjoerg }
361606f32e7eSjoerg
361706f32e7eSjoerg // But have to place the 'control' into the wide-enough register first.
361806f32e7eSjoerg if (XVT != MVT::i32) {
361906f32e7eSjoerg Control = CurDAG->getNode(ISD::ANY_EXTEND, DL, XVT, Control);
362006f32e7eSjoerg insertDAGNode(*CurDAG, SDValue(Node, 0), Control);
362106f32e7eSjoerg }
362206f32e7eSjoerg
362306f32e7eSjoerg // And finally, form the BEXTR itself.
362406f32e7eSjoerg SDValue Extract = CurDAG->getNode(X86ISD::BEXTR, DL, XVT, X, Control);
362506f32e7eSjoerg
362606f32e7eSjoerg // The 'X' was originally truncated. Do that now.
362706f32e7eSjoerg if (XVT != NVT) {
362806f32e7eSjoerg insertDAGNode(*CurDAG, SDValue(Node, 0), Extract);
362906f32e7eSjoerg Extract = CurDAG->getNode(ISD::TRUNCATE, DL, NVT, Extract);
363006f32e7eSjoerg }
363106f32e7eSjoerg
363206f32e7eSjoerg ReplaceNode(Node, Extract.getNode());
363306f32e7eSjoerg SelectCode(Extract.getNode());
363406f32e7eSjoerg
363506f32e7eSjoerg return true;
363606f32e7eSjoerg }
363706f32e7eSjoerg
363806f32e7eSjoerg // See if this is an (X >> C1) & C2 that we can match to BEXTR/BEXTRI.
matchBEXTRFromAndImm(SDNode * Node)363906f32e7eSjoerg MachineSDNode *X86DAGToDAGISel::matchBEXTRFromAndImm(SDNode *Node) {
364006f32e7eSjoerg MVT NVT = Node->getSimpleValueType(0);
364106f32e7eSjoerg SDLoc dl(Node);
364206f32e7eSjoerg
364306f32e7eSjoerg SDValue N0 = Node->getOperand(0);
364406f32e7eSjoerg SDValue N1 = Node->getOperand(1);
364506f32e7eSjoerg
364606f32e7eSjoerg // If we have TBM we can use an immediate for the control. If we have BMI
364706f32e7eSjoerg // we should only do this if the BEXTR instruction is implemented well.
364806f32e7eSjoerg // Otherwise moving the control into a register makes this more costly.
364906f32e7eSjoerg // TODO: Maybe load folding, greater than 32-bit masks, or a guarantee of LICM
365006f32e7eSjoerg // hoisting the move immediate would make it worthwhile with a less optimal
365106f32e7eSjoerg // BEXTR?
365206f32e7eSjoerg bool PreferBEXTR =
365306f32e7eSjoerg Subtarget->hasTBM() || (Subtarget->hasBMI() && Subtarget->hasFastBEXTR());
365406f32e7eSjoerg if (!PreferBEXTR && !Subtarget->hasBMI2())
365506f32e7eSjoerg return nullptr;
365606f32e7eSjoerg
365706f32e7eSjoerg // Must have a shift right.
365806f32e7eSjoerg if (N0->getOpcode() != ISD::SRL && N0->getOpcode() != ISD::SRA)
365906f32e7eSjoerg return nullptr;
366006f32e7eSjoerg
366106f32e7eSjoerg // Shift can't have additional users.
366206f32e7eSjoerg if (!N0->hasOneUse())
366306f32e7eSjoerg return nullptr;
366406f32e7eSjoerg
366506f32e7eSjoerg // Only supported for 32 and 64 bits.
366606f32e7eSjoerg if (NVT != MVT::i32 && NVT != MVT::i64)
366706f32e7eSjoerg return nullptr;
366806f32e7eSjoerg
366906f32e7eSjoerg // Shift amount and RHS of and must be constant.
367006f32e7eSjoerg ConstantSDNode *MaskCst = dyn_cast<ConstantSDNode>(N1);
367106f32e7eSjoerg ConstantSDNode *ShiftCst = dyn_cast<ConstantSDNode>(N0->getOperand(1));
367206f32e7eSjoerg if (!MaskCst || !ShiftCst)
367306f32e7eSjoerg return nullptr;
367406f32e7eSjoerg
367506f32e7eSjoerg // And RHS must be a mask.
367606f32e7eSjoerg uint64_t Mask = MaskCst->getZExtValue();
367706f32e7eSjoerg if (!isMask_64(Mask))
367806f32e7eSjoerg return nullptr;
367906f32e7eSjoerg
368006f32e7eSjoerg uint64_t Shift = ShiftCst->getZExtValue();
368106f32e7eSjoerg uint64_t MaskSize = countPopulation(Mask);
368206f32e7eSjoerg
368306f32e7eSjoerg // Don't interfere with something that can be handled by extracting AH.
368406f32e7eSjoerg // TODO: If we are able to fold a load, BEXTR might still be better than AH.
368506f32e7eSjoerg if (Shift == 8 && MaskSize == 8)
368606f32e7eSjoerg return nullptr;
368706f32e7eSjoerg
368806f32e7eSjoerg // Make sure we are only using bits that were in the original value, not
368906f32e7eSjoerg // shifted in.
369006f32e7eSjoerg if (Shift + MaskSize > NVT.getSizeInBits())
369106f32e7eSjoerg return nullptr;
369206f32e7eSjoerg
369306f32e7eSjoerg // BZHI, if available, is always fast, unlike BEXTR. But even if we decide
369406f32e7eSjoerg // that we can't use BEXTR, it is only worthwhile using BZHI if the mask
369506f32e7eSjoerg // does not fit into 32 bits. Load folding is not a sufficient reason.
369606f32e7eSjoerg if (!PreferBEXTR && MaskSize <= 32)
369706f32e7eSjoerg return nullptr;
369806f32e7eSjoerg
369906f32e7eSjoerg SDValue Control;
370006f32e7eSjoerg unsigned ROpc, MOpc;
370106f32e7eSjoerg
370206f32e7eSjoerg if (!PreferBEXTR) {
370306f32e7eSjoerg assert(Subtarget->hasBMI2() && "We must have BMI2's BZHI then.");
370406f32e7eSjoerg // If we can't make use of BEXTR then we can't fuse shift+mask stages.
370506f32e7eSjoerg // Let's perform the mask first, and apply shift later. Note that we need to
370606f32e7eSjoerg // widen the mask to account for the fact that we'll apply shift afterwards!
370706f32e7eSjoerg Control = CurDAG->getTargetConstant(Shift + MaskSize, dl, NVT);
370806f32e7eSjoerg ROpc = NVT == MVT::i64 ? X86::BZHI64rr : X86::BZHI32rr;
370906f32e7eSjoerg MOpc = NVT == MVT::i64 ? X86::BZHI64rm : X86::BZHI32rm;
371006f32e7eSjoerg unsigned NewOpc = NVT == MVT::i64 ? X86::MOV32ri64 : X86::MOV32ri;
371106f32e7eSjoerg Control = SDValue(CurDAG->getMachineNode(NewOpc, dl, NVT, Control), 0);
371206f32e7eSjoerg } else {
371306f32e7eSjoerg // The 'control' of BEXTR has the pattern of:
371406f32e7eSjoerg // [15...8 bit][ 7...0 bit] location
371506f32e7eSjoerg // [ bit count][ shift] name
371606f32e7eSjoerg // I.e. 0b000000011'00000001 means (x >> 0b1) & 0b11
371706f32e7eSjoerg Control = CurDAG->getTargetConstant(Shift | (MaskSize << 8), dl, NVT);
371806f32e7eSjoerg if (Subtarget->hasTBM()) {
371906f32e7eSjoerg ROpc = NVT == MVT::i64 ? X86::BEXTRI64ri : X86::BEXTRI32ri;
372006f32e7eSjoerg MOpc = NVT == MVT::i64 ? X86::BEXTRI64mi : X86::BEXTRI32mi;
372106f32e7eSjoerg } else {
372206f32e7eSjoerg assert(Subtarget->hasBMI() && "We must have BMI1's BEXTR then.");
372306f32e7eSjoerg // BMI requires the immediate to placed in a register.
372406f32e7eSjoerg ROpc = NVT == MVT::i64 ? X86::BEXTR64rr : X86::BEXTR32rr;
372506f32e7eSjoerg MOpc = NVT == MVT::i64 ? X86::BEXTR64rm : X86::BEXTR32rm;
372606f32e7eSjoerg unsigned NewOpc = NVT == MVT::i64 ? X86::MOV32ri64 : X86::MOV32ri;
372706f32e7eSjoerg Control = SDValue(CurDAG->getMachineNode(NewOpc, dl, NVT, Control), 0);
372806f32e7eSjoerg }
372906f32e7eSjoerg }
373006f32e7eSjoerg
373106f32e7eSjoerg MachineSDNode *NewNode;
373206f32e7eSjoerg SDValue Input = N0->getOperand(0);
373306f32e7eSjoerg SDValue Tmp0, Tmp1, Tmp2, Tmp3, Tmp4;
373406f32e7eSjoerg if (tryFoldLoad(Node, N0.getNode(), Input, Tmp0, Tmp1, Tmp2, Tmp3, Tmp4)) {
373506f32e7eSjoerg SDValue Ops[] = {
373606f32e7eSjoerg Tmp0, Tmp1, Tmp2, Tmp3, Tmp4, Control, Input.getOperand(0)};
373706f32e7eSjoerg SDVTList VTs = CurDAG->getVTList(NVT, MVT::i32, MVT::Other);
373806f32e7eSjoerg NewNode = CurDAG->getMachineNode(MOpc, dl, VTs, Ops);
373906f32e7eSjoerg // Update the chain.
374006f32e7eSjoerg ReplaceUses(Input.getValue(1), SDValue(NewNode, 2));
374106f32e7eSjoerg // Record the mem-refs
374206f32e7eSjoerg CurDAG->setNodeMemRefs(NewNode, {cast<LoadSDNode>(Input)->getMemOperand()});
374306f32e7eSjoerg } else {
374406f32e7eSjoerg NewNode = CurDAG->getMachineNode(ROpc, dl, NVT, MVT::i32, Input, Control);
374506f32e7eSjoerg }
374606f32e7eSjoerg
374706f32e7eSjoerg if (!PreferBEXTR) {
374806f32e7eSjoerg // We still need to apply the shift.
374906f32e7eSjoerg SDValue ShAmt = CurDAG->getTargetConstant(Shift, dl, NVT);
375006f32e7eSjoerg unsigned NewOpc = NVT == MVT::i64 ? X86::SHR64ri : X86::SHR32ri;
375106f32e7eSjoerg NewNode =
375206f32e7eSjoerg CurDAG->getMachineNode(NewOpc, dl, NVT, SDValue(NewNode, 0), ShAmt);
375306f32e7eSjoerg }
375406f32e7eSjoerg
375506f32e7eSjoerg return NewNode;
375606f32e7eSjoerg }
375706f32e7eSjoerg
375806f32e7eSjoerg // Emit a PCMISTR(I/M) instruction.
emitPCMPISTR(unsigned ROpc,unsigned MOpc,bool MayFoldLoad,const SDLoc & dl,MVT VT,SDNode * Node)375906f32e7eSjoerg MachineSDNode *X86DAGToDAGISel::emitPCMPISTR(unsigned ROpc, unsigned MOpc,
376006f32e7eSjoerg bool MayFoldLoad, const SDLoc &dl,
376106f32e7eSjoerg MVT VT, SDNode *Node) {
376206f32e7eSjoerg SDValue N0 = Node->getOperand(0);
376306f32e7eSjoerg SDValue N1 = Node->getOperand(1);
376406f32e7eSjoerg SDValue Imm = Node->getOperand(2);
376506f32e7eSjoerg const ConstantInt *Val = cast<ConstantSDNode>(Imm)->getConstantIntValue();
376606f32e7eSjoerg Imm = CurDAG->getTargetConstant(*Val, SDLoc(Node), Imm.getValueType());
376706f32e7eSjoerg
376806f32e7eSjoerg // Try to fold a load. No need to check alignment.
376906f32e7eSjoerg SDValue Tmp0, Tmp1, Tmp2, Tmp3, Tmp4;
377006f32e7eSjoerg if (MayFoldLoad && tryFoldLoad(Node, N1, Tmp0, Tmp1, Tmp2, Tmp3, Tmp4)) {
377106f32e7eSjoerg SDValue Ops[] = { N0, Tmp0, Tmp1, Tmp2, Tmp3, Tmp4, Imm,
377206f32e7eSjoerg N1.getOperand(0) };
377306f32e7eSjoerg SDVTList VTs = CurDAG->getVTList(VT, MVT::i32, MVT::Other);
377406f32e7eSjoerg MachineSDNode *CNode = CurDAG->getMachineNode(MOpc, dl, VTs, Ops);
377506f32e7eSjoerg // Update the chain.
377606f32e7eSjoerg ReplaceUses(N1.getValue(1), SDValue(CNode, 2));
377706f32e7eSjoerg // Record the mem-refs
377806f32e7eSjoerg CurDAG->setNodeMemRefs(CNode, {cast<LoadSDNode>(N1)->getMemOperand()});
377906f32e7eSjoerg return CNode;
378006f32e7eSjoerg }
378106f32e7eSjoerg
378206f32e7eSjoerg SDValue Ops[] = { N0, N1, Imm };
378306f32e7eSjoerg SDVTList VTs = CurDAG->getVTList(VT, MVT::i32);
378406f32e7eSjoerg MachineSDNode *CNode = CurDAG->getMachineNode(ROpc, dl, VTs, Ops);
378506f32e7eSjoerg return CNode;
378606f32e7eSjoerg }
378706f32e7eSjoerg
378806f32e7eSjoerg // Emit a PCMESTR(I/M) instruction. Also return the Glue result in case we need
378906f32e7eSjoerg // to emit a second instruction after this one. This is needed since we have two
379006f32e7eSjoerg // copyToReg nodes glued before this and we need to continue that glue through.
emitPCMPESTR(unsigned ROpc,unsigned MOpc,bool MayFoldLoad,const SDLoc & dl,MVT VT,SDNode * Node,SDValue & InFlag)379106f32e7eSjoerg MachineSDNode *X86DAGToDAGISel::emitPCMPESTR(unsigned ROpc, unsigned MOpc,
379206f32e7eSjoerg bool MayFoldLoad, const SDLoc &dl,
379306f32e7eSjoerg MVT VT, SDNode *Node,
379406f32e7eSjoerg SDValue &InFlag) {
379506f32e7eSjoerg SDValue N0 = Node->getOperand(0);
379606f32e7eSjoerg SDValue N2 = Node->getOperand(2);
379706f32e7eSjoerg SDValue Imm = Node->getOperand(4);
379806f32e7eSjoerg const ConstantInt *Val = cast<ConstantSDNode>(Imm)->getConstantIntValue();
379906f32e7eSjoerg Imm = CurDAG->getTargetConstant(*Val, SDLoc(Node), Imm.getValueType());
380006f32e7eSjoerg
380106f32e7eSjoerg // Try to fold a load. No need to check alignment.
380206f32e7eSjoerg SDValue Tmp0, Tmp1, Tmp2, Tmp3, Tmp4;
380306f32e7eSjoerg if (MayFoldLoad && tryFoldLoad(Node, N2, Tmp0, Tmp1, Tmp2, Tmp3, Tmp4)) {
380406f32e7eSjoerg SDValue Ops[] = { N0, Tmp0, Tmp1, Tmp2, Tmp3, Tmp4, Imm,
380506f32e7eSjoerg N2.getOperand(0), InFlag };
380606f32e7eSjoerg SDVTList VTs = CurDAG->getVTList(VT, MVT::i32, MVT::Other, MVT::Glue);
380706f32e7eSjoerg MachineSDNode *CNode = CurDAG->getMachineNode(MOpc, dl, VTs, Ops);
380806f32e7eSjoerg InFlag = SDValue(CNode, 3);
380906f32e7eSjoerg // Update the chain.
381006f32e7eSjoerg ReplaceUses(N2.getValue(1), SDValue(CNode, 2));
381106f32e7eSjoerg // Record the mem-refs
381206f32e7eSjoerg CurDAG->setNodeMemRefs(CNode, {cast<LoadSDNode>(N2)->getMemOperand()});
381306f32e7eSjoerg return CNode;
381406f32e7eSjoerg }
381506f32e7eSjoerg
381606f32e7eSjoerg SDValue Ops[] = { N0, N2, Imm, InFlag };
381706f32e7eSjoerg SDVTList VTs = CurDAG->getVTList(VT, MVT::i32, MVT::Glue);
381806f32e7eSjoerg MachineSDNode *CNode = CurDAG->getMachineNode(ROpc, dl, VTs, Ops);
381906f32e7eSjoerg InFlag = SDValue(CNode, 2);
382006f32e7eSjoerg return CNode;
382106f32e7eSjoerg }
382206f32e7eSjoerg
tryShiftAmountMod(SDNode * N)382306f32e7eSjoerg bool X86DAGToDAGISel::tryShiftAmountMod(SDNode *N) {
382406f32e7eSjoerg EVT VT = N->getValueType(0);
382506f32e7eSjoerg
382606f32e7eSjoerg // Only handle scalar shifts.
382706f32e7eSjoerg if (VT.isVector())
382806f32e7eSjoerg return false;
382906f32e7eSjoerg
383006f32e7eSjoerg // Narrower shifts only mask to 5 bits in hardware.
383106f32e7eSjoerg unsigned Size = VT == MVT::i64 ? 64 : 32;
383206f32e7eSjoerg
383306f32e7eSjoerg SDValue OrigShiftAmt = N->getOperand(1);
383406f32e7eSjoerg SDValue ShiftAmt = OrigShiftAmt;
383506f32e7eSjoerg SDLoc DL(N);
383606f32e7eSjoerg
383706f32e7eSjoerg // Skip over a truncate of the shift amount.
383806f32e7eSjoerg if (ShiftAmt->getOpcode() == ISD::TRUNCATE)
383906f32e7eSjoerg ShiftAmt = ShiftAmt->getOperand(0);
384006f32e7eSjoerg
384106f32e7eSjoerg // This function is called after X86DAGToDAGISel::matchBitExtract(),
384206f32e7eSjoerg // so we are not afraid that we might mess up BZHI/BEXTR pattern.
384306f32e7eSjoerg
384406f32e7eSjoerg SDValue NewShiftAmt;
384506f32e7eSjoerg if (ShiftAmt->getOpcode() == ISD::ADD || ShiftAmt->getOpcode() == ISD::SUB) {
384606f32e7eSjoerg SDValue Add0 = ShiftAmt->getOperand(0);
384706f32e7eSjoerg SDValue Add1 = ShiftAmt->getOperand(1);
3848*da58b97aSjoerg auto *Add0C = dyn_cast<ConstantSDNode>(Add0);
3849*da58b97aSjoerg auto *Add1C = dyn_cast<ConstantSDNode>(Add1);
385006f32e7eSjoerg // If we are shifting by X+/-N where N == 0 mod Size, then just shift by X
385106f32e7eSjoerg // to avoid the ADD/SUB.
3852*da58b97aSjoerg if (Add1C && Add1C->getAPIntValue().urem(Size) == 0) {
385306f32e7eSjoerg NewShiftAmt = Add0;
3854*da58b97aSjoerg // If we are shifting by N-X where N == 0 mod Size, then just shift by -X
3855*da58b97aSjoerg // to generate a NEG instead of a SUB of a constant.
3856*da58b97aSjoerg } else if (ShiftAmt->getOpcode() == ISD::SUB && Add0C &&
3857*da58b97aSjoerg Add0C->getZExtValue() != 0) {
3858*da58b97aSjoerg EVT SubVT = ShiftAmt.getValueType();
3859*da58b97aSjoerg SDValue X;
3860*da58b97aSjoerg if (Add0C->getZExtValue() % Size == 0)
3861*da58b97aSjoerg X = Add1;
3862*da58b97aSjoerg else if (ShiftAmt.hasOneUse() && Size == 64 &&
3863*da58b97aSjoerg Add0C->getZExtValue() % 32 == 0) {
3864*da58b97aSjoerg // We have a 64-bit shift by (n*32-x), turn it into -(x+n*32).
3865*da58b97aSjoerg // This is mainly beneficial if we already compute (x+n*32).
3866*da58b97aSjoerg if (Add1.getOpcode() == ISD::TRUNCATE) {
3867*da58b97aSjoerg Add1 = Add1.getOperand(0);
3868*da58b97aSjoerg SubVT = Add1.getValueType();
3869*da58b97aSjoerg }
3870*da58b97aSjoerg X = CurDAG->getNode(ISD::ADD, DL, SubVT, Add1,
3871*da58b97aSjoerg CurDAG->getZExtOrTrunc(Add0, DL, SubVT));
3872*da58b97aSjoerg insertDAGNode(*CurDAG, OrigShiftAmt, X);
3873*da58b97aSjoerg } else
3874*da58b97aSjoerg return false;
387506f32e7eSjoerg // Insert a negate op.
387606f32e7eSjoerg // TODO: This isn't guaranteed to replace the sub if there is a logic cone
387706f32e7eSjoerg // that uses it that's not a shift.
387806f32e7eSjoerg SDValue Zero = CurDAG->getConstant(0, DL, SubVT);
3879*da58b97aSjoerg SDValue Neg = CurDAG->getNode(ISD::SUB, DL, SubVT, Zero, X);
388006f32e7eSjoerg NewShiftAmt = Neg;
388106f32e7eSjoerg
388206f32e7eSjoerg // Insert these operands into a valid topological order so they can
388306f32e7eSjoerg // get selected independently.
388406f32e7eSjoerg insertDAGNode(*CurDAG, OrigShiftAmt, Zero);
388506f32e7eSjoerg insertDAGNode(*CurDAG, OrigShiftAmt, Neg);
388606f32e7eSjoerg } else
388706f32e7eSjoerg return false;
388806f32e7eSjoerg } else
388906f32e7eSjoerg return false;
389006f32e7eSjoerg
389106f32e7eSjoerg if (NewShiftAmt.getValueType() != MVT::i8) {
389206f32e7eSjoerg // Need to truncate the shift amount.
389306f32e7eSjoerg NewShiftAmt = CurDAG->getNode(ISD::TRUNCATE, DL, MVT::i8, NewShiftAmt);
389406f32e7eSjoerg // Add to a correct topological ordering.
389506f32e7eSjoerg insertDAGNode(*CurDAG, OrigShiftAmt, NewShiftAmt);
389606f32e7eSjoerg }
389706f32e7eSjoerg
389806f32e7eSjoerg // Insert a new mask to keep the shift amount legal. This should be removed
389906f32e7eSjoerg // by isel patterns.
390006f32e7eSjoerg NewShiftAmt = CurDAG->getNode(ISD::AND, DL, MVT::i8, NewShiftAmt,
390106f32e7eSjoerg CurDAG->getConstant(Size - 1, DL, MVT::i8));
390206f32e7eSjoerg // Place in a correct topological ordering.
390306f32e7eSjoerg insertDAGNode(*CurDAG, OrigShiftAmt, NewShiftAmt);
390406f32e7eSjoerg
390506f32e7eSjoerg SDNode *UpdatedNode = CurDAG->UpdateNodeOperands(N, N->getOperand(0),
390606f32e7eSjoerg NewShiftAmt);
390706f32e7eSjoerg if (UpdatedNode != N) {
390806f32e7eSjoerg // If we found an existing node, we should replace ourselves with that node
390906f32e7eSjoerg // and wait for it to be selected after its other users.
391006f32e7eSjoerg ReplaceNode(N, UpdatedNode);
391106f32e7eSjoerg return true;
391206f32e7eSjoerg }
391306f32e7eSjoerg
391406f32e7eSjoerg // If the original shift amount is now dead, delete it so that we don't run
391506f32e7eSjoerg // it through isel.
391606f32e7eSjoerg if (OrigShiftAmt.getNode()->use_empty())
391706f32e7eSjoerg CurDAG->RemoveDeadNode(OrigShiftAmt.getNode());
391806f32e7eSjoerg
391906f32e7eSjoerg // Now that we've optimized the shift amount, defer to normal isel to get
392006f32e7eSjoerg // load folding and legacy vs BMI2 selection without repeating it here.
392106f32e7eSjoerg SelectCode(N);
392206f32e7eSjoerg return true;
392306f32e7eSjoerg }
392406f32e7eSjoerg
tryShrinkShlLogicImm(SDNode * N)392506f32e7eSjoerg bool X86DAGToDAGISel::tryShrinkShlLogicImm(SDNode *N) {
392606f32e7eSjoerg MVT NVT = N->getSimpleValueType(0);
392706f32e7eSjoerg unsigned Opcode = N->getOpcode();
392806f32e7eSjoerg SDLoc dl(N);
392906f32e7eSjoerg
393006f32e7eSjoerg // For operations of the form (x << C1) op C2, check if we can use a smaller
393106f32e7eSjoerg // encoding for C2 by transforming it into (x op (C2>>C1)) << C1.
393206f32e7eSjoerg SDValue Shift = N->getOperand(0);
393306f32e7eSjoerg SDValue N1 = N->getOperand(1);
393406f32e7eSjoerg
393506f32e7eSjoerg ConstantSDNode *Cst = dyn_cast<ConstantSDNode>(N1);
393606f32e7eSjoerg if (!Cst)
393706f32e7eSjoerg return false;
393806f32e7eSjoerg
393906f32e7eSjoerg int64_t Val = Cst->getSExtValue();
394006f32e7eSjoerg
394106f32e7eSjoerg // If we have an any_extend feeding the AND, look through it to see if there
394206f32e7eSjoerg // is a shift behind it. But only if the AND doesn't use the extended bits.
394306f32e7eSjoerg // FIXME: Generalize this to other ANY_EXTEND than i32 to i64?
394406f32e7eSjoerg bool FoundAnyExtend = false;
394506f32e7eSjoerg if (Shift.getOpcode() == ISD::ANY_EXTEND && Shift.hasOneUse() &&
394606f32e7eSjoerg Shift.getOperand(0).getSimpleValueType() == MVT::i32 &&
394706f32e7eSjoerg isUInt<32>(Val)) {
394806f32e7eSjoerg FoundAnyExtend = true;
394906f32e7eSjoerg Shift = Shift.getOperand(0);
395006f32e7eSjoerg }
395106f32e7eSjoerg
395206f32e7eSjoerg if (Shift.getOpcode() != ISD::SHL || !Shift.hasOneUse())
395306f32e7eSjoerg return false;
395406f32e7eSjoerg
395506f32e7eSjoerg // i8 is unshrinkable, i16 should be promoted to i32.
395606f32e7eSjoerg if (NVT != MVT::i32 && NVT != MVT::i64)
395706f32e7eSjoerg return false;
395806f32e7eSjoerg
395906f32e7eSjoerg ConstantSDNode *ShlCst = dyn_cast<ConstantSDNode>(Shift.getOperand(1));
396006f32e7eSjoerg if (!ShlCst)
396106f32e7eSjoerg return false;
396206f32e7eSjoerg
396306f32e7eSjoerg uint64_t ShAmt = ShlCst->getZExtValue();
396406f32e7eSjoerg
396506f32e7eSjoerg // Make sure that we don't change the operation by removing bits.
396606f32e7eSjoerg // This only matters for OR and XOR, AND is unaffected.
396706f32e7eSjoerg uint64_t RemovedBitsMask = (1ULL << ShAmt) - 1;
396806f32e7eSjoerg if (Opcode != ISD::AND && (Val & RemovedBitsMask) != 0)
396906f32e7eSjoerg return false;
397006f32e7eSjoerg
397106f32e7eSjoerg // Check the minimum bitwidth for the new constant.
397206f32e7eSjoerg // TODO: Using 16 and 8 bit operations is also possible for or32 & xor32.
397306f32e7eSjoerg auto CanShrinkImmediate = [&](int64_t &ShiftedVal) {
397406f32e7eSjoerg if (Opcode == ISD::AND) {
397506f32e7eSjoerg // AND32ri is the same as AND64ri32 with zext imm.
397606f32e7eSjoerg // Try this before sign extended immediates below.
397706f32e7eSjoerg ShiftedVal = (uint64_t)Val >> ShAmt;
397806f32e7eSjoerg if (NVT == MVT::i64 && !isUInt<32>(Val) && isUInt<32>(ShiftedVal))
397906f32e7eSjoerg return true;
398006f32e7eSjoerg // Also swap order when the AND can become MOVZX.
398106f32e7eSjoerg if (ShiftedVal == UINT8_MAX || ShiftedVal == UINT16_MAX)
398206f32e7eSjoerg return true;
398306f32e7eSjoerg }
398406f32e7eSjoerg ShiftedVal = Val >> ShAmt;
398506f32e7eSjoerg if ((!isInt<8>(Val) && isInt<8>(ShiftedVal)) ||
398606f32e7eSjoerg (!isInt<32>(Val) && isInt<32>(ShiftedVal)))
398706f32e7eSjoerg return true;
398806f32e7eSjoerg if (Opcode != ISD::AND) {
398906f32e7eSjoerg // MOV32ri+OR64r/XOR64r is cheaper than MOV64ri64+OR64rr/XOR64rr
399006f32e7eSjoerg ShiftedVal = (uint64_t)Val >> ShAmt;
399106f32e7eSjoerg if (NVT == MVT::i64 && !isUInt<32>(Val) && isUInt<32>(ShiftedVal))
399206f32e7eSjoerg return true;
399306f32e7eSjoerg }
399406f32e7eSjoerg return false;
399506f32e7eSjoerg };
399606f32e7eSjoerg
399706f32e7eSjoerg int64_t ShiftedVal;
399806f32e7eSjoerg if (!CanShrinkImmediate(ShiftedVal))
399906f32e7eSjoerg return false;
400006f32e7eSjoerg
400106f32e7eSjoerg // Ok, we can reorder to get a smaller immediate.
400206f32e7eSjoerg
400306f32e7eSjoerg // But, its possible the original immediate allowed an AND to become MOVZX.
400406f32e7eSjoerg // Doing this late due to avoid the MakedValueIsZero call as late as
400506f32e7eSjoerg // possible.
400606f32e7eSjoerg if (Opcode == ISD::AND) {
400706f32e7eSjoerg // Find the smallest zext this could possibly be.
400806f32e7eSjoerg unsigned ZExtWidth = Cst->getAPIntValue().getActiveBits();
400906f32e7eSjoerg ZExtWidth = PowerOf2Ceil(std::max(ZExtWidth, 8U));
401006f32e7eSjoerg
401106f32e7eSjoerg // Figure out which bits need to be zero to achieve that mask.
401206f32e7eSjoerg APInt NeededMask = APInt::getLowBitsSet(NVT.getSizeInBits(),
401306f32e7eSjoerg ZExtWidth);
401406f32e7eSjoerg NeededMask &= ~Cst->getAPIntValue();
401506f32e7eSjoerg
401606f32e7eSjoerg if (CurDAG->MaskedValueIsZero(N->getOperand(0), NeededMask))
401706f32e7eSjoerg return false;
401806f32e7eSjoerg }
401906f32e7eSjoerg
402006f32e7eSjoerg SDValue X = Shift.getOperand(0);
402106f32e7eSjoerg if (FoundAnyExtend) {
402206f32e7eSjoerg SDValue NewX = CurDAG->getNode(ISD::ANY_EXTEND, dl, NVT, X);
402306f32e7eSjoerg insertDAGNode(*CurDAG, SDValue(N, 0), NewX);
402406f32e7eSjoerg X = NewX;
402506f32e7eSjoerg }
402606f32e7eSjoerg
402706f32e7eSjoerg SDValue NewCst = CurDAG->getConstant(ShiftedVal, dl, NVT);
402806f32e7eSjoerg insertDAGNode(*CurDAG, SDValue(N, 0), NewCst);
402906f32e7eSjoerg SDValue NewBinOp = CurDAG->getNode(Opcode, dl, NVT, X, NewCst);
403006f32e7eSjoerg insertDAGNode(*CurDAG, SDValue(N, 0), NewBinOp);
403106f32e7eSjoerg SDValue NewSHL = CurDAG->getNode(ISD::SHL, dl, NVT, NewBinOp,
403206f32e7eSjoerg Shift.getOperand(1));
403306f32e7eSjoerg ReplaceNode(N, NewSHL.getNode());
403406f32e7eSjoerg SelectCode(NewSHL.getNode());
403506f32e7eSjoerg return true;
403606f32e7eSjoerg }
403706f32e7eSjoerg
matchVPTERNLOG(SDNode * Root,SDNode * ParentA,SDNode * ParentBC,SDValue A,SDValue B,SDValue C,uint8_t Imm)4038*da58b97aSjoerg bool X86DAGToDAGISel::matchVPTERNLOG(SDNode *Root, SDNode *ParentA,
4039*da58b97aSjoerg SDNode *ParentBC, SDValue A, SDValue B,
4040*da58b97aSjoerg SDValue C, uint8_t Imm) {
4041*da58b97aSjoerg assert(A.isOperandOf(ParentA));
4042*da58b97aSjoerg assert(B.isOperandOf(ParentBC));
4043*da58b97aSjoerg assert(C.isOperandOf(ParentBC));
404406f32e7eSjoerg
4045*da58b97aSjoerg auto tryFoldLoadOrBCast =
4046*da58b97aSjoerg [this](SDNode *Root, SDNode *P, SDValue &L, SDValue &Base, SDValue &Scale,
4047*da58b97aSjoerg SDValue &Index, SDValue &Disp, SDValue &Segment) {
4048*da58b97aSjoerg if (tryFoldLoad(Root, P, L, Base, Scale, Index, Disp, Segment))
4049*da58b97aSjoerg return true;
405006f32e7eSjoerg
4051*da58b97aSjoerg // Not a load, check for broadcast which may be behind a bitcast.
4052*da58b97aSjoerg if (L.getOpcode() == ISD::BITCAST && L.hasOneUse()) {
4053*da58b97aSjoerg P = L.getNode();
4054*da58b97aSjoerg L = L.getOperand(0);
4055*da58b97aSjoerg }
405606f32e7eSjoerg
4057*da58b97aSjoerg if (L.getOpcode() != X86ISD::VBROADCAST_LOAD)
405806f32e7eSjoerg return false;
405906f32e7eSjoerg
4060*da58b97aSjoerg // Only 32 and 64 bit broadcasts are supported.
4061*da58b97aSjoerg auto *MemIntr = cast<MemIntrinsicSDNode>(L);
4062*da58b97aSjoerg unsigned Size = MemIntr->getMemoryVT().getSizeInBits();
4063*da58b97aSjoerg if (Size != 32 && Size != 64)
4064*da58b97aSjoerg return false;
406506f32e7eSjoerg
4066*da58b97aSjoerg return tryFoldBroadcast(Root, P, L, Base, Scale, Index, Disp, Segment);
4067*da58b97aSjoerg };
406806f32e7eSjoerg
4069*da58b97aSjoerg bool FoldedLoad = false;
4070*da58b97aSjoerg SDValue Tmp0, Tmp1, Tmp2, Tmp3, Tmp4;
4071*da58b97aSjoerg if (tryFoldLoadOrBCast(Root, ParentBC, C, Tmp0, Tmp1, Tmp2, Tmp3, Tmp4)) {
4072*da58b97aSjoerg FoldedLoad = true;
4073*da58b97aSjoerg } else if (tryFoldLoadOrBCast(Root, ParentA, A, Tmp0, Tmp1, Tmp2, Tmp3,
4074*da58b97aSjoerg Tmp4)) {
4075*da58b97aSjoerg FoldedLoad = true;
4076*da58b97aSjoerg std::swap(A, C);
4077*da58b97aSjoerg // Swap bits 1/4 and 3/6.
4078*da58b97aSjoerg uint8_t OldImm = Imm;
4079*da58b97aSjoerg Imm = OldImm & 0xa5;
4080*da58b97aSjoerg if (OldImm & 0x02) Imm |= 0x10;
4081*da58b97aSjoerg if (OldImm & 0x10) Imm |= 0x02;
4082*da58b97aSjoerg if (OldImm & 0x08) Imm |= 0x40;
4083*da58b97aSjoerg if (OldImm & 0x40) Imm |= 0x08;
4084*da58b97aSjoerg } else if (tryFoldLoadOrBCast(Root, ParentBC, B, Tmp0, Tmp1, Tmp2, Tmp3,
4085*da58b97aSjoerg Tmp4)) {
4086*da58b97aSjoerg FoldedLoad = true;
4087*da58b97aSjoerg std::swap(B, C);
4088*da58b97aSjoerg // Swap bits 1/2 and 5/6.
4089*da58b97aSjoerg uint8_t OldImm = Imm;
4090*da58b97aSjoerg Imm = OldImm & 0x99;
4091*da58b97aSjoerg if (OldImm & 0x02) Imm |= 0x04;
4092*da58b97aSjoerg if (OldImm & 0x04) Imm |= 0x02;
4093*da58b97aSjoerg if (OldImm & 0x20) Imm |= 0x40;
4094*da58b97aSjoerg if (OldImm & 0x40) Imm |= 0x20;
4095*da58b97aSjoerg }
409606f32e7eSjoerg
4097*da58b97aSjoerg SDLoc DL(Root);
409806f32e7eSjoerg
4099*da58b97aSjoerg SDValue TImm = CurDAG->getTargetConstant(Imm, DL, MVT::i8);
410006f32e7eSjoerg
4101*da58b97aSjoerg MVT NVT = Root->getSimpleValueType(0);
4102*da58b97aSjoerg
4103*da58b97aSjoerg MachineSDNode *MNode;
4104*da58b97aSjoerg if (FoldedLoad) {
4105*da58b97aSjoerg SDVTList VTs = CurDAG->getVTList(NVT, MVT::Other);
4106*da58b97aSjoerg
4107*da58b97aSjoerg unsigned Opc;
4108*da58b97aSjoerg if (C.getOpcode() == X86ISD::VBROADCAST_LOAD) {
4109*da58b97aSjoerg auto *MemIntr = cast<MemIntrinsicSDNode>(C);
4110*da58b97aSjoerg unsigned EltSize = MemIntr->getMemoryVT().getSizeInBits();
4111*da58b97aSjoerg assert((EltSize == 32 || EltSize == 64) && "Unexpected broadcast size!");
4112*da58b97aSjoerg
4113*da58b97aSjoerg bool UseD = EltSize == 32;
4114*da58b97aSjoerg if (NVT.is128BitVector())
4115*da58b97aSjoerg Opc = UseD ? X86::VPTERNLOGDZ128rmbi : X86::VPTERNLOGQZ128rmbi;
4116*da58b97aSjoerg else if (NVT.is256BitVector())
4117*da58b97aSjoerg Opc = UseD ? X86::VPTERNLOGDZ256rmbi : X86::VPTERNLOGQZ256rmbi;
4118*da58b97aSjoerg else if (NVT.is512BitVector())
4119*da58b97aSjoerg Opc = UseD ? X86::VPTERNLOGDZrmbi : X86::VPTERNLOGQZrmbi;
4120*da58b97aSjoerg else
4121*da58b97aSjoerg llvm_unreachable("Unexpected vector size!");
4122*da58b97aSjoerg } else {
4123*da58b97aSjoerg bool UseD = NVT.getVectorElementType() == MVT::i32;
4124*da58b97aSjoerg if (NVT.is128BitVector())
4125*da58b97aSjoerg Opc = UseD ? X86::VPTERNLOGDZ128rmi : X86::VPTERNLOGQZ128rmi;
4126*da58b97aSjoerg else if (NVT.is256BitVector())
4127*da58b97aSjoerg Opc = UseD ? X86::VPTERNLOGDZ256rmi : X86::VPTERNLOGQZ256rmi;
4128*da58b97aSjoerg else if (NVT.is512BitVector())
4129*da58b97aSjoerg Opc = UseD ? X86::VPTERNLOGDZrmi : X86::VPTERNLOGQZrmi;
4130*da58b97aSjoerg else
4131*da58b97aSjoerg llvm_unreachable("Unexpected vector size!");
4132*da58b97aSjoerg }
4133*da58b97aSjoerg
4134*da58b97aSjoerg SDValue Ops[] = {A, B, Tmp0, Tmp1, Tmp2, Tmp3, Tmp4, TImm, C.getOperand(0)};
4135*da58b97aSjoerg MNode = CurDAG->getMachineNode(Opc, DL, VTs, Ops);
4136*da58b97aSjoerg
4137*da58b97aSjoerg // Update the chain.
4138*da58b97aSjoerg ReplaceUses(C.getValue(1), SDValue(MNode, 1));
4139*da58b97aSjoerg // Record the mem-refs
4140*da58b97aSjoerg CurDAG->setNodeMemRefs(MNode, {cast<MemSDNode>(C)->getMemOperand()});
4141*da58b97aSjoerg } else {
4142*da58b97aSjoerg bool UseD = NVT.getVectorElementType() == MVT::i32;
4143*da58b97aSjoerg unsigned Opc;
4144*da58b97aSjoerg if (NVT.is128BitVector())
4145*da58b97aSjoerg Opc = UseD ? X86::VPTERNLOGDZ128rri : X86::VPTERNLOGQZ128rri;
4146*da58b97aSjoerg else if (NVT.is256BitVector())
4147*da58b97aSjoerg Opc = UseD ? X86::VPTERNLOGDZ256rri : X86::VPTERNLOGQZ256rri;
4148*da58b97aSjoerg else if (NVT.is512BitVector())
4149*da58b97aSjoerg Opc = UseD ? X86::VPTERNLOGDZrri : X86::VPTERNLOGQZrri;
4150*da58b97aSjoerg else
4151*da58b97aSjoerg llvm_unreachable("Unexpected vector size!");
4152*da58b97aSjoerg
4153*da58b97aSjoerg MNode = CurDAG->getMachineNode(Opc, DL, NVT, {A, B, C, TImm});
4154*da58b97aSjoerg }
4155*da58b97aSjoerg
4156*da58b97aSjoerg ReplaceUses(SDValue(Root, 0), SDValue(MNode, 0));
4157*da58b97aSjoerg CurDAG->RemoveDeadNode(Root);
415806f32e7eSjoerg return true;
415906f32e7eSjoerg }
416006f32e7eSjoerg
4161*da58b97aSjoerg // Try to match two logic ops to a VPTERNLOG.
4162*da58b97aSjoerg // FIXME: Handle inverted inputs?
4163*da58b97aSjoerg // FIXME: Handle more complex patterns that use an operand more than once?
tryVPTERNLOG(SDNode * N)4164*da58b97aSjoerg bool X86DAGToDAGISel::tryVPTERNLOG(SDNode *N) {
4165*da58b97aSjoerg MVT NVT = N->getSimpleValueType(0);
4166*da58b97aSjoerg
4167*da58b97aSjoerg // Make sure we support VPTERNLOG.
4168*da58b97aSjoerg if (!NVT.isVector() || !Subtarget->hasAVX512() ||
4169*da58b97aSjoerg NVT.getVectorElementType() == MVT::i1)
4170*da58b97aSjoerg return false;
4171*da58b97aSjoerg
4172*da58b97aSjoerg // We need VLX for 128/256-bit.
4173*da58b97aSjoerg if (!(Subtarget->hasVLX() || NVT.is512BitVector()))
4174*da58b97aSjoerg return false;
4175*da58b97aSjoerg
4176*da58b97aSjoerg SDValue N0 = N->getOperand(0);
4177*da58b97aSjoerg SDValue N1 = N->getOperand(1);
4178*da58b97aSjoerg
4179*da58b97aSjoerg auto getFoldableLogicOp = [](SDValue Op) {
4180*da58b97aSjoerg // Peek through single use bitcast.
4181*da58b97aSjoerg if (Op.getOpcode() == ISD::BITCAST && Op.hasOneUse())
4182*da58b97aSjoerg Op = Op.getOperand(0);
4183*da58b97aSjoerg
4184*da58b97aSjoerg if (!Op.hasOneUse())
4185*da58b97aSjoerg return SDValue();
4186*da58b97aSjoerg
4187*da58b97aSjoerg unsigned Opc = Op.getOpcode();
4188*da58b97aSjoerg if (Opc == ISD::AND || Opc == ISD::OR || Opc == ISD::XOR ||
4189*da58b97aSjoerg Opc == X86ISD::ANDNP)
4190*da58b97aSjoerg return Op;
4191*da58b97aSjoerg
4192*da58b97aSjoerg return SDValue();
4193*da58b97aSjoerg };
4194*da58b97aSjoerg
4195*da58b97aSjoerg SDValue A, FoldableOp;
4196*da58b97aSjoerg if ((FoldableOp = getFoldableLogicOp(N1))) {
4197*da58b97aSjoerg A = N0;
4198*da58b97aSjoerg } else if ((FoldableOp = getFoldableLogicOp(N0))) {
4199*da58b97aSjoerg A = N1;
4200*da58b97aSjoerg } else
4201*da58b97aSjoerg return false;
4202*da58b97aSjoerg
4203*da58b97aSjoerg SDValue B = FoldableOp.getOperand(0);
4204*da58b97aSjoerg SDValue C = FoldableOp.getOperand(1);
4205*da58b97aSjoerg
4206*da58b97aSjoerg // We can build the appropriate control immediate by performing the logic
4207*da58b97aSjoerg // operation we're matching using these constants for A, B, and C.
4208*da58b97aSjoerg const uint8_t TernlogMagicA = 0xf0;
4209*da58b97aSjoerg const uint8_t TernlogMagicB = 0xcc;
4210*da58b97aSjoerg const uint8_t TernlogMagicC = 0xaa;
4211*da58b97aSjoerg
4212*da58b97aSjoerg uint8_t Imm;
4213*da58b97aSjoerg switch (FoldableOp.getOpcode()) {
4214*da58b97aSjoerg default: llvm_unreachable("Unexpected opcode!");
4215*da58b97aSjoerg case ISD::AND: Imm = TernlogMagicB & TernlogMagicC; break;
4216*da58b97aSjoerg case ISD::OR: Imm = TernlogMagicB | TernlogMagicC; break;
4217*da58b97aSjoerg case ISD::XOR: Imm = TernlogMagicB ^ TernlogMagicC; break;
4218*da58b97aSjoerg case X86ISD::ANDNP: Imm = ~(TernlogMagicB) & TernlogMagicC; break;
4219*da58b97aSjoerg }
4220*da58b97aSjoerg
4221*da58b97aSjoerg switch (N->getOpcode()) {
4222*da58b97aSjoerg default: llvm_unreachable("Unexpected opcode!");
4223*da58b97aSjoerg case X86ISD::ANDNP:
4224*da58b97aSjoerg if (A == N0)
4225*da58b97aSjoerg Imm &= ~TernlogMagicA;
4226*da58b97aSjoerg else
4227*da58b97aSjoerg Imm = ~(Imm) & TernlogMagicA;
4228*da58b97aSjoerg break;
4229*da58b97aSjoerg case ISD::AND: Imm &= TernlogMagicA; break;
4230*da58b97aSjoerg case ISD::OR: Imm |= TernlogMagicA; break;
4231*da58b97aSjoerg case ISD::XOR: Imm ^= TernlogMagicA; break;
4232*da58b97aSjoerg }
4233*da58b97aSjoerg
4234*da58b97aSjoerg return matchVPTERNLOG(N, N, FoldableOp.getNode(), A, B, C, Imm);
4235*da58b97aSjoerg }
4236*da58b97aSjoerg
423706f32e7eSjoerg /// If the high bits of an 'and' operand are known zero, try setting the
423806f32e7eSjoerg /// high bits of an 'and' constant operand to produce a smaller encoding by
423906f32e7eSjoerg /// creating a small, sign-extended negative immediate rather than a large
424006f32e7eSjoerg /// positive one. This reverses a transform in SimplifyDemandedBits that
424106f32e7eSjoerg /// shrinks mask constants by clearing bits. There is also a possibility that
424206f32e7eSjoerg /// the 'and' mask can be made -1, so the 'and' itself is unnecessary. In that
424306f32e7eSjoerg /// case, just replace the 'and'. Return 'true' if the node is replaced.
shrinkAndImmediate(SDNode * And)424406f32e7eSjoerg bool X86DAGToDAGISel::shrinkAndImmediate(SDNode *And) {
424506f32e7eSjoerg // i8 is unshrinkable, i16 should be promoted to i32, and vector ops don't
424606f32e7eSjoerg // have immediate operands.
424706f32e7eSjoerg MVT VT = And->getSimpleValueType(0);
424806f32e7eSjoerg if (VT != MVT::i32 && VT != MVT::i64)
424906f32e7eSjoerg return false;
425006f32e7eSjoerg
425106f32e7eSjoerg auto *And1C = dyn_cast<ConstantSDNode>(And->getOperand(1));
425206f32e7eSjoerg if (!And1C)
425306f32e7eSjoerg return false;
425406f32e7eSjoerg
425506f32e7eSjoerg // Bail out if the mask constant is already negative. It's can't shrink more.
425606f32e7eSjoerg // If the upper 32 bits of a 64 bit mask are all zeros, we have special isel
425706f32e7eSjoerg // patterns to use a 32-bit and instead of a 64-bit and by relying on the
425806f32e7eSjoerg // implicit zeroing of 32 bit ops. So we should check if the lower 32 bits
425906f32e7eSjoerg // are negative too.
426006f32e7eSjoerg APInt MaskVal = And1C->getAPIntValue();
426106f32e7eSjoerg unsigned MaskLZ = MaskVal.countLeadingZeros();
426206f32e7eSjoerg if (!MaskLZ || (VT == MVT::i64 && MaskLZ == 32))
426306f32e7eSjoerg return false;
426406f32e7eSjoerg
426506f32e7eSjoerg // Don't extend into the upper 32 bits of a 64 bit mask.
426606f32e7eSjoerg if (VT == MVT::i64 && MaskLZ >= 32) {
426706f32e7eSjoerg MaskLZ -= 32;
426806f32e7eSjoerg MaskVal = MaskVal.trunc(32);
426906f32e7eSjoerg }
427006f32e7eSjoerg
427106f32e7eSjoerg SDValue And0 = And->getOperand(0);
427206f32e7eSjoerg APInt HighZeros = APInt::getHighBitsSet(MaskVal.getBitWidth(), MaskLZ);
427306f32e7eSjoerg APInt NegMaskVal = MaskVal | HighZeros;
427406f32e7eSjoerg
427506f32e7eSjoerg // If a negative constant would not allow a smaller encoding, there's no need
427606f32e7eSjoerg // to continue. Only change the constant when we know it's a win.
427706f32e7eSjoerg unsigned MinWidth = NegMaskVal.getMinSignedBits();
427806f32e7eSjoerg if (MinWidth > 32 || (MinWidth > 8 && MaskVal.getMinSignedBits() <= 32))
427906f32e7eSjoerg return false;
428006f32e7eSjoerg
428106f32e7eSjoerg // Extend masks if we truncated above.
428206f32e7eSjoerg if (VT == MVT::i64 && MaskVal.getBitWidth() < 64) {
428306f32e7eSjoerg NegMaskVal = NegMaskVal.zext(64);
428406f32e7eSjoerg HighZeros = HighZeros.zext(64);
428506f32e7eSjoerg }
428606f32e7eSjoerg
428706f32e7eSjoerg // The variable operand must be all zeros in the top bits to allow using the
428806f32e7eSjoerg // new, negative constant as the mask.
428906f32e7eSjoerg if (!CurDAG->MaskedValueIsZero(And0, HighZeros))
429006f32e7eSjoerg return false;
429106f32e7eSjoerg
429206f32e7eSjoerg // Check if the mask is -1. In that case, this is an unnecessary instruction
429306f32e7eSjoerg // that escaped earlier analysis.
429406f32e7eSjoerg if (NegMaskVal.isAllOnesValue()) {
429506f32e7eSjoerg ReplaceNode(And, And0.getNode());
429606f32e7eSjoerg return true;
429706f32e7eSjoerg }
429806f32e7eSjoerg
429906f32e7eSjoerg // A negative mask allows a smaller encoding. Create a new 'and' node.
430006f32e7eSjoerg SDValue NewMask = CurDAG->getConstant(NegMaskVal, SDLoc(And), VT);
4301*da58b97aSjoerg insertDAGNode(*CurDAG, SDValue(And, 0), NewMask);
430206f32e7eSjoerg SDValue NewAnd = CurDAG->getNode(ISD::AND, SDLoc(And), VT, And0, NewMask);
430306f32e7eSjoerg ReplaceNode(And, NewAnd.getNode());
430406f32e7eSjoerg SelectCode(NewAnd.getNode());
430506f32e7eSjoerg return true;
430606f32e7eSjoerg }
430706f32e7eSjoerg
getVPTESTMOpc(MVT TestVT,bool IsTestN,bool FoldedLoad,bool FoldedBCast,bool Masked)430806f32e7eSjoerg static unsigned getVPTESTMOpc(MVT TestVT, bool IsTestN, bool FoldedLoad,
430906f32e7eSjoerg bool FoldedBCast, bool Masked) {
4310*da58b97aSjoerg #define VPTESTM_CASE(VT, SUFFIX) \
4311*da58b97aSjoerg case MVT::VT: \
4312*da58b97aSjoerg if (Masked) \
4313*da58b97aSjoerg return IsTestN ? X86::VPTESTNM##SUFFIX##k: X86::VPTESTM##SUFFIX##k; \
4314*da58b97aSjoerg return IsTestN ? X86::VPTESTNM##SUFFIX : X86::VPTESTM##SUFFIX;
4315*da58b97aSjoerg
4316*da58b97aSjoerg
4317*da58b97aSjoerg #define VPTESTM_BROADCAST_CASES(SUFFIX) \
4318*da58b97aSjoerg default: llvm_unreachable("Unexpected VT!"); \
4319*da58b97aSjoerg VPTESTM_CASE(v4i32, DZ128##SUFFIX) \
4320*da58b97aSjoerg VPTESTM_CASE(v2i64, QZ128##SUFFIX) \
4321*da58b97aSjoerg VPTESTM_CASE(v8i32, DZ256##SUFFIX) \
4322*da58b97aSjoerg VPTESTM_CASE(v4i64, QZ256##SUFFIX) \
4323*da58b97aSjoerg VPTESTM_CASE(v16i32, DZ##SUFFIX) \
4324*da58b97aSjoerg VPTESTM_CASE(v8i64, QZ##SUFFIX)
4325*da58b97aSjoerg
4326*da58b97aSjoerg #define VPTESTM_FULL_CASES(SUFFIX) \
4327*da58b97aSjoerg VPTESTM_BROADCAST_CASES(SUFFIX) \
4328*da58b97aSjoerg VPTESTM_CASE(v16i8, BZ128##SUFFIX) \
4329*da58b97aSjoerg VPTESTM_CASE(v8i16, WZ128##SUFFIX) \
4330*da58b97aSjoerg VPTESTM_CASE(v32i8, BZ256##SUFFIX) \
4331*da58b97aSjoerg VPTESTM_CASE(v16i16, WZ256##SUFFIX) \
4332*da58b97aSjoerg VPTESTM_CASE(v64i8, BZ##SUFFIX) \
4333*da58b97aSjoerg VPTESTM_CASE(v32i16, WZ##SUFFIX)
433406f32e7eSjoerg
433506f32e7eSjoerg if (FoldedBCast) {
433606f32e7eSjoerg switch (TestVT.SimpleTy) {
4337*da58b97aSjoerg VPTESTM_BROADCAST_CASES(rmb)
433806f32e7eSjoerg }
433906f32e7eSjoerg }
434006f32e7eSjoerg
434106f32e7eSjoerg if (FoldedLoad) {
434206f32e7eSjoerg switch (TestVT.SimpleTy) {
4343*da58b97aSjoerg VPTESTM_FULL_CASES(rm)
434406f32e7eSjoerg }
434506f32e7eSjoerg }
434606f32e7eSjoerg
434706f32e7eSjoerg switch (TestVT.SimpleTy) {
4348*da58b97aSjoerg VPTESTM_FULL_CASES(rr)
434906f32e7eSjoerg }
4350*da58b97aSjoerg
4351*da58b97aSjoerg #undef VPTESTM_FULL_CASES
4352*da58b97aSjoerg #undef VPTESTM_BROADCAST_CASES
4353*da58b97aSjoerg #undef VPTESTM_CASE
435406f32e7eSjoerg }
435506f32e7eSjoerg
435606f32e7eSjoerg // Try to create VPTESTM instruction. If InMask is not null, it will be used
435706f32e7eSjoerg // to form a masked operation.
tryVPTESTM(SDNode * Root,SDValue Setcc,SDValue InMask)435806f32e7eSjoerg bool X86DAGToDAGISel::tryVPTESTM(SDNode *Root, SDValue Setcc,
435906f32e7eSjoerg SDValue InMask) {
436006f32e7eSjoerg assert(Subtarget->hasAVX512() && "Expected AVX512!");
436106f32e7eSjoerg assert(Setcc.getSimpleValueType().getVectorElementType() == MVT::i1 &&
436206f32e7eSjoerg "Unexpected VT!");
436306f32e7eSjoerg
436406f32e7eSjoerg // Look for equal and not equal compares.
436506f32e7eSjoerg ISD::CondCode CC = cast<CondCodeSDNode>(Setcc.getOperand(2))->get();
436606f32e7eSjoerg if (CC != ISD::SETEQ && CC != ISD::SETNE)
436706f32e7eSjoerg return false;
436806f32e7eSjoerg
436906f32e7eSjoerg SDValue SetccOp0 = Setcc.getOperand(0);
437006f32e7eSjoerg SDValue SetccOp1 = Setcc.getOperand(1);
437106f32e7eSjoerg
437206f32e7eSjoerg // Canonicalize the all zero vector to the RHS.
437306f32e7eSjoerg if (ISD::isBuildVectorAllZeros(SetccOp0.getNode()))
437406f32e7eSjoerg std::swap(SetccOp0, SetccOp1);
437506f32e7eSjoerg
437606f32e7eSjoerg // See if we're comparing against zero.
437706f32e7eSjoerg if (!ISD::isBuildVectorAllZeros(SetccOp1.getNode()))
437806f32e7eSjoerg return false;
437906f32e7eSjoerg
438006f32e7eSjoerg SDValue N0 = SetccOp0;
438106f32e7eSjoerg
438206f32e7eSjoerg MVT CmpVT = N0.getSimpleValueType();
438306f32e7eSjoerg MVT CmpSVT = CmpVT.getVectorElementType();
438406f32e7eSjoerg
438506f32e7eSjoerg // Start with both operands the same. We'll try to refine this.
438606f32e7eSjoerg SDValue Src0 = N0;
438706f32e7eSjoerg SDValue Src1 = N0;
438806f32e7eSjoerg
438906f32e7eSjoerg {
439006f32e7eSjoerg // Look through single use bitcasts.
439106f32e7eSjoerg SDValue N0Temp = N0;
439206f32e7eSjoerg if (N0Temp.getOpcode() == ISD::BITCAST && N0Temp.hasOneUse())
439306f32e7eSjoerg N0Temp = N0.getOperand(0);
439406f32e7eSjoerg
439506f32e7eSjoerg // Look for single use AND.
439606f32e7eSjoerg if (N0Temp.getOpcode() == ISD::AND && N0Temp.hasOneUse()) {
439706f32e7eSjoerg Src0 = N0Temp.getOperand(0);
439806f32e7eSjoerg Src1 = N0Temp.getOperand(1);
439906f32e7eSjoerg }
440006f32e7eSjoerg }
440106f32e7eSjoerg
4402*da58b97aSjoerg // Without VLX we need to widen the operation.
440306f32e7eSjoerg bool Widen = !Subtarget->hasVLX() && !CmpVT.is512BitVector();
440406f32e7eSjoerg
4405*da58b97aSjoerg auto tryFoldLoadOrBCast = [&](SDNode *Root, SDNode *P, SDValue &L,
4406*da58b97aSjoerg SDValue &Base, SDValue &Scale, SDValue &Index,
4407*da58b97aSjoerg SDValue &Disp, SDValue &Segment) {
4408*da58b97aSjoerg // If we need to widen, we can't fold the load.
4409*da58b97aSjoerg if (!Widen)
4410*da58b97aSjoerg if (tryFoldLoad(Root, P, L, Base, Scale, Index, Disp, Segment))
4411*da58b97aSjoerg return true;
4412*da58b97aSjoerg
4413*da58b97aSjoerg // If we didn't fold a load, try to match broadcast. No widening limitation
4414*da58b97aSjoerg // for this. But only 32 and 64 bit types are supported.
4415*da58b97aSjoerg if (CmpSVT != MVT::i32 && CmpSVT != MVT::i64)
4416*da58b97aSjoerg return false;
4417*da58b97aSjoerg
4418*da58b97aSjoerg // Look through single use bitcasts.
4419*da58b97aSjoerg if (L.getOpcode() == ISD::BITCAST && L.hasOneUse()) {
4420*da58b97aSjoerg P = L.getNode();
4421*da58b97aSjoerg L = L.getOperand(0);
4422*da58b97aSjoerg }
4423*da58b97aSjoerg
4424*da58b97aSjoerg if (L.getOpcode() != X86ISD::VBROADCAST_LOAD)
4425*da58b97aSjoerg return false;
4426*da58b97aSjoerg
4427*da58b97aSjoerg auto *MemIntr = cast<MemIntrinsicSDNode>(L);
4428*da58b97aSjoerg if (MemIntr->getMemoryVT().getSizeInBits() != CmpSVT.getSizeInBits())
4429*da58b97aSjoerg return false;
4430*da58b97aSjoerg
4431*da58b97aSjoerg return tryFoldBroadcast(Root, P, L, Base, Scale, Index, Disp, Segment);
4432*da58b97aSjoerg };
4433*da58b97aSjoerg
443406f32e7eSjoerg // We can only fold loads if the sources are unique.
443506f32e7eSjoerg bool CanFoldLoads = Src0 != Src1;
443606f32e7eSjoerg
443706f32e7eSjoerg bool FoldedLoad = false;
4438*da58b97aSjoerg SDValue Tmp0, Tmp1, Tmp2, Tmp3, Tmp4;
4439*da58b97aSjoerg if (CanFoldLoads) {
4440*da58b97aSjoerg FoldedLoad = tryFoldLoadOrBCast(Root, N0.getNode(), Src1, Tmp0, Tmp1, Tmp2,
444106f32e7eSjoerg Tmp3, Tmp4);
4442*da58b97aSjoerg if (!FoldedLoad) {
4443*da58b97aSjoerg // And is commutative.
4444*da58b97aSjoerg FoldedLoad = tryFoldLoadOrBCast(Root, N0.getNode(), Src0, Tmp0, Tmp1,
4445*da58b97aSjoerg Tmp2, Tmp3, Tmp4);
444606f32e7eSjoerg if (FoldedLoad)
444706f32e7eSjoerg std::swap(Src0, Src1);
444806f32e7eSjoerg }
444906f32e7eSjoerg }
445006f32e7eSjoerg
4451*da58b97aSjoerg bool FoldedBCast = FoldedLoad && Src1.getOpcode() == X86ISD::VBROADCAST_LOAD;
445206f32e7eSjoerg
445306f32e7eSjoerg bool IsMasked = InMask.getNode() != nullptr;
445406f32e7eSjoerg
445506f32e7eSjoerg SDLoc dl(Root);
445606f32e7eSjoerg
445706f32e7eSjoerg MVT ResVT = Setcc.getSimpleValueType();
445806f32e7eSjoerg MVT MaskVT = ResVT;
445906f32e7eSjoerg if (Widen) {
446006f32e7eSjoerg // Widen the inputs using insert_subreg or copy_to_regclass.
446106f32e7eSjoerg unsigned Scale = CmpVT.is128BitVector() ? 4 : 2;
446206f32e7eSjoerg unsigned SubReg = CmpVT.is128BitVector() ? X86::sub_xmm : X86::sub_ymm;
446306f32e7eSjoerg unsigned NumElts = CmpVT.getVectorNumElements() * Scale;
446406f32e7eSjoerg CmpVT = MVT::getVectorVT(CmpSVT, NumElts);
446506f32e7eSjoerg MaskVT = MVT::getVectorVT(MVT::i1, NumElts);
446606f32e7eSjoerg SDValue ImplDef = SDValue(CurDAG->getMachineNode(X86::IMPLICIT_DEF, dl,
446706f32e7eSjoerg CmpVT), 0);
446806f32e7eSjoerg Src0 = CurDAG->getTargetInsertSubreg(SubReg, dl, CmpVT, ImplDef, Src0);
446906f32e7eSjoerg
447006f32e7eSjoerg if (!FoldedBCast)
447106f32e7eSjoerg Src1 = CurDAG->getTargetInsertSubreg(SubReg, dl, CmpVT, ImplDef, Src1);
447206f32e7eSjoerg
447306f32e7eSjoerg if (IsMasked) {
447406f32e7eSjoerg // Widen the mask.
4475*da58b97aSjoerg unsigned RegClass = TLI->getRegClassFor(MaskVT)->getID();
447606f32e7eSjoerg SDValue RC = CurDAG->getTargetConstant(RegClass, dl, MVT::i32);
447706f32e7eSjoerg InMask = SDValue(CurDAG->getMachineNode(TargetOpcode::COPY_TO_REGCLASS,
447806f32e7eSjoerg dl, MaskVT, InMask, RC), 0);
447906f32e7eSjoerg }
448006f32e7eSjoerg }
448106f32e7eSjoerg
448206f32e7eSjoerg bool IsTestN = CC == ISD::SETEQ;
448306f32e7eSjoerg unsigned Opc = getVPTESTMOpc(CmpVT, IsTestN, FoldedLoad, FoldedBCast,
448406f32e7eSjoerg IsMasked);
448506f32e7eSjoerg
448606f32e7eSjoerg MachineSDNode *CNode;
4487*da58b97aSjoerg if (FoldedLoad) {
448806f32e7eSjoerg SDVTList VTs = CurDAG->getVTList(MaskVT, MVT::Other);
448906f32e7eSjoerg
449006f32e7eSjoerg if (IsMasked) {
449106f32e7eSjoerg SDValue Ops[] = { InMask, Src0, Tmp0, Tmp1, Tmp2, Tmp3, Tmp4,
4492*da58b97aSjoerg Src1.getOperand(0) };
449306f32e7eSjoerg CNode = CurDAG->getMachineNode(Opc, dl, VTs, Ops);
449406f32e7eSjoerg } else {
449506f32e7eSjoerg SDValue Ops[] = { Src0, Tmp0, Tmp1, Tmp2, Tmp3, Tmp4,
4496*da58b97aSjoerg Src1.getOperand(0) };
449706f32e7eSjoerg CNode = CurDAG->getMachineNode(Opc, dl, VTs, Ops);
449806f32e7eSjoerg }
449906f32e7eSjoerg
450006f32e7eSjoerg // Update the chain.
4501*da58b97aSjoerg ReplaceUses(Src1.getValue(1), SDValue(CNode, 1));
450206f32e7eSjoerg // Record the mem-refs
4503*da58b97aSjoerg CurDAG->setNodeMemRefs(CNode, {cast<MemSDNode>(Src1)->getMemOperand()});
450406f32e7eSjoerg } else {
450506f32e7eSjoerg if (IsMasked)
450606f32e7eSjoerg CNode = CurDAG->getMachineNode(Opc, dl, MaskVT, InMask, Src0, Src1);
450706f32e7eSjoerg else
450806f32e7eSjoerg CNode = CurDAG->getMachineNode(Opc, dl, MaskVT, Src0, Src1);
450906f32e7eSjoerg }
451006f32e7eSjoerg
451106f32e7eSjoerg // If we widened, we need to shrink the mask VT.
451206f32e7eSjoerg if (Widen) {
4513*da58b97aSjoerg unsigned RegClass = TLI->getRegClassFor(ResVT)->getID();
451406f32e7eSjoerg SDValue RC = CurDAG->getTargetConstant(RegClass, dl, MVT::i32);
451506f32e7eSjoerg CNode = CurDAG->getMachineNode(TargetOpcode::COPY_TO_REGCLASS,
451606f32e7eSjoerg dl, ResVT, SDValue(CNode, 0), RC);
451706f32e7eSjoerg }
451806f32e7eSjoerg
451906f32e7eSjoerg ReplaceUses(SDValue(Root, 0), SDValue(CNode, 0));
452006f32e7eSjoerg CurDAG->RemoveDeadNode(Root);
452106f32e7eSjoerg return true;
452206f32e7eSjoerg }
452306f32e7eSjoerg
452406f32e7eSjoerg // Try to match the bitselect pattern (or (and A, B), (andn A, C)). Turn it
452506f32e7eSjoerg // into vpternlog.
tryMatchBitSelect(SDNode * N)452606f32e7eSjoerg bool X86DAGToDAGISel::tryMatchBitSelect(SDNode *N) {
452706f32e7eSjoerg assert(N->getOpcode() == ISD::OR && "Unexpected opcode!");
452806f32e7eSjoerg
452906f32e7eSjoerg MVT NVT = N->getSimpleValueType(0);
453006f32e7eSjoerg
453106f32e7eSjoerg // Make sure we support VPTERNLOG.
453206f32e7eSjoerg if (!NVT.isVector() || !Subtarget->hasAVX512())
453306f32e7eSjoerg return false;
453406f32e7eSjoerg
453506f32e7eSjoerg // We need VLX for 128/256-bit.
453606f32e7eSjoerg if (!(Subtarget->hasVLX() || NVT.is512BitVector()))
453706f32e7eSjoerg return false;
453806f32e7eSjoerg
453906f32e7eSjoerg SDValue N0 = N->getOperand(0);
454006f32e7eSjoerg SDValue N1 = N->getOperand(1);
454106f32e7eSjoerg
454206f32e7eSjoerg // Canonicalize AND to LHS.
454306f32e7eSjoerg if (N1.getOpcode() == ISD::AND)
454406f32e7eSjoerg std::swap(N0, N1);
454506f32e7eSjoerg
454606f32e7eSjoerg if (N0.getOpcode() != ISD::AND ||
454706f32e7eSjoerg N1.getOpcode() != X86ISD::ANDNP ||
454806f32e7eSjoerg !N0.hasOneUse() || !N1.hasOneUse())
454906f32e7eSjoerg return false;
455006f32e7eSjoerg
455106f32e7eSjoerg // ANDN is not commutable, use it to pick down A and C.
455206f32e7eSjoerg SDValue A = N1.getOperand(0);
455306f32e7eSjoerg SDValue C = N1.getOperand(1);
455406f32e7eSjoerg
455506f32e7eSjoerg // AND is commutable, if one operand matches A, the other operand is B.
455606f32e7eSjoerg // Otherwise this isn't a match.
455706f32e7eSjoerg SDValue B;
455806f32e7eSjoerg if (N0.getOperand(0) == A)
455906f32e7eSjoerg B = N0.getOperand(1);
456006f32e7eSjoerg else if (N0.getOperand(1) == A)
456106f32e7eSjoerg B = N0.getOperand(0);
456206f32e7eSjoerg else
456306f32e7eSjoerg return false;
456406f32e7eSjoerg
456506f32e7eSjoerg SDLoc dl(N);
456606f32e7eSjoerg SDValue Imm = CurDAG->getTargetConstant(0xCA, dl, MVT::i8);
456706f32e7eSjoerg SDValue Ternlog = CurDAG->getNode(X86ISD::VPTERNLOG, dl, NVT, A, B, C, Imm);
456806f32e7eSjoerg ReplaceNode(N, Ternlog.getNode());
4569*da58b97aSjoerg
4570*da58b97aSjoerg return matchVPTERNLOG(Ternlog.getNode(), Ternlog.getNode(), Ternlog.getNode(),
4571*da58b97aSjoerg A, B, C, 0xCA);
457206f32e7eSjoerg }
457306f32e7eSjoerg
Select(SDNode * Node)457406f32e7eSjoerg void X86DAGToDAGISel::Select(SDNode *Node) {
457506f32e7eSjoerg MVT NVT = Node->getSimpleValueType(0);
457606f32e7eSjoerg unsigned Opcode = Node->getOpcode();
457706f32e7eSjoerg SDLoc dl(Node);
457806f32e7eSjoerg
457906f32e7eSjoerg if (Node->isMachineOpcode()) {
458006f32e7eSjoerg LLVM_DEBUG(dbgs() << "== "; Node->dump(CurDAG); dbgs() << '\n');
458106f32e7eSjoerg Node->setNodeId(-1);
458206f32e7eSjoerg return; // Already selected.
458306f32e7eSjoerg }
458406f32e7eSjoerg
458506f32e7eSjoerg switch (Opcode) {
458606f32e7eSjoerg default: break;
4587*da58b97aSjoerg case ISD::INTRINSIC_W_CHAIN: {
4588*da58b97aSjoerg unsigned IntNo = Node->getConstantOperandVal(1);
4589*da58b97aSjoerg switch (IntNo) {
4590*da58b97aSjoerg default: break;
4591*da58b97aSjoerg case Intrinsic::x86_encodekey128:
4592*da58b97aSjoerg case Intrinsic::x86_encodekey256: {
4593*da58b97aSjoerg if (!Subtarget->hasKL())
4594*da58b97aSjoerg break;
4595*da58b97aSjoerg
4596*da58b97aSjoerg unsigned Opcode;
4597*da58b97aSjoerg switch (IntNo) {
4598*da58b97aSjoerg default: llvm_unreachable("Impossible intrinsic");
4599*da58b97aSjoerg case Intrinsic::x86_encodekey128: Opcode = X86::ENCODEKEY128; break;
4600*da58b97aSjoerg case Intrinsic::x86_encodekey256: Opcode = X86::ENCODEKEY256; break;
4601*da58b97aSjoerg }
4602*da58b97aSjoerg
4603*da58b97aSjoerg SDValue Chain = Node->getOperand(0);
4604*da58b97aSjoerg Chain = CurDAG->getCopyToReg(Chain, dl, X86::XMM0, Node->getOperand(3),
4605*da58b97aSjoerg SDValue());
4606*da58b97aSjoerg if (Opcode == X86::ENCODEKEY256)
4607*da58b97aSjoerg Chain = CurDAG->getCopyToReg(Chain, dl, X86::XMM1, Node->getOperand(4),
4608*da58b97aSjoerg Chain.getValue(1));
4609*da58b97aSjoerg
4610*da58b97aSjoerg MachineSDNode *Res = CurDAG->getMachineNode(
4611*da58b97aSjoerg Opcode, dl, Node->getVTList(),
4612*da58b97aSjoerg {Node->getOperand(2), Chain, Chain.getValue(1)});
4613*da58b97aSjoerg ReplaceNode(Node, Res);
4614*da58b97aSjoerg return;
4615*da58b97aSjoerg }
4616*da58b97aSjoerg case Intrinsic::x86_tileloadd64_internal: {
4617*da58b97aSjoerg if (!Subtarget->hasAMXTILE())
4618*da58b97aSjoerg break;
4619*da58b97aSjoerg unsigned Opc = X86::PTILELOADDV;
4620*da58b97aSjoerg // _tile_loadd_internal(row, col, buf, STRIDE)
4621*da58b97aSjoerg SDValue Base = Node->getOperand(4);
4622*da58b97aSjoerg SDValue Scale = getI8Imm(1, dl);
4623*da58b97aSjoerg SDValue Index = Node->getOperand(5);
4624*da58b97aSjoerg SDValue Disp = CurDAG->getTargetConstant(0, dl, MVT::i32);
4625*da58b97aSjoerg SDValue Segment = CurDAG->getRegister(0, MVT::i16);
4626*da58b97aSjoerg SDValue Chain = Node->getOperand(0);
4627*da58b97aSjoerg MachineSDNode *CNode;
4628*da58b97aSjoerg SDValue Ops[] = {Node->getOperand(2),
4629*da58b97aSjoerg Node->getOperand(3),
4630*da58b97aSjoerg Base,
4631*da58b97aSjoerg Scale,
4632*da58b97aSjoerg Index,
4633*da58b97aSjoerg Disp,
4634*da58b97aSjoerg Segment,
4635*da58b97aSjoerg Chain};
4636*da58b97aSjoerg CNode = CurDAG->getMachineNode(Opc, dl, {MVT::x86amx, MVT::Other}, Ops);
4637*da58b97aSjoerg ReplaceNode(Node, CNode);
4638*da58b97aSjoerg return;
4639*da58b97aSjoerg }
4640*da58b97aSjoerg }
4641*da58b97aSjoerg break;
4642*da58b97aSjoerg }
464306f32e7eSjoerg case ISD::INTRINSIC_VOID: {
464406f32e7eSjoerg unsigned IntNo = Node->getConstantOperandVal(1);
464506f32e7eSjoerg switch (IntNo) {
464606f32e7eSjoerg default: break;
464706f32e7eSjoerg case Intrinsic::x86_sse3_monitor:
464806f32e7eSjoerg case Intrinsic::x86_monitorx:
464906f32e7eSjoerg case Intrinsic::x86_clzero: {
465006f32e7eSjoerg bool Use64BitPtr = Node->getOperand(2).getValueType() == MVT::i64;
465106f32e7eSjoerg
465206f32e7eSjoerg unsigned Opc = 0;
465306f32e7eSjoerg switch (IntNo) {
465406f32e7eSjoerg default: llvm_unreachable("Unexpected intrinsic!");
465506f32e7eSjoerg case Intrinsic::x86_sse3_monitor:
465606f32e7eSjoerg if (!Subtarget->hasSSE3())
465706f32e7eSjoerg break;
465806f32e7eSjoerg Opc = Use64BitPtr ? X86::MONITOR64rrr : X86::MONITOR32rrr;
465906f32e7eSjoerg break;
466006f32e7eSjoerg case Intrinsic::x86_monitorx:
466106f32e7eSjoerg if (!Subtarget->hasMWAITX())
466206f32e7eSjoerg break;
466306f32e7eSjoerg Opc = Use64BitPtr ? X86::MONITORX64rrr : X86::MONITORX32rrr;
466406f32e7eSjoerg break;
466506f32e7eSjoerg case Intrinsic::x86_clzero:
466606f32e7eSjoerg if (!Subtarget->hasCLZERO())
466706f32e7eSjoerg break;
466806f32e7eSjoerg Opc = Use64BitPtr ? X86::CLZERO64r : X86::CLZERO32r;
466906f32e7eSjoerg break;
467006f32e7eSjoerg }
467106f32e7eSjoerg
467206f32e7eSjoerg if (Opc) {
467306f32e7eSjoerg unsigned PtrReg = Use64BitPtr ? X86::RAX : X86::EAX;
467406f32e7eSjoerg SDValue Chain = CurDAG->getCopyToReg(Node->getOperand(0), dl, PtrReg,
467506f32e7eSjoerg Node->getOperand(2), SDValue());
467606f32e7eSjoerg SDValue InFlag = Chain.getValue(1);
467706f32e7eSjoerg
467806f32e7eSjoerg if (IntNo == Intrinsic::x86_sse3_monitor ||
467906f32e7eSjoerg IntNo == Intrinsic::x86_monitorx) {
468006f32e7eSjoerg // Copy the other two operands to ECX and EDX.
468106f32e7eSjoerg Chain = CurDAG->getCopyToReg(Chain, dl, X86::ECX, Node->getOperand(3),
468206f32e7eSjoerg InFlag);
468306f32e7eSjoerg InFlag = Chain.getValue(1);
468406f32e7eSjoerg Chain = CurDAG->getCopyToReg(Chain, dl, X86::EDX, Node->getOperand(4),
468506f32e7eSjoerg InFlag);
468606f32e7eSjoerg InFlag = Chain.getValue(1);
468706f32e7eSjoerg }
468806f32e7eSjoerg
468906f32e7eSjoerg MachineSDNode *CNode = CurDAG->getMachineNode(Opc, dl, MVT::Other,
469006f32e7eSjoerg { Chain, InFlag});
469106f32e7eSjoerg ReplaceNode(Node, CNode);
469206f32e7eSjoerg return;
469306f32e7eSjoerg }
469406f32e7eSjoerg
469506f32e7eSjoerg break;
469606f32e7eSjoerg }
4697*da58b97aSjoerg case Intrinsic::x86_tilestored64_internal: {
4698*da58b97aSjoerg unsigned Opc = X86::PTILESTOREDV;
4699*da58b97aSjoerg // _tile_stored_internal(row, col, buf, STRIDE, c)
4700*da58b97aSjoerg SDValue Base = Node->getOperand(4);
4701*da58b97aSjoerg SDValue Scale = getI8Imm(1, dl);
4702*da58b97aSjoerg SDValue Index = Node->getOperand(5);
4703*da58b97aSjoerg SDValue Disp = CurDAG->getTargetConstant(0, dl, MVT::i32);
4704*da58b97aSjoerg SDValue Segment = CurDAG->getRegister(0, MVT::i16);
4705*da58b97aSjoerg SDValue Chain = Node->getOperand(0);
4706*da58b97aSjoerg MachineSDNode *CNode;
4707*da58b97aSjoerg SDValue Ops[] = {Node->getOperand(2),
4708*da58b97aSjoerg Node->getOperand(3),
4709*da58b97aSjoerg Base,
4710*da58b97aSjoerg Scale,
4711*da58b97aSjoerg Index,
4712*da58b97aSjoerg Disp,
4713*da58b97aSjoerg Segment,
4714*da58b97aSjoerg Node->getOperand(6),
4715*da58b97aSjoerg Chain};
4716*da58b97aSjoerg CNode = CurDAG->getMachineNode(Opc, dl, MVT::Other, Ops);
4717*da58b97aSjoerg ReplaceNode(Node, CNode);
4718*da58b97aSjoerg return;
4719*da58b97aSjoerg }
4720*da58b97aSjoerg case Intrinsic::x86_tileloadd64:
4721*da58b97aSjoerg case Intrinsic::x86_tileloaddt164:
4722*da58b97aSjoerg case Intrinsic::x86_tilestored64: {
4723*da58b97aSjoerg if (!Subtarget->hasAMXTILE())
4724*da58b97aSjoerg break;
4725*da58b97aSjoerg unsigned Opc;
4726*da58b97aSjoerg switch (IntNo) {
4727*da58b97aSjoerg default: llvm_unreachable("Unexpected intrinsic!");
4728*da58b97aSjoerg case Intrinsic::x86_tileloadd64: Opc = X86::PTILELOADD; break;
4729*da58b97aSjoerg case Intrinsic::x86_tileloaddt164: Opc = X86::PTILELOADDT1; break;
4730*da58b97aSjoerg case Intrinsic::x86_tilestored64: Opc = X86::PTILESTORED; break;
4731*da58b97aSjoerg }
4732*da58b97aSjoerg // FIXME: Match displacement and scale.
4733*da58b97aSjoerg unsigned TIndex = Node->getConstantOperandVal(2);
4734*da58b97aSjoerg SDValue TReg = getI8Imm(TIndex, dl);
4735*da58b97aSjoerg SDValue Base = Node->getOperand(3);
4736*da58b97aSjoerg SDValue Scale = getI8Imm(1, dl);
4737*da58b97aSjoerg SDValue Index = Node->getOperand(4);
4738*da58b97aSjoerg SDValue Disp = CurDAG->getTargetConstant(0, dl, MVT::i32);
4739*da58b97aSjoerg SDValue Segment = CurDAG->getRegister(0, MVT::i16);
4740*da58b97aSjoerg SDValue Chain = Node->getOperand(0);
4741*da58b97aSjoerg MachineSDNode *CNode;
4742*da58b97aSjoerg if (Opc == X86::PTILESTORED) {
4743*da58b97aSjoerg SDValue Ops[] = { Base, Scale, Index, Disp, Segment, TReg, Chain };
4744*da58b97aSjoerg CNode = CurDAG->getMachineNode(Opc, dl, MVT::Other, Ops);
4745*da58b97aSjoerg } else {
4746*da58b97aSjoerg SDValue Ops[] = { TReg, Base, Scale, Index, Disp, Segment, Chain };
4747*da58b97aSjoerg CNode = CurDAG->getMachineNode(Opc, dl, MVT::Other, Ops);
4748*da58b97aSjoerg }
4749*da58b97aSjoerg ReplaceNode(Node, CNode);
4750*da58b97aSjoerg return;
4751*da58b97aSjoerg }
4752*da58b97aSjoerg }
4753*da58b97aSjoerg break;
4754*da58b97aSjoerg }
4755*da58b97aSjoerg case ISD::BRIND:
4756*da58b97aSjoerg case X86ISD::NT_BRIND: {
475706f32e7eSjoerg if (Subtarget->isTargetNaCl())
475806f32e7eSjoerg // NaCl has its own pass where jmp %r32 are converted to jmp %r64. We
475906f32e7eSjoerg // leave the instruction alone.
476006f32e7eSjoerg break;
476106f32e7eSjoerg if (Subtarget->isTarget64BitILP32()) {
476206f32e7eSjoerg // Converts a 32-bit register to a 64-bit, zero-extended version of
476306f32e7eSjoerg // it. This is needed because x86-64 can do many things, but jmp %r32
476406f32e7eSjoerg // ain't one of them.
4765*da58b97aSjoerg SDValue Target = Node->getOperand(1);
4766*da58b97aSjoerg assert(Target.getValueType() == MVT::i32 && "Unexpected VT!");
4767*da58b97aSjoerg SDValue ZextTarget = CurDAG->getZExtOrTrunc(Target, dl, MVT::i64);
4768*da58b97aSjoerg SDValue Brind = CurDAG->getNode(Opcode, dl, MVT::Other,
476906f32e7eSjoerg Node->getOperand(0), ZextTarget);
477006f32e7eSjoerg ReplaceNode(Node, Brind.getNode());
477106f32e7eSjoerg SelectCode(ZextTarget.getNode());
477206f32e7eSjoerg SelectCode(Brind.getNode());
477306f32e7eSjoerg return;
477406f32e7eSjoerg }
477506f32e7eSjoerg break;
477606f32e7eSjoerg }
477706f32e7eSjoerg case X86ISD::GlobalBaseReg:
477806f32e7eSjoerg ReplaceNode(Node, getGlobalBaseReg());
477906f32e7eSjoerg return;
478006f32e7eSjoerg
478106f32e7eSjoerg case ISD::BITCAST:
478206f32e7eSjoerg // Just drop all 128/256/512-bit bitcasts.
478306f32e7eSjoerg if (NVT.is512BitVector() || NVT.is256BitVector() || NVT.is128BitVector() ||
478406f32e7eSjoerg NVT == MVT::f128) {
478506f32e7eSjoerg ReplaceUses(SDValue(Node, 0), Node->getOperand(0));
478606f32e7eSjoerg CurDAG->RemoveDeadNode(Node);
478706f32e7eSjoerg return;
478806f32e7eSjoerg }
478906f32e7eSjoerg break;
479006f32e7eSjoerg
479106f32e7eSjoerg case ISD::SRL:
479206f32e7eSjoerg if (matchBitExtract(Node))
479306f32e7eSjoerg return;
479406f32e7eSjoerg LLVM_FALLTHROUGH;
479506f32e7eSjoerg case ISD::SRA:
479606f32e7eSjoerg case ISD::SHL:
479706f32e7eSjoerg if (tryShiftAmountMod(Node))
479806f32e7eSjoerg return;
479906f32e7eSjoerg break;
480006f32e7eSjoerg
4801*da58b97aSjoerg case X86ISD::VPTERNLOG: {
4802*da58b97aSjoerg uint8_t Imm = cast<ConstantSDNode>(Node->getOperand(3))->getZExtValue();
4803*da58b97aSjoerg if (matchVPTERNLOG(Node, Node, Node, Node->getOperand(0),
4804*da58b97aSjoerg Node->getOperand(1), Node->getOperand(2), Imm))
4805*da58b97aSjoerg return;
4806*da58b97aSjoerg break;
4807*da58b97aSjoerg }
4808*da58b97aSjoerg
4809*da58b97aSjoerg case X86ISD::ANDNP:
4810*da58b97aSjoerg if (tryVPTERNLOG(Node))
4811*da58b97aSjoerg return;
4812*da58b97aSjoerg break;
4813*da58b97aSjoerg
481406f32e7eSjoerg case ISD::AND:
481506f32e7eSjoerg if (NVT.isVector() && NVT.getVectorElementType() == MVT::i1) {
481606f32e7eSjoerg // Try to form a masked VPTESTM. Operands can be in either order.
481706f32e7eSjoerg SDValue N0 = Node->getOperand(0);
481806f32e7eSjoerg SDValue N1 = Node->getOperand(1);
481906f32e7eSjoerg if (N0.getOpcode() == ISD::SETCC && N0.hasOneUse() &&
482006f32e7eSjoerg tryVPTESTM(Node, N0, N1))
482106f32e7eSjoerg return;
482206f32e7eSjoerg if (N1.getOpcode() == ISD::SETCC && N1.hasOneUse() &&
482306f32e7eSjoerg tryVPTESTM(Node, N1, N0))
482406f32e7eSjoerg return;
482506f32e7eSjoerg }
482606f32e7eSjoerg
482706f32e7eSjoerg if (MachineSDNode *NewNode = matchBEXTRFromAndImm(Node)) {
482806f32e7eSjoerg ReplaceUses(SDValue(Node, 0), SDValue(NewNode, 0));
482906f32e7eSjoerg CurDAG->RemoveDeadNode(Node);
483006f32e7eSjoerg return;
483106f32e7eSjoerg }
483206f32e7eSjoerg if (matchBitExtract(Node))
483306f32e7eSjoerg return;
483406f32e7eSjoerg if (AndImmShrink && shrinkAndImmediate(Node))
483506f32e7eSjoerg return;
483606f32e7eSjoerg
483706f32e7eSjoerg LLVM_FALLTHROUGH;
483806f32e7eSjoerg case ISD::OR:
483906f32e7eSjoerg case ISD::XOR:
484006f32e7eSjoerg if (tryShrinkShlLogicImm(Node))
484106f32e7eSjoerg return;
484206f32e7eSjoerg if (Opcode == ISD::OR && tryMatchBitSelect(Node))
484306f32e7eSjoerg return;
4844*da58b97aSjoerg if (tryVPTERNLOG(Node))
4845*da58b97aSjoerg return;
484606f32e7eSjoerg
484706f32e7eSjoerg LLVM_FALLTHROUGH;
484806f32e7eSjoerg case ISD::ADD:
484906f32e7eSjoerg case ISD::SUB: {
485006f32e7eSjoerg // Try to avoid folding immediates with multiple uses for optsize.
485106f32e7eSjoerg // This code tries to select to register form directly to avoid going
485206f32e7eSjoerg // through the isel table which might fold the immediate. We can't change
485306f32e7eSjoerg // the patterns on the add/sub/and/or/xor with immediate paterns in the
485406f32e7eSjoerg // tablegen files to check immediate use count without making the patterns
485506f32e7eSjoerg // unavailable to the fast-isel table.
4856*da58b97aSjoerg if (!CurDAG->shouldOptForSize())
485706f32e7eSjoerg break;
485806f32e7eSjoerg
485906f32e7eSjoerg // Only handle i8/i16/i32/i64.
486006f32e7eSjoerg if (NVT != MVT::i8 && NVT != MVT::i16 && NVT != MVT::i32 && NVT != MVT::i64)
486106f32e7eSjoerg break;
486206f32e7eSjoerg
486306f32e7eSjoerg SDValue N0 = Node->getOperand(0);
486406f32e7eSjoerg SDValue N1 = Node->getOperand(1);
486506f32e7eSjoerg
486606f32e7eSjoerg ConstantSDNode *Cst = dyn_cast<ConstantSDNode>(N1);
486706f32e7eSjoerg if (!Cst)
486806f32e7eSjoerg break;
486906f32e7eSjoerg
487006f32e7eSjoerg int64_t Val = Cst->getSExtValue();
487106f32e7eSjoerg
487206f32e7eSjoerg // Make sure its an immediate that is considered foldable.
487306f32e7eSjoerg // FIXME: Handle unsigned 32 bit immediates for 64-bit AND.
487406f32e7eSjoerg if (!isInt<8>(Val) && !isInt<32>(Val))
487506f32e7eSjoerg break;
487606f32e7eSjoerg
487706f32e7eSjoerg // If this can match to INC/DEC, let it go.
487806f32e7eSjoerg if (Opcode == ISD::ADD && (Val == 1 || Val == -1))
487906f32e7eSjoerg break;
488006f32e7eSjoerg
488106f32e7eSjoerg // Check if we should avoid folding this immediate.
488206f32e7eSjoerg if (!shouldAvoidImmediateInstFormsForSize(N1.getNode()))
488306f32e7eSjoerg break;
488406f32e7eSjoerg
488506f32e7eSjoerg // We should not fold the immediate. So we need a register form instead.
488606f32e7eSjoerg unsigned ROpc, MOpc;
488706f32e7eSjoerg switch (NVT.SimpleTy) {
488806f32e7eSjoerg default: llvm_unreachable("Unexpected VT!");
488906f32e7eSjoerg case MVT::i8:
489006f32e7eSjoerg switch (Opcode) {
489106f32e7eSjoerg default: llvm_unreachable("Unexpected opcode!");
489206f32e7eSjoerg case ISD::ADD: ROpc = X86::ADD8rr; MOpc = X86::ADD8rm; break;
489306f32e7eSjoerg case ISD::SUB: ROpc = X86::SUB8rr; MOpc = X86::SUB8rm; break;
489406f32e7eSjoerg case ISD::AND: ROpc = X86::AND8rr; MOpc = X86::AND8rm; break;
489506f32e7eSjoerg case ISD::OR: ROpc = X86::OR8rr; MOpc = X86::OR8rm; break;
489606f32e7eSjoerg case ISD::XOR: ROpc = X86::XOR8rr; MOpc = X86::XOR8rm; break;
489706f32e7eSjoerg }
489806f32e7eSjoerg break;
489906f32e7eSjoerg case MVT::i16:
490006f32e7eSjoerg switch (Opcode) {
490106f32e7eSjoerg default: llvm_unreachable("Unexpected opcode!");
490206f32e7eSjoerg case ISD::ADD: ROpc = X86::ADD16rr; MOpc = X86::ADD16rm; break;
490306f32e7eSjoerg case ISD::SUB: ROpc = X86::SUB16rr; MOpc = X86::SUB16rm; break;
490406f32e7eSjoerg case ISD::AND: ROpc = X86::AND16rr; MOpc = X86::AND16rm; break;
490506f32e7eSjoerg case ISD::OR: ROpc = X86::OR16rr; MOpc = X86::OR16rm; break;
490606f32e7eSjoerg case ISD::XOR: ROpc = X86::XOR16rr; MOpc = X86::XOR16rm; break;
490706f32e7eSjoerg }
490806f32e7eSjoerg break;
490906f32e7eSjoerg case MVT::i32:
491006f32e7eSjoerg switch (Opcode) {
491106f32e7eSjoerg default: llvm_unreachable("Unexpected opcode!");
491206f32e7eSjoerg case ISD::ADD: ROpc = X86::ADD32rr; MOpc = X86::ADD32rm; break;
491306f32e7eSjoerg case ISD::SUB: ROpc = X86::SUB32rr; MOpc = X86::SUB32rm; break;
491406f32e7eSjoerg case ISD::AND: ROpc = X86::AND32rr; MOpc = X86::AND32rm; break;
491506f32e7eSjoerg case ISD::OR: ROpc = X86::OR32rr; MOpc = X86::OR32rm; break;
491606f32e7eSjoerg case ISD::XOR: ROpc = X86::XOR32rr; MOpc = X86::XOR32rm; break;
491706f32e7eSjoerg }
491806f32e7eSjoerg break;
491906f32e7eSjoerg case MVT::i64:
492006f32e7eSjoerg switch (Opcode) {
492106f32e7eSjoerg default: llvm_unreachable("Unexpected opcode!");
492206f32e7eSjoerg case ISD::ADD: ROpc = X86::ADD64rr; MOpc = X86::ADD64rm; break;
492306f32e7eSjoerg case ISD::SUB: ROpc = X86::SUB64rr; MOpc = X86::SUB64rm; break;
492406f32e7eSjoerg case ISD::AND: ROpc = X86::AND64rr; MOpc = X86::AND64rm; break;
492506f32e7eSjoerg case ISD::OR: ROpc = X86::OR64rr; MOpc = X86::OR64rm; break;
492606f32e7eSjoerg case ISD::XOR: ROpc = X86::XOR64rr; MOpc = X86::XOR64rm; break;
492706f32e7eSjoerg }
492806f32e7eSjoerg break;
492906f32e7eSjoerg }
493006f32e7eSjoerg
493106f32e7eSjoerg // Ok this is a AND/OR/XOR/ADD/SUB with constant.
493206f32e7eSjoerg
493306f32e7eSjoerg // If this is a not a subtract, we can still try to fold a load.
493406f32e7eSjoerg if (Opcode != ISD::SUB) {
493506f32e7eSjoerg SDValue Tmp0, Tmp1, Tmp2, Tmp3, Tmp4;
493606f32e7eSjoerg if (tryFoldLoad(Node, N0, Tmp0, Tmp1, Tmp2, Tmp3, Tmp4)) {
493706f32e7eSjoerg SDValue Ops[] = { N1, Tmp0, Tmp1, Tmp2, Tmp3, Tmp4, N0.getOperand(0) };
493806f32e7eSjoerg SDVTList VTs = CurDAG->getVTList(NVT, MVT::i32, MVT::Other);
493906f32e7eSjoerg MachineSDNode *CNode = CurDAG->getMachineNode(MOpc, dl, VTs, Ops);
494006f32e7eSjoerg // Update the chain.
494106f32e7eSjoerg ReplaceUses(N0.getValue(1), SDValue(CNode, 2));
494206f32e7eSjoerg // Record the mem-refs
494306f32e7eSjoerg CurDAG->setNodeMemRefs(CNode, {cast<LoadSDNode>(N0)->getMemOperand()});
494406f32e7eSjoerg ReplaceUses(SDValue(Node, 0), SDValue(CNode, 0));
494506f32e7eSjoerg CurDAG->RemoveDeadNode(Node);
494606f32e7eSjoerg return;
494706f32e7eSjoerg }
494806f32e7eSjoerg }
494906f32e7eSjoerg
495006f32e7eSjoerg CurDAG->SelectNodeTo(Node, ROpc, NVT, MVT::i32, N0, N1);
495106f32e7eSjoerg return;
495206f32e7eSjoerg }
495306f32e7eSjoerg
495406f32e7eSjoerg case X86ISD::SMUL:
495506f32e7eSjoerg // i16/i32/i64 are handled with isel patterns.
495606f32e7eSjoerg if (NVT != MVT::i8)
495706f32e7eSjoerg break;
495806f32e7eSjoerg LLVM_FALLTHROUGH;
495906f32e7eSjoerg case X86ISD::UMUL: {
496006f32e7eSjoerg SDValue N0 = Node->getOperand(0);
496106f32e7eSjoerg SDValue N1 = Node->getOperand(1);
496206f32e7eSjoerg
496306f32e7eSjoerg unsigned LoReg, ROpc, MOpc;
496406f32e7eSjoerg switch (NVT.SimpleTy) {
496506f32e7eSjoerg default: llvm_unreachable("Unsupported VT!");
496606f32e7eSjoerg case MVT::i8:
496706f32e7eSjoerg LoReg = X86::AL;
496806f32e7eSjoerg ROpc = Opcode == X86ISD::SMUL ? X86::IMUL8r : X86::MUL8r;
496906f32e7eSjoerg MOpc = Opcode == X86ISD::SMUL ? X86::IMUL8m : X86::MUL8m;
497006f32e7eSjoerg break;
497106f32e7eSjoerg case MVT::i16:
497206f32e7eSjoerg LoReg = X86::AX;
497306f32e7eSjoerg ROpc = X86::MUL16r;
497406f32e7eSjoerg MOpc = X86::MUL16m;
497506f32e7eSjoerg break;
497606f32e7eSjoerg case MVT::i32:
497706f32e7eSjoerg LoReg = X86::EAX;
497806f32e7eSjoerg ROpc = X86::MUL32r;
497906f32e7eSjoerg MOpc = X86::MUL32m;
498006f32e7eSjoerg break;
498106f32e7eSjoerg case MVT::i64:
498206f32e7eSjoerg LoReg = X86::RAX;
498306f32e7eSjoerg ROpc = X86::MUL64r;
498406f32e7eSjoerg MOpc = X86::MUL64m;
498506f32e7eSjoerg break;
498606f32e7eSjoerg }
498706f32e7eSjoerg
498806f32e7eSjoerg SDValue Tmp0, Tmp1, Tmp2, Tmp3, Tmp4;
498906f32e7eSjoerg bool FoldedLoad = tryFoldLoad(Node, N1, Tmp0, Tmp1, Tmp2, Tmp3, Tmp4);
4990*da58b97aSjoerg // Multiply is commutative.
499106f32e7eSjoerg if (!FoldedLoad) {
499206f32e7eSjoerg FoldedLoad = tryFoldLoad(Node, N0, Tmp0, Tmp1, Tmp2, Tmp3, Tmp4);
499306f32e7eSjoerg if (FoldedLoad)
499406f32e7eSjoerg std::swap(N0, N1);
499506f32e7eSjoerg }
499606f32e7eSjoerg
499706f32e7eSjoerg SDValue InFlag = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, LoReg,
499806f32e7eSjoerg N0, SDValue()).getValue(1);
499906f32e7eSjoerg
500006f32e7eSjoerg MachineSDNode *CNode;
500106f32e7eSjoerg if (FoldedLoad) {
500206f32e7eSjoerg // i16/i32/i64 use an instruction that produces a low and high result even
500306f32e7eSjoerg // though only the low result is used.
500406f32e7eSjoerg SDVTList VTs;
500506f32e7eSjoerg if (NVT == MVT::i8)
500606f32e7eSjoerg VTs = CurDAG->getVTList(NVT, MVT::i32, MVT::Other);
500706f32e7eSjoerg else
500806f32e7eSjoerg VTs = CurDAG->getVTList(NVT, NVT, MVT::i32, MVT::Other);
500906f32e7eSjoerg
501006f32e7eSjoerg SDValue Ops[] = { Tmp0, Tmp1, Tmp2, Tmp3, Tmp4, N1.getOperand(0),
501106f32e7eSjoerg InFlag };
501206f32e7eSjoerg CNode = CurDAG->getMachineNode(MOpc, dl, VTs, Ops);
501306f32e7eSjoerg
501406f32e7eSjoerg // Update the chain.
501506f32e7eSjoerg ReplaceUses(N1.getValue(1), SDValue(CNode, NVT == MVT::i8 ? 2 : 3));
501606f32e7eSjoerg // Record the mem-refs
501706f32e7eSjoerg CurDAG->setNodeMemRefs(CNode, {cast<LoadSDNode>(N1)->getMemOperand()});
501806f32e7eSjoerg } else {
501906f32e7eSjoerg // i16/i32/i64 use an instruction that produces a low and high result even
502006f32e7eSjoerg // though only the low result is used.
502106f32e7eSjoerg SDVTList VTs;
502206f32e7eSjoerg if (NVT == MVT::i8)
502306f32e7eSjoerg VTs = CurDAG->getVTList(NVT, MVT::i32);
502406f32e7eSjoerg else
502506f32e7eSjoerg VTs = CurDAG->getVTList(NVT, NVT, MVT::i32);
502606f32e7eSjoerg
502706f32e7eSjoerg CNode = CurDAG->getMachineNode(ROpc, dl, VTs, {N1, InFlag});
502806f32e7eSjoerg }
502906f32e7eSjoerg
503006f32e7eSjoerg ReplaceUses(SDValue(Node, 0), SDValue(CNode, 0));
503106f32e7eSjoerg ReplaceUses(SDValue(Node, 1), SDValue(CNode, NVT == MVT::i8 ? 1 : 2));
503206f32e7eSjoerg CurDAG->RemoveDeadNode(Node);
503306f32e7eSjoerg return;
503406f32e7eSjoerg }
503506f32e7eSjoerg
503606f32e7eSjoerg case ISD::SMUL_LOHI:
503706f32e7eSjoerg case ISD::UMUL_LOHI: {
503806f32e7eSjoerg SDValue N0 = Node->getOperand(0);
503906f32e7eSjoerg SDValue N1 = Node->getOperand(1);
504006f32e7eSjoerg
504106f32e7eSjoerg unsigned Opc, MOpc;
5042*da58b97aSjoerg unsigned LoReg, HiReg;
5043*da58b97aSjoerg bool IsSigned = Opcode == ISD::SMUL_LOHI;
5044*da58b97aSjoerg bool UseMULX = !IsSigned && Subtarget->hasBMI2();
5045*da58b97aSjoerg bool UseMULXHi = UseMULX && SDValue(Node, 0).use_empty();
504606f32e7eSjoerg switch (NVT.SimpleTy) {
504706f32e7eSjoerg default: llvm_unreachable("Unsupported VT!");
5048*da58b97aSjoerg case MVT::i32:
5049*da58b97aSjoerg Opc = UseMULXHi ? X86::MULX32Hrr :
5050*da58b97aSjoerg UseMULX ? X86::MULX32rr :
5051*da58b97aSjoerg IsSigned ? X86::IMUL32r : X86::MUL32r;
5052*da58b97aSjoerg MOpc = UseMULXHi ? X86::MULX32Hrm :
5053*da58b97aSjoerg UseMULX ? X86::MULX32rm :
5054*da58b97aSjoerg IsSigned ? X86::IMUL32m : X86::MUL32m;
5055*da58b97aSjoerg LoReg = UseMULX ? X86::EDX : X86::EAX;
5056*da58b97aSjoerg HiReg = X86::EDX;
505706f32e7eSjoerg break;
5058*da58b97aSjoerg case MVT::i64:
5059*da58b97aSjoerg Opc = UseMULXHi ? X86::MULX64Hrr :
5060*da58b97aSjoerg UseMULX ? X86::MULX64rr :
5061*da58b97aSjoerg IsSigned ? X86::IMUL64r : X86::MUL64r;
5062*da58b97aSjoerg MOpc = UseMULXHi ? X86::MULX64Hrm :
5063*da58b97aSjoerg UseMULX ? X86::MULX64rm :
5064*da58b97aSjoerg IsSigned ? X86::IMUL64m : X86::MUL64m;
5065*da58b97aSjoerg LoReg = UseMULX ? X86::RDX : X86::RAX;
5066*da58b97aSjoerg HiReg = X86::RDX;
506706f32e7eSjoerg break;
506806f32e7eSjoerg }
506906f32e7eSjoerg
507006f32e7eSjoerg SDValue Tmp0, Tmp1, Tmp2, Tmp3, Tmp4;
507106f32e7eSjoerg bool foldedLoad = tryFoldLoad(Node, N1, Tmp0, Tmp1, Tmp2, Tmp3, Tmp4);
507206f32e7eSjoerg // Multiply is commmutative.
507306f32e7eSjoerg if (!foldedLoad) {
507406f32e7eSjoerg foldedLoad = tryFoldLoad(Node, N0, Tmp0, Tmp1, Tmp2, Tmp3, Tmp4);
507506f32e7eSjoerg if (foldedLoad)
507606f32e7eSjoerg std::swap(N0, N1);
507706f32e7eSjoerg }
507806f32e7eSjoerg
5079*da58b97aSjoerg SDValue InFlag = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, LoReg,
508006f32e7eSjoerg N0, SDValue()).getValue(1);
5081*da58b97aSjoerg SDValue ResHi, ResLo;
508206f32e7eSjoerg if (foldedLoad) {
508306f32e7eSjoerg SDValue Chain;
508406f32e7eSjoerg MachineSDNode *CNode = nullptr;
508506f32e7eSjoerg SDValue Ops[] = { Tmp0, Tmp1, Tmp2, Tmp3, Tmp4, N1.getOperand(0),
508606f32e7eSjoerg InFlag };
5087*da58b97aSjoerg if (UseMULXHi) {
5088*da58b97aSjoerg SDVTList VTs = CurDAG->getVTList(NVT, MVT::Other);
5089*da58b97aSjoerg CNode = CurDAG->getMachineNode(MOpc, dl, VTs, Ops);
5090*da58b97aSjoerg ResHi = SDValue(CNode, 0);
5091*da58b97aSjoerg Chain = SDValue(CNode, 1);
5092*da58b97aSjoerg } else if (UseMULX) {
5093*da58b97aSjoerg SDVTList VTs = CurDAG->getVTList(NVT, NVT, MVT::Other);
5094*da58b97aSjoerg CNode = CurDAG->getMachineNode(MOpc, dl, VTs, Ops);
5095*da58b97aSjoerg ResHi = SDValue(CNode, 0);
5096*da58b97aSjoerg ResLo = SDValue(CNode, 1);
5097*da58b97aSjoerg Chain = SDValue(CNode, 2);
5098*da58b97aSjoerg } else {
509906f32e7eSjoerg SDVTList VTs = CurDAG->getVTList(MVT::Other, MVT::Glue);
510006f32e7eSjoerg CNode = CurDAG->getMachineNode(MOpc, dl, VTs, Ops);
510106f32e7eSjoerg Chain = SDValue(CNode, 0);
510206f32e7eSjoerg InFlag = SDValue(CNode, 1);
5103*da58b97aSjoerg }
510406f32e7eSjoerg
510506f32e7eSjoerg // Update the chain.
510606f32e7eSjoerg ReplaceUses(N1.getValue(1), Chain);
510706f32e7eSjoerg // Record the mem-refs
510806f32e7eSjoerg CurDAG->setNodeMemRefs(CNode, {cast<LoadSDNode>(N1)->getMemOperand()});
510906f32e7eSjoerg } else {
511006f32e7eSjoerg SDValue Ops[] = { N1, InFlag };
5111*da58b97aSjoerg if (UseMULXHi) {
5112*da58b97aSjoerg SDVTList VTs = CurDAG->getVTList(NVT);
5113*da58b97aSjoerg SDNode *CNode = CurDAG->getMachineNode(Opc, dl, VTs, Ops);
5114*da58b97aSjoerg ResHi = SDValue(CNode, 0);
5115*da58b97aSjoerg } else if (UseMULX) {
5116*da58b97aSjoerg SDVTList VTs = CurDAG->getVTList(NVT, NVT);
5117*da58b97aSjoerg SDNode *CNode = CurDAG->getMachineNode(Opc, dl, VTs, Ops);
5118*da58b97aSjoerg ResHi = SDValue(CNode, 0);
5119*da58b97aSjoerg ResLo = SDValue(CNode, 1);
5120*da58b97aSjoerg } else {
512106f32e7eSjoerg SDVTList VTs = CurDAG->getVTList(MVT::Glue);
512206f32e7eSjoerg SDNode *CNode = CurDAG->getMachineNode(Opc, dl, VTs, Ops);
512306f32e7eSjoerg InFlag = SDValue(CNode, 0);
512406f32e7eSjoerg }
5125*da58b97aSjoerg }
512606f32e7eSjoerg
512706f32e7eSjoerg // Copy the low half of the result, if it is needed.
512806f32e7eSjoerg if (!SDValue(Node, 0).use_empty()) {
5129*da58b97aSjoerg if (!ResLo) {
513006f32e7eSjoerg assert(LoReg && "Register for low half is not defined!");
5131*da58b97aSjoerg ResLo = CurDAG->getCopyFromReg(CurDAG->getEntryNode(), dl, LoReg,
513206f32e7eSjoerg NVT, InFlag);
513306f32e7eSjoerg InFlag = ResLo.getValue(2);
5134*da58b97aSjoerg }
513506f32e7eSjoerg ReplaceUses(SDValue(Node, 0), ResLo);
513606f32e7eSjoerg LLVM_DEBUG(dbgs() << "=> "; ResLo.getNode()->dump(CurDAG);
513706f32e7eSjoerg dbgs() << '\n');
513806f32e7eSjoerg }
513906f32e7eSjoerg // Copy the high half of the result, if it is needed.
514006f32e7eSjoerg if (!SDValue(Node, 1).use_empty()) {
5141*da58b97aSjoerg if (!ResHi) {
514206f32e7eSjoerg assert(HiReg && "Register for high half is not defined!");
5143*da58b97aSjoerg ResHi = CurDAG->getCopyFromReg(CurDAG->getEntryNode(), dl, HiReg,
514406f32e7eSjoerg NVT, InFlag);
514506f32e7eSjoerg InFlag = ResHi.getValue(2);
5146*da58b97aSjoerg }
514706f32e7eSjoerg ReplaceUses(SDValue(Node, 1), ResHi);
514806f32e7eSjoerg LLVM_DEBUG(dbgs() << "=> "; ResHi.getNode()->dump(CurDAG);
514906f32e7eSjoerg dbgs() << '\n');
515006f32e7eSjoerg }
515106f32e7eSjoerg
515206f32e7eSjoerg CurDAG->RemoveDeadNode(Node);
515306f32e7eSjoerg return;
515406f32e7eSjoerg }
515506f32e7eSjoerg
515606f32e7eSjoerg case ISD::SDIVREM:
515706f32e7eSjoerg case ISD::UDIVREM: {
515806f32e7eSjoerg SDValue N0 = Node->getOperand(0);
515906f32e7eSjoerg SDValue N1 = Node->getOperand(1);
516006f32e7eSjoerg
5161*da58b97aSjoerg unsigned ROpc, MOpc;
516206f32e7eSjoerg bool isSigned = Opcode == ISD::SDIVREM;
516306f32e7eSjoerg if (!isSigned) {
516406f32e7eSjoerg switch (NVT.SimpleTy) {
516506f32e7eSjoerg default: llvm_unreachable("Unsupported VT!");
5166*da58b97aSjoerg case MVT::i8: ROpc = X86::DIV8r; MOpc = X86::DIV8m; break;
5167*da58b97aSjoerg case MVT::i16: ROpc = X86::DIV16r; MOpc = X86::DIV16m; break;
5168*da58b97aSjoerg case MVT::i32: ROpc = X86::DIV32r; MOpc = X86::DIV32m; break;
5169*da58b97aSjoerg case MVT::i64: ROpc = X86::DIV64r; MOpc = X86::DIV64m; break;
517006f32e7eSjoerg }
517106f32e7eSjoerg } else {
517206f32e7eSjoerg switch (NVT.SimpleTy) {
517306f32e7eSjoerg default: llvm_unreachable("Unsupported VT!");
5174*da58b97aSjoerg case MVT::i8: ROpc = X86::IDIV8r; MOpc = X86::IDIV8m; break;
5175*da58b97aSjoerg case MVT::i16: ROpc = X86::IDIV16r; MOpc = X86::IDIV16m; break;
5176*da58b97aSjoerg case MVT::i32: ROpc = X86::IDIV32r; MOpc = X86::IDIV32m; break;
5177*da58b97aSjoerg case MVT::i64: ROpc = X86::IDIV64r; MOpc = X86::IDIV64m; break;
517806f32e7eSjoerg }
517906f32e7eSjoerg }
518006f32e7eSjoerg
518106f32e7eSjoerg unsigned LoReg, HiReg, ClrReg;
518206f32e7eSjoerg unsigned SExtOpcode;
518306f32e7eSjoerg switch (NVT.SimpleTy) {
518406f32e7eSjoerg default: llvm_unreachable("Unsupported VT!");
518506f32e7eSjoerg case MVT::i8:
518606f32e7eSjoerg LoReg = X86::AL; ClrReg = HiReg = X86::AH;
518706f32e7eSjoerg SExtOpcode = 0; // Not used.
518806f32e7eSjoerg break;
518906f32e7eSjoerg case MVT::i16:
519006f32e7eSjoerg LoReg = X86::AX; HiReg = X86::DX;
519106f32e7eSjoerg ClrReg = X86::DX;
519206f32e7eSjoerg SExtOpcode = X86::CWD;
519306f32e7eSjoerg break;
519406f32e7eSjoerg case MVT::i32:
519506f32e7eSjoerg LoReg = X86::EAX; ClrReg = HiReg = X86::EDX;
519606f32e7eSjoerg SExtOpcode = X86::CDQ;
519706f32e7eSjoerg break;
519806f32e7eSjoerg case MVT::i64:
519906f32e7eSjoerg LoReg = X86::RAX; ClrReg = HiReg = X86::RDX;
520006f32e7eSjoerg SExtOpcode = X86::CQO;
520106f32e7eSjoerg break;
520206f32e7eSjoerg }
520306f32e7eSjoerg
520406f32e7eSjoerg SDValue Tmp0, Tmp1, Tmp2, Tmp3, Tmp4;
520506f32e7eSjoerg bool foldedLoad = tryFoldLoad(Node, N1, Tmp0, Tmp1, Tmp2, Tmp3, Tmp4);
520606f32e7eSjoerg bool signBitIsZero = CurDAG->SignBitIsZero(N0);
520706f32e7eSjoerg
520806f32e7eSjoerg SDValue InFlag;
520906f32e7eSjoerg if (NVT == MVT::i8) {
521006f32e7eSjoerg // Special case for div8, just use a move with zero extension to AX to
521106f32e7eSjoerg // clear the upper 8 bits (AH).
521206f32e7eSjoerg SDValue Tmp0, Tmp1, Tmp2, Tmp3, Tmp4, Chain;
521306f32e7eSjoerg MachineSDNode *Move;
521406f32e7eSjoerg if (tryFoldLoad(Node, N0, Tmp0, Tmp1, Tmp2, Tmp3, Tmp4)) {
521506f32e7eSjoerg SDValue Ops[] = { Tmp0, Tmp1, Tmp2, Tmp3, Tmp4, N0.getOperand(0) };
521606f32e7eSjoerg unsigned Opc = (isSigned && !signBitIsZero) ? X86::MOVSX16rm8
521706f32e7eSjoerg : X86::MOVZX16rm8;
521806f32e7eSjoerg Move = CurDAG->getMachineNode(Opc, dl, MVT::i16, MVT::Other, Ops);
521906f32e7eSjoerg Chain = SDValue(Move, 1);
522006f32e7eSjoerg ReplaceUses(N0.getValue(1), Chain);
522106f32e7eSjoerg // Record the mem-refs
522206f32e7eSjoerg CurDAG->setNodeMemRefs(Move, {cast<LoadSDNode>(N0)->getMemOperand()});
522306f32e7eSjoerg } else {
522406f32e7eSjoerg unsigned Opc = (isSigned && !signBitIsZero) ? X86::MOVSX16rr8
522506f32e7eSjoerg : X86::MOVZX16rr8;
522606f32e7eSjoerg Move = CurDAG->getMachineNode(Opc, dl, MVT::i16, N0);
522706f32e7eSjoerg Chain = CurDAG->getEntryNode();
522806f32e7eSjoerg }
522906f32e7eSjoerg Chain = CurDAG->getCopyToReg(Chain, dl, X86::AX, SDValue(Move, 0),
523006f32e7eSjoerg SDValue());
523106f32e7eSjoerg InFlag = Chain.getValue(1);
523206f32e7eSjoerg } else {
523306f32e7eSjoerg InFlag =
523406f32e7eSjoerg CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl,
523506f32e7eSjoerg LoReg, N0, SDValue()).getValue(1);
523606f32e7eSjoerg if (isSigned && !signBitIsZero) {
523706f32e7eSjoerg // Sign extend the low part into the high part.
523806f32e7eSjoerg InFlag =
523906f32e7eSjoerg SDValue(CurDAG->getMachineNode(SExtOpcode, dl, MVT::Glue, InFlag),0);
524006f32e7eSjoerg } else {
524106f32e7eSjoerg // Zero out the high part, effectively zero extending the input.
5242*da58b97aSjoerg SDVTList VTs = CurDAG->getVTList(MVT::i32, MVT::i32);
5243*da58b97aSjoerg SDValue ClrNode =
5244*da58b97aSjoerg SDValue(CurDAG->getMachineNode(X86::MOV32r0, dl, VTs, None), 0);
524506f32e7eSjoerg switch (NVT.SimpleTy) {
524606f32e7eSjoerg case MVT::i16:
524706f32e7eSjoerg ClrNode =
524806f32e7eSjoerg SDValue(CurDAG->getMachineNode(
524906f32e7eSjoerg TargetOpcode::EXTRACT_SUBREG, dl, MVT::i16, ClrNode,
525006f32e7eSjoerg CurDAG->getTargetConstant(X86::sub_16bit, dl,
525106f32e7eSjoerg MVT::i32)),
525206f32e7eSjoerg 0);
525306f32e7eSjoerg break;
525406f32e7eSjoerg case MVT::i32:
525506f32e7eSjoerg break;
525606f32e7eSjoerg case MVT::i64:
525706f32e7eSjoerg ClrNode =
525806f32e7eSjoerg SDValue(CurDAG->getMachineNode(
525906f32e7eSjoerg TargetOpcode::SUBREG_TO_REG, dl, MVT::i64,
526006f32e7eSjoerg CurDAG->getTargetConstant(0, dl, MVT::i64), ClrNode,
526106f32e7eSjoerg CurDAG->getTargetConstant(X86::sub_32bit, dl,
526206f32e7eSjoerg MVT::i32)),
526306f32e7eSjoerg 0);
526406f32e7eSjoerg break;
526506f32e7eSjoerg default:
526606f32e7eSjoerg llvm_unreachable("Unexpected division source");
526706f32e7eSjoerg }
526806f32e7eSjoerg
526906f32e7eSjoerg InFlag = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, ClrReg,
527006f32e7eSjoerg ClrNode, InFlag).getValue(1);
527106f32e7eSjoerg }
527206f32e7eSjoerg }
527306f32e7eSjoerg
527406f32e7eSjoerg if (foldedLoad) {
527506f32e7eSjoerg SDValue Ops[] = { Tmp0, Tmp1, Tmp2, Tmp3, Tmp4, N1.getOperand(0),
527606f32e7eSjoerg InFlag };
527706f32e7eSjoerg MachineSDNode *CNode =
527806f32e7eSjoerg CurDAG->getMachineNode(MOpc, dl, MVT::Other, MVT::Glue, Ops);
527906f32e7eSjoerg InFlag = SDValue(CNode, 1);
528006f32e7eSjoerg // Update the chain.
528106f32e7eSjoerg ReplaceUses(N1.getValue(1), SDValue(CNode, 0));
528206f32e7eSjoerg // Record the mem-refs
528306f32e7eSjoerg CurDAG->setNodeMemRefs(CNode, {cast<LoadSDNode>(N1)->getMemOperand()});
528406f32e7eSjoerg } else {
528506f32e7eSjoerg InFlag =
5286*da58b97aSjoerg SDValue(CurDAG->getMachineNode(ROpc, dl, MVT::Glue, N1, InFlag), 0);
528706f32e7eSjoerg }
528806f32e7eSjoerg
528906f32e7eSjoerg // Prevent use of AH in a REX instruction by explicitly copying it to
529006f32e7eSjoerg // an ABCD_L register.
529106f32e7eSjoerg //
529206f32e7eSjoerg // The current assumption of the register allocator is that isel
529306f32e7eSjoerg // won't generate explicit references to the GR8_ABCD_H registers. If
529406f32e7eSjoerg // the allocator and/or the backend get enhanced to be more robust in
529506f32e7eSjoerg // that regard, this can be, and should be, removed.
529606f32e7eSjoerg if (HiReg == X86::AH && !SDValue(Node, 1).use_empty()) {
529706f32e7eSjoerg SDValue AHCopy = CurDAG->getRegister(X86::AH, MVT::i8);
529806f32e7eSjoerg unsigned AHExtOpcode =
529906f32e7eSjoerg isSigned ? X86::MOVSX32rr8_NOREX : X86::MOVZX32rr8_NOREX;
530006f32e7eSjoerg
530106f32e7eSjoerg SDNode *RNode = CurDAG->getMachineNode(AHExtOpcode, dl, MVT::i32,
530206f32e7eSjoerg MVT::Glue, AHCopy, InFlag);
530306f32e7eSjoerg SDValue Result(RNode, 0);
530406f32e7eSjoerg InFlag = SDValue(RNode, 1);
530506f32e7eSjoerg
530606f32e7eSjoerg Result =
530706f32e7eSjoerg CurDAG->getTargetExtractSubreg(X86::sub_8bit, dl, MVT::i8, Result);
530806f32e7eSjoerg
530906f32e7eSjoerg ReplaceUses(SDValue(Node, 1), Result);
531006f32e7eSjoerg LLVM_DEBUG(dbgs() << "=> "; Result.getNode()->dump(CurDAG);
531106f32e7eSjoerg dbgs() << '\n');
531206f32e7eSjoerg }
531306f32e7eSjoerg // Copy the division (low) result, if it is needed.
531406f32e7eSjoerg if (!SDValue(Node, 0).use_empty()) {
531506f32e7eSjoerg SDValue Result = CurDAG->getCopyFromReg(CurDAG->getEntryNode(), dl,
531606f32e7eSjoerg LoReg, NVT, InFlag);
531706f32e7eSjoerg InFlag = Result.getValue(2);
531806f32e7eSjoerg ReplaceUses(SDValue(Node, 0), Result);
531906f32e7eSjoerg LLVM_DEBUG(dbgs() << "=> "; Result.getNode()->dump(CurDAG);
532006f32e7eSjoerg dbgs() << '\n');
532106f32e7eSjoerg }
532206f32e7eSjoerg // Copy the remainder (high) result, if it is needed.
532306f32e7eSjoerg if (!SDValue(Node, 1).use_empty()) {
532406f32e7eSjoerg SDValue Result = CurDAG->getCopyFromReg(CurDAG->getEntryNode(), dl,
532506f32e7eSjoerg HiReg, NVT, InFlag);
532606f32e7eSjoerg InFlag = Result.getValue(2);
532706f32e7eSjoerg ReplaceUses(SDValue(Node, 1), Result);
532806f32e7eSjoerg LLVM_DEBUG(dbgs() << "=> "; Result.getNode()->dump(CurDAG);
532906f32e7eSjoerg dbgs() << '\n');
533006f32e7eSjoerg }
533106f32e7eSjoerg CurDAG->RemoveDeadNode(Node);
533206f32e7eSjoerg return;
533306f32e7eSjoerg }
533406f32e7eSjoerg
5335*da58b97aSjoerg case X86ISD::FCMP:
5336*da58b97aSjoerg case X86ISD::STRICT_FCMP:
5337*da58b97aSjoerg case X86ISD::STRICT_FCMPS: {
5338*da58b97aSjoerg bool IsStrictCmp = Node->getOpcode() == X86ISD::STRICT_FCMP ||
5339*da58b97aSjoerg Node->getOpcode() == X86ISD::STRICT_FCMPS;
5340*da58b97aSjoerg SDValue N0 = Node->getOperand(IsStrictCmp ? 1 : 0);
5341*da58b97aSjoerg SDValue N1 = Node->getOperand(IsStrictCmp ? 2 : 1);
5342*da58b97aSjoerg
5343*da58b97aSjoerg // Save the original VT of the compare.
5344*da58b97aSjoerg MVT CmpVT = N0.getSimpleValueType();
5345*da58b97aSjoerg
5346*da58b97aSjoerg // Floating point needs special handling if we don't have FCOMI.
5347*da58b97aSjoerg if (Subtarget->hasCMov())
5348*da58b97aSjoerg break;
5349*da58b97aSjoerg
5350*da58b97aSjoerg bool IsSignaling = Node->getOpcode() == X86ISD::STRICT_FCMPS;
5351*da58b97aSjoerg
5352*da58b97aSjoerg unsigned Opc;
5353*da58b97aSjoerg switch (CmpVT.SimpleTy) {
5354*da58b97aSjoerg default: llvm_unreachable("Unexpected type!");
5355*da58b97aSjoerg case MVT::f32:
5356*da58b97aSjoerg Opc = IsSignaling ? X86::COM_Fpr32 : X86::UCOM_Fpr32;
5357*da58b97aSjoerg break;
5358*da58b97aSjoerg case MVT::f64:
5359*da58b97aSjoerg Opc = IsSignaling ? X86::COM_Fpr64 : X86::UCOM_Fpr64;
5360*da58b97aSjoerg break;
5361*da58b97aSjoerg case MVT::f80:
5362*da58b97aSjoerg Opc = IsSignaling ? X86::COM_Fpr80 : X86::UCOM_Fpr80;
5363*da58b97aSjoerg break;
5364*da58b97aSjoerg }
5365*da58b97aSjoerg
5366*da58b97aSjoerg SDValue Cmp;
5367*da58b97aSjoerg SDValue Chain =
5368*da58b97aSjoerg IsStrictCmp ? Node->getOperand(0) : CurDAG->getEntryNode();
5369*da58b97aSjoerg if (IsStrictCmp) {
5370*da58b97aSjoerg SDVTList VTs = CurDAG->getVTList(MVT::i16, MVT::Other);
5371*da58b97aSjoerg Cmp = SDValue(CurDAG->getMachineNode(Opc, dl, VTs, {N0, N1, Chain}), 0);
5372*da58b97aSjoerg Chain = Cmp.getValue(1);
5373*da58b97aSjoerg } else {
5374*da58b97aSjoerg Cmp = SDValue(CurDAG->getMachineNode(Opc, dl, MVT::i16, N0, N1), 0);
5375*da58b97aSjoerg }
5376*da58b97aSjoerg
5377*da58b97aSjoerg // Move FPSW to AX.
5378*da58b97aSjoerg SDValue FPSW = CurDAG->getCopyToReg(Chain, dl, X86::FPSW, Cmp, SDValue());
5379*da58b97aSjoerg Chain = FPSW;
5380*da58b97aSjoerg SDValue FNSTSW =
5381*da58b97aSjoerg SDValue(CurDAG->getMachineNode(X86::FNSTSW16r, dl, MVT::i16, FPSW,
5382*da58b97aSjoerg FPSW.getValue(1)),
5383*da58b97aSjoerg 0);
5384*da58b97aSjoerg
5385*da58b97aSjoerg // Extract upper 8-bits of AX.
5386*da58b97aSjoerg SDValue Extract =
5387*da58b97aSjoerg CurDAG->getTargetExtractSubreg(X86::sub_8bit_hi, dl, MVT::i8, FNSTSW);
5388*da58b97aSjoerg
5389*da58b97aSjoerg // Move AH into flags.
5390*da58b97aSjoerg // Some 64-bit targets lack SAHF support, but they do support FCOMI.
5391*da58b97aSjoerg assert(Subtarget->hasLAHFSAHF() &&
5392*da58b97aSjoerg "Target doesn't support SAHF or FCOMI?");
5393*da58b97aSjoerg SDValue AH = CurDAG->getCopyToReg(Chain, dl, X86::AH, Extract, SDValue());
5394*da58b97aSjoerg Chain = AH;
5395*da58b97aSjoerg SDValue SAHF = SDValue(
5396*da58b97aSjoerg CurDAG->getMachineNode(X86::SAHF, dl, MVT::i32, AH.getValue(1)), 0);
5397*da58b97aSjoerg
5398*da58b97aSjoerg if (IsStrictCmp)
5399*da58b97aSjoerg ReplaceUses(SDValue(Node, 1), Chain);
5400*da58b97aSjoerg
5401*da58b97aSjoerg ReplaceUses(SDValue(Node, 0), SAHF);
5402*da58b97aSjoerg CurDAG->RemoveDeadNode(Node);
5403*da58b97aSjoerg return;
5404*da58b97aSjoerg }
5405*da58b97aSjoerg
540606f32e7eSjoerg case X86ISD::CMP: {
540706f32e7eSjoerg SDValue N0 = Node->getOperand(0);
540806f32e7eSjoerg SDValue N1 = Node->getOperand(1);
540906f32e7eSjoerg
541006f32e7eSjoerg // Optimizations for TEST compares.
541106f32e7eSjoerg if (!isNullConstant(N1))
541206f32e7eSjoerg break;
541306f32e7eSjoerg
541406f32e7eSjoerg // Save the original VT of the compare.
541506f32e7eSjoerg MVT CmpVT = N0.getSimpleValueType();
541606f32e7eSjoerg
541706f32e7eSjoerg // If we are comparing (and (shr X, C, Mask) with 0, emit a BEXTR followed
541806f32e7eSjoerg // by a test instruction. The test should be removed later by
541906f32e7eSjoerg // analyzeCompare if we are using only the zero flag.
542006f32e7eSjoerg // TODO: Should we check the users and use the BEXTR flags directly?
542106f32e7eSjoerg if (N0.getOpcode() == ISD::AND && N0.hasOneUse()) {
542206f32e7eSjoerg if (MachineSDNode *NewNode = matchBEXTRFromAndImm(N0.getNode())) {
542306f32e7eSjoerg unsigned TestOpc = CmpVT == MVT::i64 ? X86::TEST64rr
542406f32e7eSjoerg : X86::TEST32rr;
542506f32e7eSjoerg SDValue BEXTR = SDValue(NewNode, 0);
542606f32e7eSjoerg NewNode = CurDAG->getMachineNode(TestOpc, dl, MVT::i32, BEXTR, BEXTR);
542706f32e7eSjoerg ReplaceUses(SDValue(Node, 0), SDValue(NewNode, 0));
542806f32e7eSjoerg CurDAG->RemoveDeadNode(Node);
542906f32e7eSjoerg return;
543006f32e7eSjoerg }
543106f32e7eSjoerg }
543206f32e7eSjoerg
543306f32e7eSjoerg // We can peek through truncates, but we need to be careful below.
543406f32e7eSjoerg if (N0.getOpcode() == ISD::TRUNCATE && N0.hasOneUse())
543506f32e7eSjoerg N0 = N0.getOperand(0);
543606f32e7eSjoerg
543706f32e7eSjoerg // Look for (X86cmp (and $op, $imm), 0) and see if we can convert it to
543806f32e7eSjoerg // use a smaller encoding.
543906f32e7eSjoerg // Look past the truncate if CMP is the only use of it.
544006f32e7eSjoerg if (N0.getOpcode() == ISD::AND &&
544106f32e7eSjoerg N0.getNode()->hasOneUse() &&
544206f32e7eSjoerg N0.getValueType() != MVT::i8) {
544306f32e7eSjoerg ConstantSDNode *C = dyn_cast<ConstantSDNode>(N0.getOperand(1));
544406f32e7eSjoerg if (!C) break;
544506f32e7eSjoerg uint64_t Mask = C->getZExtValue();
544606f32e7eSjoerg
544706f32e7eSjoerg // Check if we can replace AND+IMM64 with a shift. This is possible for
544806f32e7eSjoerg // masks/ like 0xFF000000 or 0x00FFFFFF and if we care only about the zero
544906f32e7eSjoerg // flag.
545006f32e7eSjoerg if (CmpVT == MVT::i64 && !isInt<32>(Mask) &&
545106f32e7eSjoerg onlyUsesZeroFlag(SDValue(Node, 0))) {
545206f32e7eSjoerg if (isMask_64(~Mask)) {
545306f32e7eSjoerg unsigned TrailingZeros = countTrailingZeros(Mask);
545406f32e7eSjoerg SDValue Imm = CurDAG->getTargetConstant(TrailingZeros, dl, MVT::i64);
545506f32e7eSjoerg SDValue Shift =
545606f32e7eSjoerg SDValue(CurDAG->getMachineNode(X86::SHR64ri, dl, MVT::i64, MVT::i32,
545706f32e7eSjoerg N0.getOperand(0), Imm), 0);
545806f32e7eSjoerg MachineSDNode *Test = CurDAG->getMachineNode(X86::TEST64rr, dl,
545906f32e7eSjoerg MVT::i32, Shift, Shift);
546006f32e7eSjoerg ReplaceNode(Node, Test);
546106f32e7eSjoerg return;
546206f32e7eSjoerg }
546306f32e7eSjoerg if (isMask_64(Mask)) {
546406f32e7eSjoerg unsigned LeadingZeros = countLeadingZeros(Mask);
546506f32e7eSjoerg SDValue Imm = CurDAG->getTargetConstant(LeadingZeros, dl, MVT::i64);
546606f32e7eSjoerg SDValue Shift =
546706f32e7eSjoerg SDValue(CurDAG->getMachineNode(X86::SHL64ri, dl, MVT::i64, MVT::i32,
546806f32e7eSjoerg N0.getOperand(0), Imm), 0);
546906f32e7eSjoerg MachineSDNode *Test = CurDAG->getMachineNode(X86::TEST64rr, dl,
547006f32e7eSjoerg MVT::i32, Shift, Shift);
547106f32e7eSjoerg ReplaceNode(Node, Test);
547206f32e7eSjoerg return;
547306f32e7eSjoerg }
547406f32e7eSjoerg }
547506f32e7eSjoerg
547606f32e7eSjoerg MVT VT;
547706f32e7eSjoerg int SubRegOp;
547806f32e7eSjoerg unsigned ROpc, MOpc;
547906f32e7eSjoerg
548006f32e7eSjoerg // For each of these checks we need to be careful if the sign flag is
548106f32e7eSjoerg // being used. It is only safe to use the sign flag in two conditions,
548206f32e7eSjoerg // either the sign bit in the shrunken mask is zero or the final test
548306f32e7eSjoerg // size is equal to the original compare size.
548406f32e7eSjoerg
548506f32e7eSjoerg if (isUInt<8>(Mask) &&
548606f32e7eSjoerg (!(Mask & 0x80) || CmpVT == MVT::i8 ||
548706f32e7eSjoerg hasNoSignFlagUses(SDValue(Node, 0)))) {
548806f32e7eSjoerg // For example, convert "testl %eax, $8" to "testb %al, $8"
548906f32e7eSjoerg VT = MVT::i8;
549006f32e7eSjoerg SubRegOp = X86::sub_8bit;
549106f32e7eSjoerg ROpc = X86::TEST8ri;
549206f32e7eSjoerg MOpc = X86::TEST8mi;
549306f32e7eSjoerg } else if (OptForMinSize && isUInt<16>(Mask) &&
549406f32e7eSjoerg (!(Mask & 0x8000) || CmpVT == MVT::i16 ||
549506f32e7eSjoerg hasNoSignFlagUses(SDValue(Node, 0)))) {
549606f32e7eSjoerg // For example, "testl %eax, $32776" to "testw %ax, $32776".
549706f32e7eSjoerg // NOTE: We only want to form TESTW instructions if optimizing for
549806f32e7eSjoerg // min size. Otherwise we only save one byte and possibly get a length
549906f32e7eSjoerg // changing prefix penalty in the decoders.
550006f32e7eSjoerg VT = MVT::i16;
550106f32e7eSjoerg SubRegOp = X86::sub_16bit;
550206f32e7eSjoerg ROpc = X86::TEST16ri;
550306f32e7eSjoerg MOpc = X86::TEST16mi;
550406f32e7eSjoerg } else if (isUInt<32>(Mask) && N0.getValueType() != MVT::i16 &&
550506f32e7eSjoerg ((!(Mask & 0x80000000) &&
550606f32e7eSjoerg // Without minsize 16-bit Cmps can get here so we need to
550706f32e7eSjoerg // be sure we calculate the correct sign flag if needed.
550806f32e7eSjoerg (CmpVT != MVT::i16 || !(Mask & 0x8000))) ||
550906f32e7eSjoerg CmpVT == MVT::i32 ||
551006f32e7eSjoerg hasNoSignFlagUses(SDValue(Node, 0)))) {
551106f32e7eSjoerg // For example, "testq %rax, $268468232" to "testl %eax, $268468232".
551206f32e7eSjoerg // NOTE: We only want to run that transform if N0 is 32 or 64 bits.
551306f32e7eSjoerg // Otherwize, we find ourselves in a position where we have to do
551406f32e7eSjoerg // promotion. If previous passes did not promote the and, we assume
551506f32e7eSjoerg // they had a good reason not to and do not promote here.
551606f32e7eSjoerg VT = MVT::i32;
551706f32e7eSjoerg SubRegOp = X86::sub_32bit;
551806f32e7eSjoerg ROpc = X86::TEST32ri;
551906f32e7eSjoerg MOpc = X86::TEST32mi;
552006f32e7eSjoerg } else {
552106f32e7eSjoerg // No eligible transformation was found.
552206f32e7eSjoerg break;
552306f32e7eSjoerg }
552406f32e7eSjoerg
552506f32e7eSjoerg SDValue Imm = CurDAG->getTargetConstant(Mask, dl, VT);
552606f32e7eSjoerg SDValue Reg = N0.getOperand(0);
552706f32e7eSjoerg
552806f32e7eSjoerg // Emit a testl or testw.
552906f32e7eSjoerg MachineSDNode *NewNode;
553006f32e7eSjoerg SDValue Tmp0, Tmp1, Tmp2, Tmp3, Tmp4;
553106f32e7eSjoerg if (tryFoldLoad(Node, N0.getNode(), Reg, Tmp0, Tmp1, Tmp2, Tmp3, Tmp4)) {
5532*da58b97aSjoerg if (auto *LoadN = dyn_cast<LoadSDNode>(N0.getOperand(0).getNode())) {
5533*da58b97aSjoerg if (!LoadN->isSimple()) {
5534*da58b97aSjoerg unsigned NumVolBits = LoadN->getValueType(0).getSizeInBits();
5535*da58b97aSjoerg if ((MOpc == X86::TEST8mi && NumVolBits != 8) ||
5536*da58b97aSjoerg (MOpc == X86::TEST16mi && NumVolBits != 16) ||
5537*da58b97aSjoerg (MOpc == X86::TEST32mi && NumVolBits != 32))
5538*da58b97aSjoerg break;
5539*da58b97aSjoerg }
5540*da58b97aSjoerg }
554106f32e7eSjoerg SDValue Ops[] = { Tmp0, Tmp1, Tmp2, Tmp3, Tmp4, Imm,
554206f32e7eSjoerg Reg.getOperand(0) };
554306f32e7eSjoerg NewNode = CurDAG->getMachineNode(MOpc, dl, MVT::i32, MVT::Other, Ops);
554406f32e7eSjoerg // Update the chain.
554506f32e7eSjoerg ReplaceUses(Reg.getValue(1), SDValue(NewNode, 1));
554606f32e7eSjoerg // Record the mem-refs
554706f32e7eSjoerg CurDAG->setNodeMemRefs(NewNode,
554806f32e7eSjoerg {cast<LoadSDNode>(Reg)->getMemOperand()});
554906f32e7eSjoerg } else {
555006f32e7eSjoerg // Extract the subregister if necessary.
555106f32e7eSjoerg if (N0.getValueType() != VT)
555206f32e7eSjoerg Reg = CurDAG->getTargetExtractSubreg(SubRegOp, dl, VT, Reg);
555306f32e7eSjoerg
555406f32e7eSjoerg NewNode = CurDAG->getMachineNode(ROpc, dl, MVT::i32, Reg, Imm);
555506f32e7eSjoerg }
555606f32e7eSjoerg // Replace CMP with TEST.
555706f32e7eSjoerg ReplaceNode(Node, NewNode);
555806f32e7eSjoerg return;
555906f32e7eSjoerg }
556006f32e7eSjoerg break;
556106f32e7eSjoerg }
556206f32e7eSjoerg case X86ISD::PCMPISTR: {
556306f32e7eSjoerg if (!Subtarget->hasSSE42())
556406f32e7eSjoerg break;
556506f32e7eSjoerg
556606f32e7eSjoerg bool NeedIndex = !SDValue(Node, 0).use_empty();
556706f32e7eSjoerg bool NeedMask = !SDValue(Node, 1).use_empty();
556806f32e7eSjoerg // We can't fold a load if we are going to make two instructions.
556906f32e7eSjoerg bool MayFoldLoad = !NeedIndex || !NeedMask;
557006f32e7eSjoerg
557106f32e7eSjoerg MachineSDNode *CNode;
557206f32e7eSjoerg if (NeedMask) {
557306f32e7eSjoerg unsigned ROpc = Subtarget->hasAVX() ? X86::VPCMPISTRMrr : X86::PCMPISTRMrr;
557406f32e7eSjoerg unsigned MOpc = Subtarget->hasAVX() ? X86::VPCMPISTRMrm : X86::PCMPISTRMrm;
557506f32e7eSjoerg CNode = emitPCMPISTR(ROpc, MOpc, MayFoldLoad, dl, MVT::v16i8, Node);
557606f32e7eSjoerg ReplaceUses(SDValue(Node, 1), SDValue(CNode, 0));
557706f32e7eSjoerg }
557806f32e7eSjoerg if (NeedIndex || !NeedMask) {
557906f32e7eSjoerg unsigned ROpc = Subtarget->hasAVX() ? X86::VPCMPISTRIrr : X86::PCMPISTRIrr;
558006f32e7eSjoerg unsigned MOpc = Subtarget->hasAVX() ? X86::VPCMPISTRIrm : X86::PCMPISTRIrm;
558106f32e7eSjoerg CNode = emitPCMPISTR(ROpc, MOpc, MayFoldLoad, dl, MVT::i32, Node);
558206f32e7eSjoerg ReplaceUses(SDValue(Node, 0), SDValue(CNode, 0));
558306f32e7eSjoerg }
558406f32e7eSjoerg
558506f32e7eSjoerg // Connect the flag usage to the last instruction created.
558606f32e7eSjoerg ReplaceUses(SDValue(Node, 2), SDValue(CNode, 1));
558706f32e7eSjoerg CurDAG->RemoveDeadNode(Node);
558806f32e7eSjoerg return;
558906f32e7eSjoerg }
559006f32e7eSjoerg case X86ISD::PCMPESTR: {
559106f32e7eSjoerg if (!Subtarget->hasSSE42())
559206f32e7eSjoerg break;
559306f32e7eSjoerg
559406f32e7eSjoerg // Copy the two implicit register inputs.
559506f32e7eSjoerg SDValue InFlag = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, X86::EAX,
559606f32e7eSjoerg Node->getOperand(1),
559706f32e7eSjoerg SDValue()).getValue(1);
559806f32e7eSjoerg InFlag = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, X86::EDX,
559906f32e7eSjoerg Node->getOperand(3), InFlag).getValue(1);
560006f32e7eSjoerg
560106f32e7eSjoerg bool NeedIndex = !SDValue(Node, 0).use_empty();
560206f32e7eSjoerg bool NeedMask = !SDValue(Node, 1).use_empty();
560306f32e7eSjoerg // We can't fold a load if we are going to make two instructions.
560406f32e7eSjoerg bool MayFoldLoad = !NeedIndex || !NeedMask;
560506f32e7eSjoerg
560606f32e7eSjoerg MachineSDNode *CNode;
560706f32e7eSjoerg if (NeedMask) {
560806f32e7eSjoerg unsigned ROpc = Subtarget->hasAVX() ? X86::VPCMPESTRMrr : X86::PCMPESTRMrr;
560906f32e7eSjoerg unsigned MOpc = Subtarget->hasAVX() ? X86::VPCMPESTRMrm : X86::PCMPESTRMrm;
561006f32e7eSjoerg CNode = emitPCMPESTR(ROpc, MOpc, MayFoldLoad, dl, MVT::v16i8, Node,
561106f32e7eSjoerg InFlag);
561206f32e7eSjoerg ReplaceUses(SDValue(Node, 1), SDValue(CNode, 0));
561306f32e7eSjoerg }
561406f32e7eSjoerg if (NeedIndex || !NeedMask) {
561506f32e7eSjoerg unsigned ROpc = Subtarget->hasAVX() ? X86::VPCMPESTRIrr : X86::PCMPESTRIrr;
561606f32e7eSjoerg unsigned MOpc = Subtarget->hasAVX() ? X86::VPCMPESTRIrm : X86::PCMPESTRIrm;
561706f32e7eSjoerg CNode = emitPCMPESTR(ROpc, MOpc, MayFoldLoad, dl, MVT::i32, Node, InFlag);
561806f32e7eSjoerg ReplaceUses(SDValue(Node, 0), SDValue(CNode, 0));
561906f32e7eSjoerg }
562006f32e7eSjoerg // Connect the flag usage to the last instruction created.
562106f32e7eSjoerg ReplaceUses(SDValue(Node, 2), SDValue(CNode, 1));
562206f32e7eSjoerg CurDAG->RemoveDeadNode(Node);
562306f32e7eSjoerg return;
562406f32e7eSjoerg }
562506f32e7eSjoerg
562606f32e7eSjoerg case ISD::SETCC: {
562706f32e7eSjoerg if (NVT.isVector() && tryVPTESTM(Node, SDValue(Node, 0), SDValue()))
562806f32e7eSjoerg return;
562906f32e7eSjoerg
563006f32e7eSjoerg break;
563106f32e7eSjoerg }
563206f32e7eSjoerg
563306f32e7eSjoerg case ISD::STORE:
563406f32e7eSjoerg if (foldLoadStoreIntoMemOperand(Node))
563506f32e7eSjoerg return;
563606f32e7eSjoerg break;
5637*da58b97aSjoerg
5638*da58b97aSjoerg case X86ISD::SETCC_CARRY: {
5639*da58b97aSjoerg // We have to do this manually because tblgen will put the eflags copy in
5640*da58b97aSjoerg // the wrong place if we use an extract_subreg in the pattern.
5641*da58b97aSjoerg MVT VT = Node->getSimpleValueType(0);
5642*da58b97aSjoerg
5643*da58b97aSjoerg // Copy flags to the EFLAGS register and glue it to next node.
5644*da58b97aSjoerg SDValue EFLAGS =
5645*da58b97aSjoerg CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, X86::EFLAGS,
5646*da58b97aSjoerg Node->getOperand(1), SDValue());
5647*da58b97aSjoerg
5648*da58b97aSjoerg // Create a 64-bit instruction if the result is 64-bits otherwise use the
5649*da58b97aSjoerg // 32-bit version.
5650*da58b97aSjoerg unsigned Opc = VT == MVT::i64 ? X86::SETB_C64r : X86::SETB_C32r;
5651*da58b97aSjoerg MVT SetVT = VT == MVT::i64 ? MVT::i64 : MVT::i32;
5652*da58b97aSjoerg SDValue Result = SDValue(
5653*da58b97aSjoerg CurDAG->getMachineNode(Opc, dl, SetVT, EFLAGS, EFLAGS.getValue(1)), 0);
5654*da58b97aSjoerg
5655*da58b97aSjoerg // For less than 32-bits we need to extract from the 32-bit node.
5656*da58b97aSjoerg if (VT == MVT::i8 || VT == MVT::i16) {
5657*da58b97aSjoerg int SubIndex = VT == MVT::i16 ? X86::sub_16bit : X86::sub_8bit;
5658*da58b97aSjoerg Result = CurDAG->getTargetExtractSubreg(SubIndex, dl, VT, Result);
565906f32e7eSjoerg }
5660*da58b97aSjoerg
5661*da58b97aSjoerg ReplaceUses(SDValue(Node, 0), Result);
5662*da58b97aSjoerg CurDAG->RemoveDeadNode(Node);
5663*da58b97aSjoerg return;
5664*da58b97aSjoerg }
5665*da58b97aSjoerg case X86ISD::SBB: {
5666*da58b97aSjoerg if (isNullConstant(Node->getOperand(0)) &&
5667*da58b97aSjoerg isNullConstant(Node->getOperand(1))) {
5668*da58b97aSjoerg MVT VT = Node->getSimpleValueType(0);
5669*da58b97aSjoerg
5670*da58b97aSjoerg // Create zero.
5671*da58b97aSjoerg SDVTList VTs = CurDAG->getVTList(MVT::i32, MVT::i32);
5672*da58b97aSjoerg SDValue Zero =
5673*da58b97aSjoerg SDValue(CurDAG->getMachineNode(X86::MOV32r0, dl, VTs, None), 0);
5674*da58b97aSjoerg if (VT == MVT::i64) {
5675*da58b97aSjoerg Zero = SDValue(
5676*da58b97aSjoerg CurDAG->getMachineNode(
5677*da58b97aSjoerg TargetOpcode::SUBREG_TO_REG, dl, MVT::i64,
5678*da58b97aSjoerg CurDAG->getTargetConstant(0, dl, MVT::i64), Zero,
5679*da58b97aSjoerg CurDAG->getTargetConstant(X86::sub_32bit, dl, MVT::i32)),
5680*da58b97aSjoerg 0);
5681*da58b97aSjoerg }
5682*da58b97aSjoerg
5683*da58b97aSjoerg // Copy flags to the EFLAGS register and glue it to next node.
5684*da58b97aSjoerg SDValue EFLAGS =
5685*da58b97aSjoerg CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, X86::EFLAGS,
5686*da58b97aSjoerg Node->getOperand(2), SDValue());
5687*da58b97aSjoerg
5688*da58b97aSjoerg // Create a 64-bit instruction if the result is 64-bits otherwise use the
5689*da58b97aSjoerg // 32-bit version.
5690*da58b97aSjoerg unsigned Opc = VT == MVT::i64 ? X86::SBB64rr : X86::SBB32rr;
5691*da58b97aSjoerg MVT SBBVT = VT == MVT::i64 ? MVT::i64 : MVT::i32;
5692*da58b97aSjoerg VTs = CurDAG->getVTList(SBBVT, MVT::i32);
5693*da58b97aSjoerg SDValue Result =
5694*da58b97aSjoerg SDValue(CurDAG->getMachineNode(Opc, dl, VTs, {Zero, Zero, EFLAGS,
5695*da58b97aSjoerg EFLAGS.getValue(1)}),
5696*da58b97aSjoerg 0);
5697*da58b97aSjoerg
5698*da58b97aSjoerg // Replace the flag use.
5699*da58b97aSjoerg ReplaceUses(SDValue(Node, 1), Result.getValue(1));
5700*da58b97aSjoerg
5701*da58b97aSjoerg // Replace the result use.
5702*da58b97aSjoerg if (!SDValue(Node, 0).use_empty()) {
5703*da58b97aSjoerg // For less than 32-bits we need to extract from the 32-bit node.
5704*da58b97aSjoerg if (VT == MVT::i8 || VT == MVT::i16) {
5705*da58b97aSjoerg int SubIndex = VT == MVT::i16 ? X86::sub_16bit : X86::sub_8bit;
5706*da58b97aSjoerg Result = CurDAG->getTargetExtractSubreg(SubIndex, dl, VT, Result);
5707*da58b97aSjoerg }
5708*da58b97aSjoerg ReplaceUses(SDValue(Node, 0), Result);
5709*da58b97aSjoerg }
5710*da58b97aSjoerg
5711*da58b97aSjoerg CurDAG->RemoveDeadNode(Node);
5712*da58b97aSjoerg return;
5713*da58b97aSjoerg }
5714*da58b97aSjoerg break;
5715*da58b97aSjoerg }
5716*da58b97aSjoerg case X86ISD::MGATHER: {
5717*da58b97aSjoerg auto *Mgt = cast<X86MaskedGatherSDNode>(Node);
5718*da58b97aSjoerg SDValue IndexOp = Mgt->getIndex();
5719*da58b97aSjoerg SDValue Mask = Mgt->getMask();
5720*da58b97aSjoerg MVT IndexVT = IndexOp.getSimpleValueType();
5721*da58b97aSjoerg MVT ValueVT = Node->getSimpleValueType(0);
5722*da58b97aSjoerg MVT MaskVT = Mask.getSimpleValueType();
5723*da58b97aSjoerg
5724*da58b97aSjoerg // This is just to prevent crashes if the nodes are malformed somehow. We're
5725*da58b97aSjoerg // otherwise only doing loose type checking in here based on type what
5726*da58b97aSjoerg // a type constraint would say just like table based isel.
5727*da58b97aSjoerg if (!ValueVT.isVector() || !MaskVT.isVector())
5728*da58b97aSjoerg break;
5729*da58b97aSjoerg
5730*da58b97aSjoerg unsigned NumElts = ValueVT.getVectorNumElements();
5731*da58b97aSjoerg MVT ValueSVT = ValueVT.getVectorElementType();
5732*da58b97aSjoerg
5733*da58b97aSjoerg bool IsFP = ValueSVT.isFloatingPoint();
5734*da58b97aSjoerg unsigned EltSize = ValueSVT.getSizeInBits();
5735*da58b97aSjoerg
5736*da58b97aSjoerg unsigned Opc = 0;
5737*da58b97aSjoerg bool AVX512Gather = MaskVT.getVectorElementType() == MVT::i1;
5738*da58b97aSjoerg if (AVX512Gather) {
5739*da58b97aSjoerg if (IndexVT == MVT::v4i32 && NumElts == 4 && EltSize == 32)
5740*da58b97aSjoerg Opc = IsFP ? X86::VGATHERDPSZ128rm : X86::VPGATHERDDZ128rm;
5741*da58b97aSjoerg else if (IndexVT == MVT::v8i32 && NumElts == 8 && EltSize == 32)
5742*da58b97aSjoerg Opc = IsFP ? X86::VGATHERDPSZ256rm : X86::VPGATHERDDZ256rm;
5743*da58b97aSjoerg else if (IndexVT == MVT::v16i32 && NumElts == 16 && EltSize == 32)
5744*da58b97aSjoerg Opc = IsFP ? X86::VGATHERDPSZrm : X86::VPGATHERDDZrm;
5745*da58b97aSjoerg else if (IndexVT == MVT::v4i32 && NumElts == 2 && EltSize == 64)
5746*da58b97aSjoerg Opc = IsFP ? X86::VGATHERDPDZ128rm : X86::VPGATHERDQZ128rm;
5747*da58b97aSjoerg else if (IndexVT == MVT::v4i32 && NumElts == 4 && EltSize == 64)
5748*da58b97aSjoerg Opc = IsFP ? X86::VGATHERDPDZ256rm : X86::VPGATHERDQZ256rm;
5749*da58b97aSjoerg else if (IndexVT == MVT::v8i32 && NumElts == 8 && EltSize == 64)
5750*da58b97aSjoerg Opc = IsFP ? X86::VGATHERDPDZrm : X86::VPGATHERDQZrm;
5751*da58b97aSjoerg else if (IndexVT == MVT::v2i64 && NumElts == 4 && EltSize == 32)
5752*da58b97aSjoerg Opc = IsFP ? X86::VGATHERQPSZ128rm : X86::VPGATHERQDZ128rm;
5753*da58b97aSjoerg else if (IndexVT == MVT::v4i64 && NumElts == 4 && EltSize == 32)
5754*da58b97aSjoerg Opc = IsFP ? X86::VGATHERQPSZ256rm : X86::VPGATHERQDZ256rm;
5755*da58b97aSjoerg else if (IndexVT == MVT::v8i64 && NumElts == 8 && EltSize == 32)
5756*da58b97aSjoerg Opc = IsFP ? X86::VGATHERQPSZrm : X86::VPGATHERQDZrm;
5757*da58b97aSjoerg else if (IndexVT == MVT::v2i64 && NumElts == 2 && EltSize == 64)
5758*da58b97aSjoerg Opc = IsFP ? X86::VGATHERQPDZ128rm : X86::VPGATHERQQZ128rm;
5759*da58b97aSjoerg else if (IndexVT == MVT::v4i64 && NumElts == 4 && EltSize == 64)
5760*da58b97aSjoerg Opc = IsFP ? X86::VGATHERQPDZ256rm : X86::VPGATHERQQZ256rm;
5761*da58b97aSjoerg else if (IndexVT == MVT::v8i64 && NumElts == 8 && EltSize == 64)
5762*da58b97aSjoerg Opc = IsFP ? X86::VGATHERQPDZrm : X86::VPGATHERQQZrm;
5763*da58b97aSjoerg } else {
5764*da58b97aSjoerg assert(EVT(MaskVT) == EVT(ValueVT).changeVectorElementTypeToInteger() &&
5765*da58b97aSjoerg "Unexpected mask VT!");
5766*da58b97aSjoerg if (IndexVT == MVT::v4i32 && NumElts == 4 && EltSize == 32)
5767*da58b97aSjoerg Opc = IsFP ? X86::VGATHERDPSrm : X86::VPGATHERDDrm;
5768*da58b97aSjoerg else if (IndexVT == MVT::v8i32 && NumElts == 8 && EltSize == 32)
5769*da58b97aSjoerg Opc = IsFP ? X86::VGATHERDPSYrm : X86::VPGATHERDDYrm;
5770*da58b97aSjoerg else if (IndexVT == MVT::v4i32 && NumElts == 2 && EltSize == 64)
5771*da58b97aSjoerg Opc = IsFP ? X86::VGATHERDPDrm : X86::VPGATHERDQrm;
5772*da58b97aSjoerg else if (IndexVT == MVT::v4i32 && NumElts == 4 && EltSize == 64)
5773*da58b97aSjoerg Opc = IsFP ? X86::VGATHERDPDYrm : X86::VPGATHERDQYrm;
5774*da58b97aSjoerg else if (IndexVT == MVT::v2i64 && NumElts == 4 && EltSize == 32)
5775*da58b97aSjoerg Opc = IsFP ? X86::VGATHERQPSrm : X86::VPGATHERQDrm;
5776*da58b97aSjoerg else if (IndexVT == MVT::v4i64 && NumElts == 4 && EltSize == 32)
5777*da58b97aSjoerg Opc = IsFP ? X86::VGATHERQPSYrm : X86::VPGATHERQDYrm;
5778*da58b97aSjoerg else if (IndexVT == MVT::v2i64 && NumElts == 2 && EltSize == 64)
5779*da58b97aSjoerg Opc = IsFP ? X86::VGATHERQPDrm : X86::VPGATHERQQrm;
5780*da58b97aSjoerg else if (IndexVT == MVT::v4i64 && NumElts == 4 && EltSize == 64)
5781*da58b97aSjoerg Opc = IsFP ? X86::VGATHERQPDYrm : X86::VPGATHERQQYrm;
5782*da58b97aSjoerg }
5783*da58b97aSjoerg
5784*da58b97aSjoerg if (!Opc)
5785*da58b97aSjoerg break;
5786*da58b97aSjoerg
5787*da58b97aSjoerg SDValue Base, Scale, Index, Disp, Segment;
5788*da58b97aSjoerg if (!selectVectorAddr(Mgt, Mgt->getBasePtr(), IndexOp, Mgt->getScale(),
5789*da58b97aSjoerg Base, Scale, Index, Disp, Segment))
5790*da58b97aSjoerg break;
5791*da58b97aSjoerg
5792*da58b97aSjoerg SDValue PassThru = Mgt->getPassThru();
5793*da58b97aSjoerg SDValue Chain = Mgt->getChain();
5794*da58b97aSjoerg // Gather instructions have a mask output not in the ISD node.
5795*da58b97aSjoerg SDVTList VTs = CurDAG->getVTList(ValueVT, MaskVT, MVT::Other);
5796*da58b97aSjoerg
5797*da58b97aSjoerg MachineSDNode *NewNode;
5798*da58b97aSjoerg if (AVX512Gather) {
5799*da58b97aSjoerg SDValue Ops[] = {PassThru, Mask, Base, Scale,
5800*da58b97aSjoerg Index, Disp, Segment, Chain};
5801*da58b97aSjoerg NewNode = CurDAG->getMachineNode(Opc, SDLoc(dl), VTs, Ops);
5802*da58b97aSjoerg } else {
5803*da58b97aSjoerg SDValue Ops[] = {PassThru, Base, Scale, Index,
5804*da58b97aSjoerg Disp, Segment, Mask, Chain};
5805*da58b97aSjoerg NewNode = CurDAG->getMachineNode(Opc, SDLoc(dl), VTs, Ops);
5806*da58b97aSjoerg }
5807*da58b97aSjoerg CurDAG->setNodeMemRefs(NewNode, {Mgt->getMemOperand()});
5808*da58b97aSjoerg ReplaceUses(SDValue(Node, 0), SDValue(NewNode, 0));
5809*da58b97aSjoerg ReplaceUses(SDValue(Node, 1), SDValue(NewNode, 2));
5810*da58b97aSjoerg CurDAG->RemoveDeadNode(Node);
5811*da58b97aSjoerg return;
5812*da58b97aSjoerg }
5813*da58b97aSjoerg case X86ISD::MSCATTER: {
5814*da58b97aSjoerg auto *Sc = cast<X86MaskedScatterSDNode>(Node);
5815*da58b97aSjoerg SDValue Value = Sc->getValue();
5816*da58b97aSjoerg SDValue IndexOp = Sc->getIndex();
5817*da58b97aSjoerg MVT IndexVT = IndexOp.getSimpleValueType();
5818*da58b97aSjoerg MVT ValueVT = Value.getSimpleValueType();
5819*da58b97aSjoerg
5820*da58b97aSjoerg // This is just to prevent crashes if the nodes are malformed somehow. We're
5821*da58b97aSjoerg // otherwise only doing loose type checking in here based on type what
5822*da58b97aSjoerg // a type constraint would say just like table based isel.
5823*da58b97aSjoerg if (!ValueVT.isVector())
5824*da58b97aSjoerg break;
5825*da58b97aSjoerg
5826*da58b97aSjoerg unsigned NumElts = ValueVT.getVectorNumElements();
5827*da58b97aSjoerg MVT ValueSVT = ValueVT.getVectorElementType();
5828*da58b97aSjoerg
5829*da58b97aSjoerg bool IsFP = ValueSVT.isFloatingPoint();
5830*da58b97aSjoerg unsigned EltSize = ValueSVT.getSizeInBits();
5831*da58b97aSjoerg
5832*da58b97aSjoerg unsigned Opc;
5833*da58b97aSjoerg if (IndexVT == MVT::v4i32 && NumElts == 4 && EltSize == 32)
5834*da58b97aSjoerg Opc = IsFP ? X86::VSCATTERDPSZ128mr : X86::VPSCATTERDDZ128mr;
5835*da58b97aSjoerg else if (IndexVT == MVT::v8i32 && NumElts == 8 && EltSize == 32)
5836*da58b97aSjoerg Opc = IsFP ? X86::VSCATTERDPSZ256mr : X86::VPSCATTERDDZ256mr;
5837*da58b97aSjoerg else if (IndexVT == MVT::v16i32 && NumElts == 16 && EltSize == 32)
5838*da58b97aSjoerg Opc = IsFP ? X86::VSCATTERDPSZmr : X86::VPSCATTERDDZmr;
5839*da58b97aSjoerg else if (IndexVT == MVT::v4i32 && NumElts == 2 && EltSize == 64)
5840*da58b97aSjoerg Opc = IsFP ? X86::VSCATTERDPDZ128mr : X86::VPSCATTERDQZ128mr;
5841*da58b97aSjoerg else if (IndexVT == MVT::v4i32 && NumElts == 4 && EltSize == 64)
5842*da58b97aSjoerg Opc = IsFP ? X86::VSCATTERDPDZ256mr : X86::VPSCATTERDQZ256mr;
5843*da58b97aSjoerg else if (IndexVT == MVT::v8i32 && NumElts == 8 && EltSize == 64)
5844*da58b97aSjoerg Opc = IsFP ? X86::VSCATTERDPDZmr : X86::VPSCATTERDQZmr;
5845*da58b97aSjoerg else if (IndexVT == MVT::v2i64 && NumElts == 4 && EltSize == 32)
5846*da58b97aSjoerg Opc = IsFP ? X86::VSCATTERQPSZ128mr : X86::VPSCATTERQDZ128mr;
5847*da58b97aSjoerg else if (IndexVT == MVT::v4i64 && NumElts == 4 && EltSize == 32)
5848*da58b97aSjoerg Opc = IsFP ? X86::VSCATTERQPSZ256mr : X86::VPSCATTERQDZ256mr;
5849*da58b97aSjoerg else if (IndexVT == MVT::v8i64 && NumElts == 8 && EltSize == 32)
5850*da58b97aSjoerg Opc = IsFP ? X86::VSCATTERQPSZmr : X86::VPSCATTERQDZmr;
5851*da58b97aSjoerg else if (IndexVT == MVT::v2i64 && NumElts == 2 && EltSize == 64)
5852*da58b97aSjoerg Opc = IsFP ? X86::VSCATTERQPDZ128mr : X86::VPSCATTERQQZ128mr;
5853*da58b97aSjoerg else if (IndexVT == MVT::v4i64 && NumElts == 4 && EltSize == 64)
5854*da58b97aSjoerg Opc = IsFP ? X86::VSCATTERQPDZ256mr : X86::VPSCATTERQQZ256mr;
5855*da58b97aSjoerg else if (IndexVT == MVT::v8i64 && NumElts == 8 && EltSize == 64)
5856*da58b97aSjoerg Opc = IsFP ? X86::VSCATTERQPDZmr : X86::VPSCATTERQQZmr;
5857*da58b97aSjoerg else
5858*da58b97aSjoerg break;
5859*da58b97aSjoerg
5860*da58b97aSjoerg SDValue Base, Scale, Index, Disp, Segment;
5861*da58b97aSjoerg if (!selectVectorAddr(Sc, Sc->getBasePtr(), IndexOp, Sc->getScale(),
5862*da58b97aSjoerg Base, Scale, Index, Disp, Segment))
5863*da58b97aSjoerg break;
5864*da58b97aSjoerg
5865*da58b97aSjoerg SDValue Mask = Sc->getMask();
5866*da58b97aSjoerg SDValue Chain = Sc->getChain();
5867*da58b97aSjoerg // Scatter instructions have a mask output not in the ISD node.
5868*da58b97aSjoerg SDVTList VTs = CurDAG->getVTList(Mask.getValueType(), MVT::Other);
5869*da58b97aSjoerg SDValue Ops[] = {Base, Scale, Index, Disp, Segment, Mask, Value, Chain};
5870*da58b97aSjoerg
5871*da58b97aSjoerg MachineSDNode *NewNode = CurDAG->getMachineNode(Opc, SDLoc(dl), VTs, Ops);
5872*da58b97aSjoerg CurDAG->setNodeMemRefs(NewNode, {Sc->getMemOperand()});
5873*da58b97aSjoerg ReplaceUses(SDValue(Node, 0), SDValue(NewNode, 1));
5874*da58b97aSjoerg CurDAG->RemoveDeadNode(Node);
5875*da58b97aSjoerg return;
5876*da58b97aSjoerg }
5877*da58b97aSjoerg case ISD::PREALLOCATED_SETUP: {
5878*da58b97aSjoerg auto *MFI = CurDAG->getMachineFunction().getInfo<X86MachineFunctionInfo>();
5879*da58b97aSjoerg auto CallId = MFI->getPreallocatedIdForCallSite(
5880*da58b97aSjoerg cast<SrcValueSDNode>(Node->getOperand(1))->getValue());
5881*da58b97aSjoerg SDValue Chain = Node->getOperand(0);
5882*da58b97aSjoerg SDValue CallIdValue = CurDAG->getTargetConstant(CallId, dl, MVT::i32);
5883*da58b97aSjoerg MachineSDNode *New = CurDAG->getMachineNode(
5884*da58b97aSjoerg TargetOpcode::PREALLOCATED_SETUP, dl, MVT::Other, CallIdValue, Chain);
5885*da58b97aSjoerg ReplaceUses(SDValue(Node, 0), SDValue(New, 0)); // Chain
5886*da58b97aSjoerg CurDAG->RemoveDeadNode(Node);
5887*da58b97aSjoerg return;
5888*da58b97aSjoerg }
5889*da58b97aSjoerg case ISD::PREALLOCATED_ARG: {
5890*da58b97aSjoerg auto *MFI = CurDAG->getMachineFunction().getInfo<X86MachineFunctionInfo>();
5891*da58b97aSjoerg auto CallId = MFI->getPreallocatedIdForCallSite(
5892*da58b97aSjoerg cast<SrcValueSDNode>(Node->getOperand(1))->getValue());
5893*da58b97aSjoerg SDValue Chain = Node->getOperand(0);
5894*da58b97aSjoerg SDValue CallIdValue = CurDAG->getTargetConstant(CallId, dl, MVT::i32);
5895*da58b97aSjoerg SDValue ArgIndex = Node->getOperand(2);
5896*da58b97aSjoerg SDValue Ops[3];
5897*da58b97aSjoerg Ops[0] = CallIdValue;
5898*da58b97aSjoerg Ops[1] = ArgIndex;
5899*da58b97aSjoerg Ops[2] = Chain;
5900*da58b97aSjoerg MachineSDNode *New = CurDAG->getMachineNode(
5901*da58b97aSjoerg TargetOpcode::PREALLOCATED_ARG, dl,
5902*da58b97aSjoerg CurDAG->getVTList(TLI->getPointerTy(CurDAG->getDataLayout()),
5903*da58b97aSjoerg MVT::Other),
5904*da58b97aSjoerg Ops);
5905*da58b97aSjoerg ReplaceUses(SDValue(Node, 0), SDValue(New, 0)); // Arg pointer
5906*da58b97aSjoerg ReplaceUses(SDValue(Node, 1), SDValue(New, 1)); // Chain
5907*da58b97aSjoerg CurDAG->RemoveDeadNode(Node);
5908*da58b97aSjoerg return;
5909*da58b97aSjoerg }
5910*da58b97aSjoerg case X86ISD::AESENCWIDE128KL:
5911*da58b97aSjoerg case X86ISD::AESDECWIDE128KL:
5912*da58b97aSjoerg case X86ISD::AESENCWIDE256KL:
5913*da58b97aSjoerg case X86ISD::AESDECWIDE256KL: {
5914*da58b97aSjoerg if (!Subtarget->hasWIDEKL())
5915*da58b97aSjoerg break;
5916*da58b97aSjoerg
5917*da58b97aSjoerg unsigned Opcode;
5918*da58b97aSjoerg switch (Node->getOpcode()) {
5919*da58b97aSjoerg default:
5920*da58b97aSjoerg llvm_unreachable("Unexpected opcode!");
5921*da58b97aSjoerg case X86ISD::AESENCWIDE128KL:
5922*da58b97aSjoerg Opcode = X86::AESENCWIDE128KL;
5923*da58b97aSjoerg break;
5924*da58b97aSjoerg case X86ISD::AESDECWIDE128KL:
5925*da58b97aSjoerg Opcode = X86::AESDECWIDE128KL;
5926*da58b97aSjoerg break;
5927*da58b97aSjoerg case X86ISD::AESENCWIDE256KL:
5928*da58b97aSjoerg Opcode = X86::AESENCWIDE256KL;
5929*da58b97aSjoerg break;
5930*da58b97aSjoerg case X86ISD::AESDECWIDE256KL:
5931*da58b97aSjoerg Opcode = X86::AESDECWIDE256KL;
5932*da58b97aSjoerg break;
5933*da58b97aSjoerg }
5934*da58b97aSjoerg
5935*da58b97aSjoerg SDValue Chain = Node->getOperand(0);
5936*da58b97aSjoerg SDValue Addr = Node->getOperand(1);
5937*da58b97aSjoerg
5938*da58b97aSjoerg SDValue Base, Scale, Index, Disp, Segment;
5939*da58b97aSjoerg if (!selectAddr(Node, Addr, Base, Scale, Index, Disp, Segment))
5940*da58b97aSjoerg break;
5941*da58b97aSjoerg
5942*da58b97aSjoerg Chain = CurDAG->getCopyToReg(Chain, dl, X86::XMM0, Node->getOperand(2),
5943*da58b97aSjoerg SDValue());
5944*da58b97aSjoerg Chain = CurDAG->getCopyToReg(Chain, dl, X86::XMM1, Node->getOperand(3),
5945*da58b97aSjoerg Chain.getValue(1));
5946*da58b97aSjoerg Chain = CurDAG->getCopyToReg(Chain, dl, X86::XMM2, Node->getOperand(4),
5947*da58b97aSjoerg Chain.getValue(1));
5948*da58b97aSjoerg Chain = CurDAG->getCopyToReg(Chain, dl, X86::XMM3, Node->getOperand(5),
5949*da58b97aSjoerg Chain.getValue(1));
5950*da58b97aSjoerg Chain = CurDAG->getCopyToReg(Chain, dl, X86::XMM4, Node->getOperand(6),
5951*da58b97aSjoerg Chain.getValue(1));
5952*da58b97aSjoerg Chain = CurDAG->getCopyToReg(Chain, dl, X86::XMM5, Node->getOperand(7),
5953*da58b97aSjoerg Chain.getValue(1));
5954*da58b97aSjoerg Chain = CurDAG->getCopyToReg(Chain, dl, X86::XMM6, Node->getOperand(8),
5955*da58b97aSjoerg Chain.getValue(1));
5956*da58b97aSjoerg Chain = CurDAG->getCopyToReg(Chain, dl, X86::XMM7, Node->getOperand(9),
5957*da58b97aSjoerg Chain.getValue(1));
5958*da58b97aSjoerg
5959*da58b97aSjoerg MachineSDNode *Res = CurDAG->getMachineNode(
5960*da58b97aSjoerg Opcode, dl, Node->getVTList(),
5961*da58b97aSjoerg {Base, Scale, Index, Disp, Segment, Chain, Chain.getValue(1)});
5962*da58b97aSjoerg CurDAG->setNodeMemRefs(Res, cast<MemSDNode>(Node)->getMemOperand());
5963*da58b97aSjoerg ReplaceNode(Node, Res);
596406f32e7eSjoerg return;
596506f32e7eSjoerg }
596606f32e7eSjoerg }
596706f32e7eSjoerg
596806f32e7eSjoerg SelectCode(Node);
596906f32e7eSjoerg }
597006f32e7eSjoerg
597106f32e7eSjoerg bool X86DAGToDAGISel::
SelectInlineAsmMemoryOperand(const SDValue & Op,unsigned ConstraintID,std::vector<SDValue> & OutOps)597206f32e7eSjoerg SelectInlineAsmMemoryOperand(const SDValue &Op, unsigned ConstraintID,
597306f32e7eSjoerg std::vector<SDValue> &OutOps) {
597406f32e7eSjoerg SDValue Op0, Op1, Op2, Op3, Op4;
597506f32e7eSjoerg switch (ConstraintID) {
597606f32e7eSjoerg default:
597706f32e7eSjoerg llvm_unreachable("Unexpected asm memory constraint");
597806f32e7eSjoerg case InlineAsm::Constraint_o: // offsetable ??
597906f32e7eSjoerg case InlineAsm::Constraint_v: // not offsetable ??
598006f32e7eSjoerg case InlineAsm::Constraint_m: // memory
598106f32e7eSjoerg case InlineAsm::Constraint_X:
598206f32e7eSjoerg if (!selectAddr(nullptr, Op, Op0, Op1, Op2, Op3, Op4))
598306f32e7eSjoerg return true;
598406f32e7eSjoerg break;
598506f32e7eSjoerg }
598606f32e7eSjoerg
598706f32e7eSjoerg OutOps.push_back(Op0);
598806f32e7eSjoerg OutOps.push_back(Op1);
598906f32e7eSjoerg OutOps.push_back(Op2);
599006f32e7eSjoerg OutOps.push_back(Op3);
599106f32e7eSjoerg OutOps.push_back(Op4);
599206f32e7eSjoerg return false;
599306f32e7eSjoerg }
599406f32e7eSjoerg
599506f32e7eSjoerg /// This pass converts a legalized DAG into a X86-specific DAG,
599606f32e7eSjoerg /// ready for instruction scheduling.
createX86ISelDag(X86TargetMachine & TM,CodeGenOpt::Level OptLevel)599706f32e7eSjoerg FunctionPass *llvm::createX86ISelDag(X86TargetMachine &TM,
599806f32e7eSjoerg CodeGenOpt::Level OptLevel) {
599906f32e7eSjoerg return new X86DAGToDAGISel(TM, OptLevel);
600006f32e7eSjoerg }
6001