1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
|
//===- ARMInstrInfo.h - ARM Instruction Information -------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by the "Instituto Nokia de Tecnologia" and
// is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the ARM implementation of the TargetInstrInfo class.
//
//===----------------------------------------------------------------------===//
#ifndef ARMINSTRUCTIONINFO_H
#define ARMINSTRUCTIONINFO_H
#include "llvm/Target/TargetInstrInfo.h"
#include "ARMRegisterInfo.h"
namespace llvm {
class ARMSubtarget;
/// ARMII - This namespace holds all of the target specific flags that
/// instruction info tracks.
///
namespace ARMII {
enum {
//===------------------------------------------------------------------===//
// Instruction Flags.
//===------------------------------------------------------------------===//
// This three-bit field describes the addressing mode used. Zero is unused
// so that we can tell if we forgot to set a value.
AddrModeMask = 0xf,
AddrModeNone = 0,
AddrMode1 = 1,
AddrMode2 = 2,
AddrMode3 = 3,
AddrMode4 = 4,
AddrMode5 = 5,
AddrModeT1 = 6,
AddrModeT2 = 7,
AddrModeT4 = 8,
AddrModeTs = 9, // i8 * 4 for pc and sp relative data
// Size* - Flags to keep track of the size of an instruction.
SizeShift = 4,
SizeMask = 7 << SizeShift,
SizeSpecial = 1, // 0 byte pseudo or special case.
Size8Bytes = 2,
Size4Bytes = 3,
Size2Bytes = 4,
// IndexMode - Unindex, pre-indexed, or post-indexed. Only valid for load
// and store ops
IndexModeShift = 7,
IndexModeMask = 3 << IndexModeShift,
IndexModePre = 1,
IndexModePost = 2,
// Opcode
OpcodeShift = 9,
OpcodeMask = 0xf << OpcodeShift,
// Format
FormShift = 13,
FormMask = 31 << FormShift,
// Pseudo instructions
Pseudo = 1 << FormShift,
// Multiply instructions
MulFrm = 2 << FormShift,
MulSMLAW = 3 << FormShift,
MulSMULW = 4 << FormShift,
MulSMLA = 5 << FormShift,
MulSMUL = 6 << FormShift,
// Branch instructions
Branch = 7 << FormShift,
BranchMisc = 8 << FormShift,
// Data Processing instructions
DPRdIm = 9 << FormShift,
DPRdReg = 10 << FormShift,
DPRdSoReg = 11 << FormShift,
DPRdMisc = 12 << FormShift,
DPRnIm = 13 << FormShift,
DPRnReg = 14 << FormShift,
DPRnSoReg = 15 << FormShift,
DPRIm = 16 << FormShift,
DPRReg = 17 << FormShift,
DPRSoReg = 18 << FormShift,
DPRImS = 19 << FormShift,
DPRRegS = 20 << FormShift,
DPRSoRegS = 21 << FormShift,
// Load and Store
LdFrm = 22 << FormShift,
StFrm = 23 << FormShift,
// Miscellaneous arithmetic instructions
ArithMisc = 24 << FormShift,
// Thumb format
ThumbFrm = 25 << FormShift,
// VFP format
VPFFrm = 26 << FormShift,
// Field shifts - such shifts are used to set field while generating
// machine instructions.
RegRsShift = 8,
RegRdShift = 12,
RegRnShift = 16,
L_BitShift = 20,
S_BitShift = 20,
U_BitShift = 23,
IndexShift = 24,
I_BitShift = 25
};
}
class ARMInstrInfo : public TargetInstrInfo {
const ARMRegisterInfo RI;
public:
ARMInstrInfo(const ARMSubtarget &STI);
/// getRegisterInfo - TargetInstrInfo is a superset of MRegister info. As
/// such, whenever a client has an instance of instruction info, it should
/// always be able to get register info as well (through this method).
///
virtual const MRegisterInfo &getRegisterInfo() const { return RI; }
/// getPointerRegClass - Return the register class to use to hold pointers.
/// This is used for addressing modes.
virtual const TargetRegisterClass *getPointerRegClass() const;
/// Return true if the instruction is a register to register move and
/// leave the source and dest operands in the passed parameters.
///
virtual bool isMoveInstr(const MachineInstr &MI,
unsigned &SrcReg, unsigned &DstReg) const;
virtual unsigned isLoadFromStackSlot(MachineInstr *MI, int &FrameIndex) const;
virtual unsigned isStoreToStackSlot(MachineInstr *MI, int &FrameIndex) const;
virtual MachineInstr *convertToThreeAddress(MachineFunction::iterator &MFI,
MachineBasicBlock::iterator &MBBI,
LiveVariables &LV) const;
// Branch analysis.
virtual bool AnalyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
MachineBasicBlock *&FBB,
std::vector<MachineOperand> &Cond) const;
virtual unsigned RemoveBranch(MachineBasicBlock &MBB) const;
virtual unsigned InsertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
MachineBasicBlock *FBB,
const std::vector<MachineOperand> &Cond) const;
virtual bool BlockHasNoFallThrough(MachineBasicBlock &MBB) const;
virtual bool ReverseBranchCondition(std::vector<MachineOperand> &Cond) const;
// Predication support.
virtual bool isPredicated(const MachineInstr *MI) const;
virtual
bool PredicateInstruction(MachineInstr *MI,
const std::vector<MachineOperand> &Pred) const;
virtual
bool SubsumesPredicate(const std::vector<MachineOperand> &Pred1,
const std::vector<MachineOperand> &Pred2) const;
virtual bool DefinesPredicate(MachineInstr *MI,
std::vector<MachineOperand> &Pred) const;
};
// Utility routines
namespace ARM {
/// GetInstSize - Returns the size of the specified MachineInstr.
///
unsigned GetInstSize(MachineInstr *MI);
/// GetFunctionSize - Returns the size of the specified MachineFunction.
///
unsigned GetFunctionSize(MachineFunction &MF);
}
}
#endif
|
