contrib/llvm/lib/Target/X86/X86LegalizerInfo.cpp

   1 //===- X86LegalizerInfo.cpp --------------------------------------*- C++ -*-==//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 /// \file
  10 /// This file implements the targeting of the Machinelegalizer class for X86.
  11 /// \todo This should be generated by TableGen.
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "X86LegalizerInfo.h"
  15 #include "X86Subtarget.h"
  16 #include "X86TargetMachine.h"
  17 #include "llvm/CodeGen/ValueTypes.h"
  18 #include "llvm/IR/DerivedTypes.h"
  19 #include "llvm/IR/Type.h"
  20 #include "llvm/Target/TargetOpcodes.h"
  21
  22 using namespace llvm;
  23 using namespace TargetOpcode;
  24
  25 #ifndef LLVM_BUILD_GLOBAL_ISEL
  26 #error "You shouldn't build this"
  27 #endif
  28
  29 X86LegalizerInfo::X86LegalizerInfo(const X86Subtarget &STI,
  30                                    const X86TargetMachine &TM)
  31     : Subtarget(STI), TM(TM) {
  32
  33   setLegalizerInfo32bit();
  34   setLegalizerInfo64bit();
  35   setLegalizerInfoSSE1();
  36   setLegalizerInfoSSE2();
  37
  38   computeTables();
  39 }
  40
  41 void X86LegalizerInfo::setLegalizerInfo32bit() {
  42
  43   if (Subtarget.is64Bit())
  44     return;
  45
  46   const LLT p0 = LLT::pointer(0, 32);
  47   const LLT s1 = LLT::scalar(1);
  48   const LLT s8 = LLT::scalar(8);
  49   const LLT s16 = LLT::scalar(16);
  50   const LLT s32 = LLT::scalar(32);
  51   const LLT s64 = LLT::scalar(64);
  52
  53   for (unsigned BinOp : {G_ADD, G_SUB})
  54     for (auto Ty : {s8, s16, s32})
  55       setAction({BinOp, Ty}, Legal);
  56
  57   for (unsigned MemOp : {G_LOAD, G_STORE}) {
  58     for (auto Ty : {s8, s16, s32, p0})
  59       setAction({MemOp, Ty}, Legal);
  60
  61     // And everything's fine in addrspace 0.
  62     setAction({MemOp, 1, p0}, Legal);
  63   }
  64
  65   // Pointer-handling
  66   setAction({G_FRAME_INDEX, p0}, Legal);
  67
  68   // Constants
  69   for (auto Ty : {s8, s16, s32, p0})
  70     setAction({TargetOpcode::G_CONSTANT, Ty}, Legal);
  71
  72   setAction({TargetOpcode::G_CONSTANT, s1}, WidenScalar);
  73   setAction({TargetOpcode::G_CONSTANT, s64}, NarrowScalar);
  74 }
  75
  76 void X86LegalizerInfo::setLegalizerInfo64bit() {
  77
  78   if (!Subtarget.is64Bit())
  79     return;
  80
  81   const LLT p0 = LLT::pointer(0, TM.getPointerSize() * 8);
  82   const LLT s1 = LLT::scalar(1);
  83   const LLT s8 = LLT::scalar(8);
  84   const LLT s16 = LLT::scalar(16);
  85   const LLT s32 = LLT::scalar(32);
  86   const LLT s64 = LLT::scalar(64);
  87
  88   for (unsigned BinOp : {G_ADD, G_SUB})
  89     for (auto Ty : {s8, s16, s32, s64})
  90       setAction({BinOp, Ty}, Legal);
  91
  92   for (unsigned MemOp : {G_LOAD, G_STORE}) {
  93     for (auto Ty : {s8, s16, s32, s64, p0})
  94       setAction({MemOp, Ty}, Legal);
  95
  96     // And everything's fine in addrspace 0.
  97     setAction({MemOp, 1, p0}, Legal);
  98   }
  99
 100   // Pointer-handling
 101   setAction({G_FRAME_INDEX, p0}, Legal);
 102
 103   // Constants
 104   for (auto Ty : {s8, s16, s32, s64, p0})
 105     setAction({TargetOpcode::G_CONSTANT, Ty}, Legal);
 106
 107   setAction({TargetOpcode::G_CONSTANT, s1}, WidenScalar);
 108 }
 109
 110 void X86LegalizerInfo::setLegalizerInfoSSE1() {
 111   if (!Subtarget.hasSSE1())
 112     return;
 113
 114   const LLT s32 = LLT::scalar(32);
 115   const LLT v4s32 = LLT::vector(4, 32);
 116   const LLT v2s64 = LLT::vector(2, 64);
 117
 118   for (unsigned BinOp : {G_FADD, G_FSUB, G_FMUL, G_FDIV})
 119     for (auto Ty : {s32, v4s32})
 120       setAction({BinOp, Ty}, Legal);
 121
 122   for (unsigned MemOp : {G_LOAD, G_STORE})
 123     for (auto Ty : {v4s32, v2s64})
 124       setAction({MemOp, Ty}, Legal);
 125 }
 126
 127 void X86LegalizerInfo::setLegalizerInfoSSE2() {
 128   if (!Subtarget.hasSSE2())
 129     return;
 130
 131   const LLT s64 = LLT::scalar(64);
 132   const LLT v4s32 = LLT::vector(4, 32);
 133   const LLT v2s64 = LLT::vector(2, 64);
 134
 135   for (unsigned BinOp : {G_FADD, G_FSUB, G_FMUL, G_FDIV})
 136     for (auto Ty : {s64, v2s64})
 137       setAction({BinOp, Ty}, Legal);
 138
 139   for (unsigned BinOp : {G_ADD, G_SUB})
 140     for (auto Ty : {v4s32})
 141       setAction({BinOp, Ty}, Legal);
 142 }