1 //===- AMDGPULegalizerInfo.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
11 /// AMDGPU.
12 /// \todo This should be generated by TableGen.
13 //===----------------------------------------------------------------------===//
14 
15 #include "AMDGPU.h"
16 #include "AMDGPULegalizerInfo.h"
17 #include "AMDGPUTargetMachine.h"
18 #include "llvm/CodeGen/TargetOpcodes.h"
19 #include "llvm/CodeGen/ValueTypes.h"
20 #include "llvm/IR/DerivedTypes.h"
21 #include "llvm/IR/Type.h"
22 #include "llvm/Support/Debug.h"
23 
24 using namespace llvm;
25 using namespace LegalizeActions;
26 
27 AMDGPULegalizerInfo::AMDGPULegalizerInfo(const SISubtarget &ST,
28                                          const GCNTargetMachine &TM) {
29   using namespace TargetOpcode;
30 
31   auto GetAddrSpacePtr = [&TM](unsigned AS) {
32     return LLT::pointer(AS, TM.getPointerSizeInBits(AS));
33   };
34 
35   auto AMDGPUAS = ST.getAMDGPUAS();
36 
37   const LLT S1 = LLT::scalar(1);
38   const LLT V2S16 = LLT::vector(2, 16);
39 
40   const LLT S32 = LLT::scalar(32);
41   const LLT S64 = LLT::scalar(64);
42 
43   const LLT GlobalPtr = GetAddrSpacePtr(AMDGPUAS::GLOBAL_ADDRESS);
44   const LLT ConstantPtr = GetAddrSpacePtr(AMDGPUAS::CONSTANT_ADDRESS);
45   const LLT LocalPtr = GetAddrSpacePtr(AMDGPUAS::LOCAL_ADDRESS);
46   const LLT FlatPtr = GetAddrSpacePtr(AMDGPUAS.FLAT_ADDRESS);
47   const LLT PrivatePtr = GetAddrSpacePtr(AMDGPUAS.PRIVATE_ADDRESS);
48 
49   const LLT AddrSpaces[] = {
50     GlobalPtr,
51     ConstantPtr,
52     LocalPtr,
53     FlatPtr,
54     PrivatePtr
55   };
56 
57   setAction({G_ADD, S32}, Legal);
58   setAction({G_ASHR, S32}, Legal);
59   setAction({G_SUB, S32}, Legal);
60   setAction({G_MUL, S32}, Legal);
61   setAction({G_AND, S32}, Legal);
62   setAction({G_OR, S32}, Legal);
63   setAction({G_XOR, S32}, Legal);
64 
65   setAction({G_BITCAST, V2S16}, Legal);
66   setAction({G_BITCAST, 1, S32}, Legal);
67 
68   setAction({G_BITCAST, S32}, Legal);
69   setAction({G_BITCAST, 1, V2S16}, Legal);
70 
71   getActionDefinitionsBuilder(G_FCONSTANT)
72     .legalFor({S32, S64});
73   getActionDefinitionsBuilder({G_IMPLICIT_DEF, G_CONSTANT})
74     .legalFor({S1, S32, S64});
75 
76   // FIXME: i1 operands to intrinsics should always be legal, but other i1
77   // values may not be legal.  We need to figure out how to distinguish
78   // between these two scenarios.
79   setAction({G_CONSTANT, S1}, Legal);
80 
81   setAction({G_FADD, S32}, Legal);
82 
83   setAction({G_FCMP, S1}, Legal);
84   setAction({G_FCMP, 1, S32}, Legal);
85   setAction({G_FCMP, 1, S64}, Legal);
86 
87   setAction({G_FMUL, S32}, Legal);
88 
89   setAction({G_ZEXT, S64}, Legal);
90   setAction({G_ZEXT, 1, S32}, Legal);
91 
92   setAction({G_FPTOSI, S32}, Legal);
93   setAction({G_FPTOSI, 1, S32}, Legal);
94 
95   setAction({G_SITOFP, S32}, Legal);
96   setAction({G_SITOFP, 1, S32}, Legal);
97 
98   setAction({G_FPTOUI, S32}, Legal);
99   setAction({G_FPTOUI, 1, S32}, Legal);
100 
101   for (LLT PtrTy : AddrSpaces) {
102     LLT IdxTy = LLT::scalar(PtrTy.getSizeInBits());
103     setAction({G_GEP, PtrTy}, Legal);
104     setAction({G_GEP, 1, IdxTy}, Legal);
105   }
106 
107   setAction({G_ICMP, S1}, Legal);
108   setAction({G_ICMP, 1, S32}, Legal);
109 
110 
111   getActionDefinitionsBuilder({G_LOAD, G_STORE})
112     .legalIf([=, &ST](const LegalityQuery &Query) {
113         const LLT &Ty0 = Query.Types[0];
114 
115         // TODO: Decompose private loads into 4-byte components.
116         // TODO: Illegal flat loads on SI
117         switch (Ty0.getSizeInBits()) {
118         case 32:
119         case 64:
120         case 128:
121           return true;
122 
123         case 96:
124           // XXX hasLoadX3
125           return (ST.getGeneration() >= AMDGPUSubtarget::SEA_ISLANDS);
126 
127         case 256:
128         case 512:
129           // TODO: constant loads
130         default:
131           return false;
132         }
133       });
134 
135 
136 
137   setAction({G_SELECT, S32}, Legal);
138   setAction({G_SELECT, 1, S1}, Legal);
139 
140   setAction({G_SHL, S32}, Legal);
141 
142 
143   // FIXME: When RegBankSelect inserts copies, it will only create new
144   // registers with scalar types.  This means we can end up with
145   // G_LOAD/G_STORE/G_GEP instruction with scalar types for their pointer
146   // operands.  In assert builds, the instruction selector will assert
147   // if it sees a generic instruction which isn't legal, so we need to
148   // tell it that scalar types are legal for pointer operands
149   setAction({G_GEP, S64}, Legal);
150 
151   for (unsigned Op : {G_EXTRACT_VECTOR_ELT, G_INSERT_VECTOR_ELT}) {
152     getActionDefinitionsBuilder(Op)
153       .legalIf([=](const LegalityQuery &Query) {
154           const LLT &VecTy = Query.Types[1];
155           const LLT &IdxTy = Query.Types[2];
156           return VecTy.getSizeInBits() % 32 == 0 &&
157             VecTy.getSizeInBits() <= 512 &&
158             IdxTy.getSizeInBits() == 32;
159         });
160   }
161 
162   // FIXME: Doesn't handle extract of illegal sizes.
163   getActionDefinitionsBuilder(G_EXTRACT)
164     .unsupportedIf([=](const LegalityQuery &Query) {
165         return Query.Types[0].getSizeInBits() >= Query.Types[1].getSizeInBits();
166       })
167     .legalIf([=](const LegalityQuery &Query) {
168         const LLT &Ty0 = Query.Types[0];
169         const LLT &Ty1 = Query.Types[1];
170         return (Ty0.getSizeInBits() % 32 == 0) &&
171                (Ty1.getSizeInBits() % 32 == 0);
172       });
173 
174   // Merge/Unmerge
175   for (unsigned Op : {G_MERGE_VALUES, G_UNMERGE_VALUES}) {
176     unsigned BigTyIdx = Op == G_MERGE_VALUES ? 0 : 1;
177     unsigned LitTyIdx = Op == G_MERGE_VALUES ? 1 : 0;
178 
179     getActionDefinitionsBuilder(Op)
180       .legalIf([=](const LegalityQuery &Query) {
181           const LLT &BigTy = Query.Types[BigTyIdx];
182           const LLT &LitTy = Query.Types[LitTyIdx];
183           return BigTy.getSizeInBits() % 32 == 0 &&
184                  LitTy.getSizeInBits() % 32 == 0 &&
185                  BigTy.getSizeInBits() <= 512;
186         })
187       // Any vectors left are the wrong size. Scalarize them.
188       .fewerElementsIf([](const LegalityQuery &Query) { return true; },
189                        [](const LegalityQuery &Query) {
190                          return std::make_pair(
191                            0, Query.Types[0].getElementType());
192                        })
193       .fewerElementsIf([](const LegalityQuery &Query) { return true; },
194                        [](const LegalityQuery &Query) {
195                          return std::make_pair(
196                            1, Query.Types[1].getElementType());
197                        });
198 
199   }
200 
201   computeTables();
202   verify(*ST.getInstrInfo());
203 }
204