89a2db74a75eff147e58c2ef73c22defe757481a
[oota-llvm.git] / lib / Target / ARM / ARMBaseInstrInfo.h
1 //===- ARMBaseInstrInfo.h - ARM Base Instruction Information ----*- 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 //
10 // This file contains the Base ARM implementation of the TargetInstrInfo class.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #ifndef ARMBASEINSTRUCTIONINFO_H
15 #define ARMBASEINSTRUCTIONINFO_H
16
17 #include "ARM.h"
18 #include "ARMRegisterInfo.h"
19 #include "llvm/CodeGen/MachineInstrBuilder.h"
20 #include "llvm/Target/TargetInstrInfo.h"
21
22 namespace llvm {
23
24 /// ARMII - This namespace holds all of the target specific flags that
25 /// instruction info tracks.
26 ///
27 namespace ARMII {
28   enum {
29     //===------------------------------------------------------------------===//
30     // Instruction Flags.
31
32     //===------------------------------------------------------------------===//
33     // This four-bit field describes the addressing mode used.
34
35     AddrModeMask  = 0xf,
36     AddrModeNone    = 0,
37     AddrMode1       = 1,
38     AddrMode2       = 2,
39     AddrMode3       = 3,
40     AddrMode4       = 4,
41     AddrMode5       = 5,
42     AddrMode6       = 6,
43     AddrModeT1_1    = 7,
44     AddrModeT1_2    = 8,
45     AddrModeT1_4    = 9,
46     AddrModeT1_s    = 10, // i8 * 4 for pc and sp relative data
47     AddrModeT2_i12  = 11,
48     AddrModeT2_i8   = 12,
49     AddrModeT2_so   = 13,
50     AddrModeT2_pc   = 14, // +/- i12 for pc relative data
51     AddrModeT2_i8s4 = 15, // i8 * 4
52
53     // Size* - Flags to keep track of the size of an instruction.
54     SizeShift     = 4,
55     SizeMask      = 7 << SizeShift,
56     SizeSpecial   = 1,   // 0 byte pseudo or special case.
57     Size8Bytes    = 2,
58     Size4Bytes    = 3,
59     Size2Bytes    = 4,
60
61     // IndexMode - Unindex, pre-indexed, or post-indexed are valid for load
62     // and store ops only.  Generic "updating" flag is used for ld/st multiple.
63     IndexModeShift = 7,
64     IndexModeMask  = 3 << IndexModeShift,
65     IndexModePre   = 1,
66     IndexModePost  = 2,
67     IndexModeUpd   = 3,
68
69     //===------------------------------------------------------------------===//
70     // Instruction encoding formats.
71     //
72     FormShift     = 9,
73     FormMask      = 0x3f << FormShift,
74
75     // Pseudo instructions
76     Pseudo        = 0  << FormShift,
77
78     // Multiply instructions
79     MulFrm        = 1  << FormShift,
80
81     // Branch instructions
82     BrFrm         = 2  << FormShift,
83     BrMiscFrm     = 3  << FormShift,
84
85     // Data Processing instructions
86     DPFrm         = 4  << FormShift,
87     DPSoRegFrm    = 5  << FormShift,
88
89     // Load and Store
90     LdFrm         = 6  << FormShift,
91     StFrm         = 7  << FormShift,
92     LdMiscFrm     = 8  << FormShift,
93     StMiscFrm     = 9  << FormShift,
94     LdStMulFrm    = 10 << FormShift,
95
96     LdStExFrm     = 11 << FormShift,
97
98     // Miscellaneous arithmetic instructions
99     ArithMiscFrm  = 12 << FormShift,
100
101     // Extend instructions
102     ExtFrm        = 13 << FormShift,
103
104     // VFP formats
105     VFPUnaryFrm   = 14 << FormShift,
106     VFPBinaryFrm  = 15 << FormShift,
107     VFPConv1Frm   = 16 << FormShift,
108     VFPConv2Frm   = 17 << FormShift,
109     VFPConv3Frm   = 18 << FormShift,
110     VFPConv4Frm   = 19 << FormShift,
111     VFPConv5Frm   = 20 << FormShift,
112     VFPLdStFrm    = 21 << FormShift,
113     VFPLdStMulFrm = 22 << FormShift,
114     VFPMiscFrm    = 23 << FormShift,
115
116     // Thumb format
117     ThumbFrm      = 24 << FormShift,
118
119     // Miscelleaneous format
120     MiscFrm       = 25 << FormShift,
121
122     // NEON formats
123     NGetLnFrm     = 26 << FormShift,
124     NSetLnFrm     = 27 << FormShift,
125     NDupFrm       = 28 << FormShift,
126     NLdStFrm      = 29 << FormShift,
127     N1RegModImmFrm= 30 << FormShift,
128     N2RegFrm      = 31 << FormShift,
129     NVCVTFrm      = 32 << FormShift,
130     NVDupLnFrm    = 33 << FormShift,
131     N2RegVShLFrm  = 34 << FormShift,
132     N2RegVShRFrm  = 35 << FormShift,
133     N3RegFrm      = 36 << FormShift,
134     N3RegVShFrm   = 37 << FormShift,
135     NVExtFrm      = 38 << FormShift,
136     NVMulSLFrm    = 39 << FormShift,
137     NVTBLFrm      = 40 << FormShift,
138
139     //===------------------------------------------------------------------===//
140     // Misc flags.
141
142     // UnaryDP - Indicates this is a unary data processing instruction, i.e.
143     // it doesn't have a Rn operand.
144     UnaryDP       = 1 << 15,
145
146     // Xform16Bit - Indicates this Thumb2 instruction may be transformed into
147     // a 16-bit Thumb instruction if certain conditions are met.
148     Xform16Bit    = 1 << 16,
149
150     //===------------------------------------------------------------------===//
151     // Code domain.
152     DomainShift   = 17,
153     DomainMask    = 3 << DomainShift,
154     DomainGeneral = 0 << DomainShift,
155     DomainVFP     = 1 << DomainShift,
156     DomainNEON    = 2 << DomainShift,
157
158     //===------------------------------------------------------------------===//
159     // Field shifts - such shifts are used to set field while generating
160     // machine instructions.
161     M_BitShift     = 5,
162     ShiftImmShift  = 5,
163     ShiftShift     = 7,
164     N_BitShift     = 7,
165     ImmHiShift     = 8,
166     SoRotImmShift  = 8,
167     RegRsShift     = 8,
168     ExtRotImmShift = 10,
169     RegRdLoShift   = 12,
170     RegRdShift     = 12,
171     RegRdHiShift   = 16,
172     RegRnShift     = 16,
173     S_BitShift     = 20,
174     W_BitShift     = 21,
175     AM3_I_BitShift = 22,
176     D_BitShift     = 22,
177     U_BitShift     = 23,
178     P_BitShift     = 24,
179     I_BitShift     = 25,
180     CondShift      = 28
181   };
182
183   /// Target Operand Flag enum.
184   enum TOF {
185     //===------------------------------------------------------------------===//
186     // ARM Specific MachineOperand flags.
187
188     MO_NO_FLAG,
189
190     /// MO_LO16 - On a symbol operand, this represents a relocation containing
191     /// lower 16 bit of the address. Used only via movw instruction.
192     MO_LO16,
193
194     /// MO_HI16 - On a symbol operand, this represents a relocation containing
195     /// higher 16 bit of the address. Used only via movt instruction.
196     MO_HI16
197   };
198 }
199
200 class ARMBaseInstrInfo : public TargetInstrInfoImpl {
201   const ARMSubtarget& Subtarget;
202 protected:
203   // Can be only subclassed.
204   explicit ARMBaseInstrInfo(const ARMSubtarget &STI);
205 public:
206   // Return the non-pre/post incrementing version of 'Opc'. Return 0
207   // if there is not such an opcode.
208   virtual unsigned getUnindexedOpcode(unsigned Opc) const =0;
209
210   virtual MachineInstr *convertToThreeAddress(MachineFunction::iterator &MFI,
211                                               MachineBasicBlock::iterator &MBBI,
212                                               LiveVariables *LV) const;
213
214   virtual const ARMBaseRegisterInfo &getRegisterInfo() const =0;
215   const ARMSubtarget &getSubtarget() const { return Subtarget; }
216
217   bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
218                                  MachineBasicBlock::iterator MI,
219                                  const std::vector<CalleeSavedInfo> &CSI,
220                                  const TargetRegisterInfo *TRI) const;
221
222   // Branch analysis.
223   virtual bool AnalyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
224                              MachineBasicBlock *&FBB,
225                              SmallVectorImpl<MachineOperand> &Cond,
226                              bool AllowModify) const;
227   virtual unsigned RemoveBranch(MachineBasicBlock &MBB) const;
228   virtual unsigned InsertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
229                                 MachineBasicBlock *FBB,
230                                 const SmallVectorImpl<MachineOperand> &Cond,
231                                 DebugLoc DL) const;
232
233   virtual
234   bool ReverseBranchCondition(SmallVectorImpl<MachineOperand> &Cond) const;
235
236   // Predication support.
237   bool isPredicated(const MachineInstr *MI) const {
238     int PIdx = MI->findFirstPredOperandIdx();
239     return PIdx != -1 && MI->getOperand(PIdx).getImm() != ARMCC::AL;
240   }
241
242   ARMCC::CondCodes getPredicate(const MachineInstr *MI) const {
243     int PIdx = MI->findFirstPredOperandIdx();
244     return PIdx != -1 ? (ARMCC::CondCodes)MI->getOperand(PIdx).getImm()
245                       : ARMCC::AL;
246   }
247
248   virtual
249   bool PredicateInstruction(MachineInstr *MI,
250                             const SmallVectorImpl<MachineOperand> &Pred) const;
251
252   virtual
253   bool SubsumesPredicate(const SmallVectorImpl<MachineOperand> &Pred1,
254                          const SmallVectorImpl<MachineOperand> &Pred2) const;
255
256   virtual bool DefinesPredicate(MachineInstr *MI,
257                                 std::vector<MachineOperand> &Pred) const;
258
259   virtual bool isPredicable(MachineInstr *MI) const;
260
261   /// GetInstSize - Returns the size of the specified MachineInstr.
262   ///
263   virtual unsigned GetInstSizeInBytes(const MachineInstr* MI) const;
264
265   /// Return true if the instruction is a register to register move and return
266   /// the source and dest operands and their sub-register indices by reference.
267   virtual bool isMoveInstr(const MachineInstr &MI,
268                            unsigned &SrcReg, unsigned &DstReg,
269                            unsigned &SrcSubIdx, unsigned &DstSubIdx) const;
270
271   virtual unsigned isLoadFromStackSlot(const MachineInstr *MI,
272                                        int &FrameIndex) const;
273   virtual unsigned isStoreToStackSlot(const MachineInstr *MI,
274                                       int &FrameIndex) const;
275
276   virtual void copyPhysReg(MachineBasicBlock &MBB,
277                            MachineBasicBlock::iterator I, DebugLoc DL,
278                            unsigned DestReg, unsigned SrcReg,
279                            bool KillSrc) const;
280
281   virtual void storeRegToStackSlot(MachineBasicBlock &MBB,
282                                    MachineBasicBlock::iterator MBBI,
283                                    unsigned SrcReg, bool isKill, int FrameIndex,
284                                    const TargetRegisterClass *RC,
285                                    const TargetRegisterInfo *TRI) const;
286
287   virtual void loadRegFromStackSlot(MachineBasicBlock &MBB,
288                                     MachineBasicBlock::iterator MBBI,
289                                     unsigned DestReg, int FrameIndex,
290                                     const TargetRegisterClass *RC,
291                                     const TargetRegisterInfo *TRI) const;
292
293   virtual MachineInstr *emitFrameIndexDebugValue(MachineFunction &MF,
294                                                  int FrameIx,
295                                                  uint64_t Offset,
296                                                  const MDNode *MDPtr,
297                                                  DebugLoc DL) const;
298
299   virtual void reMaterialize(MachineBasicBlock &MBB,
300                              MachineBasicBlock::iterator MI,
301                              unsigned DestReg, unsigned SubIdx,
302                              const MachineInstr *Orig,
303                              const TargetRegisterInfo &TRI) const;
304
305   MachineInstr *duplicate(MachineInstr *Orig, MachineFunction &MF) const;
306
307   virtual bool produceSameValue(const MachineInstr *MI0,
308                                 const MachineInstr *MI1) const;
309
310   /// areLoadsFromSameBasePtr - This is used by the pre-regalloc scheduler to
311   /// determine if two loads are loading from the same base address. It should
312   /// only return true if the base pointers are the same and the only
313   /// differences between the two addresses is the offset. It also returns the
314   /// offsets by reference.
315   virtual bool areLoadsFromSameBasePtr(SDNode *Load1, SDNode *Load2,
316                                        int64_t &Offset1, int64_t &Offset2)const;
317
318   /// shouldScheduleLoadsNear - This is a used by the pre-regalloc scheduler to
319   /// determine (in conjuction with areLoadsFromSameBasePtr) if two loads should
320   /// be scheduled togther. On some targets if two loads are loading from
321   /// addresses in the same cache line, it's better if they are scheduled
322   /// together. This function takes two integers that represent the load offsets
323   /// from the common base address. It returns true if it decides it's desirable
324   /// to schedule the two loads together. "NumLoads" is the number of loads that
325   /// have already been scheduled after Load1.
326   virtual bool shouldScheduleLoadsNear(SDNode *Load1, SDNode *Load2,
327                                        int64_t Offset1, int64_t Offset2,
328                                        unsigned NumLoads) const;
329
330   virtual bool isSchedulingBoundary(const MachineInstr *MI,
331                                     const MachineBasicBlock *MBB,
332                                     const MachineFunction &MF) const;
333
334   virtual bool isProfitableToIfCvt(MachineBasicBlock &MBB,
335                                    unsigned NumInstrs) const;
336
337   virtual bool isProfitableToIfCvt(MachineBasicBlock &TMBB,unsigned NumT,
338                                    MachineBasicBlock &FMBB,unsigned NumF) const;
339
340   virtual bool isProfitableToDupForIfCvt(MachineBasicBlock &MBB,
341                                          unsigned NumInstrs) const {
342     return NumInstrs && NumInstrs == 1;
343   }
344 };
345
346 static inline
347 const MachineInstrBuilder &AddDefaultPred(const MachineInstrBuilder &MIB) {
348   return MIB.addImm((int64_t)ARMCC::AL).addReg(0);
349 }
350
351 static inline
352 const MachineInstrBuilder &AddDefaultCC(const MachineInstrBuilder &MIB) {
353   return MIB.addReg(0);
354 }
355
356 static inline
357 const MachineInstrBuilder &AddDefaultT1CC(const MachineInstrBuilder &MIB,
358                                           bool isDead = false) {
359   return MIB.addReg(ARM::CPSR, getDefRegState(true) | getDeadRegState(isDead));
360 }
361
362 static inline
363 const MachineInstrBuilder &AddNoT1CC(const MachineInstrBuilder &MIB) {
364   return MIB.addReg(0);
365 }
366
367 static inline
368 bool isUncondBranchOpcode(int Opc) {
369   return Opc == ARM::B || Opc == ARM::tB || Opc == ARM::t2B;
370 }
371
372 static inline
373 bool isCondBranchOpcode(int Opc) {
374   return Opc == ARM::Bcc || Opc == ARM::tBcc || Opc == ARM::t2Bcc;
375 }
376
377 static inline
378 bool isJumpTableBranchOpcode(int Opc) {
379   return Opc == ARM::BR_JTr || Opc == ARM::BR_JTm || Opc == ARM::BR_JTadd ||
380     Opc == ARM::tBR_JTr || Opc == ARM::t2BR_JT;
381 }
382
383 static inline
384 bool isIndirectBranchOpcode(int Opc) {
385   return Opc == ARM::BRIND || Opc == ARM::MOVPCRX || Opc == ARM::tBRIND;
386 }
387
388 /// getInstrPredicate - If instruction is predicated, returns its predicate
389 /// condition, otherwise returns AL. It also returns the condition code
390 /// register by reference.
391 ARMCC::CondCodes getInstrPredicate(const MachineInstr *MI, unsigned &PredReg);
392
393 int getMatchingCondBranchOpcode(int Opc);
394
395 /// emitARMRegPlusImmediate / emitT2RegPlusImmediate - Emits a series of
396 /// instructions to materializea destreg = basereg + immediate in ARM / Thumb2
397 /// code.
398 void emitARMRegPlusImmediate(MachineBasicBlock &MBB,
399                              MachineBasicBlock::iterator &MBBI, DebugLoc dl,
400                              unsigned DestReg, unsigned BaseReg, int NumBytes,
401                              ARMCC::CondCodes Pred, unsigned PredReg,
402                              const ARMBaseInstrInfo &TII);
403
404 void emitT2RegPlusImmediate(MachineBasicBlock &MBB,
405                             MachineBasicBlock::iterator &MBBI, DebugLoc dl,
406                             unsigned DestReg, unsigned BaseReg, int NumBytes,
407                             ARMCC::CondCodes Pred, unsigned PredReg,
408                             const ARMBaseInstrInfo &TII);
409
410
411 /// rewriteARMFrameIndex / rewriteT2FrameIndex -
412 /// Rewrite MI to access 'Offset' bytes from the FP. Return false if the
413 /// offset could not be handled directly in MI, and return the left-over
414 /// portion by reference.
415 bool rewriteARMFrameIndex(MachineInstr &MI, unsigned FrameRegIdx,
416                           unsigned FrameReg, int &Offset,
417                           const ARMBaseInstrInfo &TII);
418
419 bool rewriteT2FrameIndex(MachineInstr &MI, unsigned FrameRegIdx,
420                          unsigned FrameReg, int &Offset,
421                          const ARMBaseInstrInfo &TII);
422
423 } // End llvm namespace
424
425 #endif