Blame - src/compiler/codegen/arm/Assemble.cc - platform/art

2011-08-17 17:51:35 -0700

[diff] [blame]

/*

*

* Licensed under the Apache License, Version 2.0 (the "License");

5

* you may not use this file except in compliance with the License.

6

* You may obtain a copy of the License at

7

*

8

* http://www.apache.org/licenses/LICENSE-2.0

9

*

10

* Unless required by applicable law or agreed to in writing, software

11

* distributed under the License is distributed on an "AS IS" BASIS,

12

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

13

* See the License for the specific language governing permissions and

14

* limitations under the License.

15

*/

16

17

#include "../../Dalvik.h"

18

#include "../../CompilerInternals.h"

19

#include "ArmLIR.h"

20

#include "Codegen.h"

21

#include <sys/mman.h> /* for protection change */

22

Elliott Hughes

11d1b0c

2012-01-23 16:57:47 -0800

[diff] [blame]

23

namespace art {

24

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

25

#define MAX_ASSEMBLER_RETRIES 50

26

27

/*

28

* opcode: ArmOpcode enum

29

* skeleton: pre-designated bit-pattern for this opcode

30

* k0: key to applying ds/de

31

* ds: dest start bit position

32

* de: dest end bit position

33

* k1: key to applying s1s/s1e

34

* s1s: src1 start bit position

35

* s1e: src1 end bit position

36

* k2: key to applying s2s/s2e

37

* s2s: src2 start bit position

38

* s2e: src2 end bit position

39

* operands: number of operands (for sanity check purposes)

40

* name: mnemonic name

41

* fmt: for pretty-printing

42

*/

43

#define ENCODING_MAP(opcode, skeleton, k0, ds, de, k1, s1s, s1e, k2, s2s, s2e, \

44

k3, k3s, k3e, flags, name, fmt, size) \

45

{skeleton, {{k0, ds, de}, {k1, s1s, s1e}, {k2, s2s, s2e}, \

46

{k3, k3s, k3e}}, opcode, flags, name, fmt, size}

47

48

/* Instruction dump string format keys: !pf, where "!" is the start

49

* of the key, "p" is which numeric operand to use and "f" is the

* print format.

*

* [p]ositions:

* 0 -> operands[0] (dest)

54

* 1 -> operands[1] (src1)

55

* 2 -> operands[2] (src2)

56

* 3 -> operands[3] (extra)

*

* [f]ormats:

* h -> 4-digit hex

* d -> decimal

* E -> decimal*4

* F -> decimal*2

* c -> branch condition (beq, bne, etc.)

64

* t -> pc-relative target

65

* u -> 1st half of bl[x] target

66

* v -> 2nd half ob bl[x] target

67

* R -> register list

68

* s -> single precision floating point register

69

* S -> double precision floating point register

70

* m -> Thumb2 modified immediate

71

* n -> complimented Thumb2 modified immediate

72

* M -> Thumb2 16-bit zero-extended immediate

73

* b -> 4-digit binary

74

* B -> dmb option string (sy, st, ish, ishst, nsh, hshst)

75

* H -> operand shift

76

* C -> core register name

77

* P -> fp cs register list (base of s16)

78

* Q -> fp cs register list (base of s0)

79

*

80

* [!] escape. To insert "!", use "!!"

81

*/

82

/* NOTE: must be kept in sync with enum ArmOpcode from ArmLIR.h */

83

ArmEncodingMap EncodingMap[kArmLast] = {

84

ENCODING_MAP(kArm16BitData, 0x0000,

85

kFmtBitBlt, 15, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,

86

kFmtUnused, -1, -1, IS_UNARY_OP, "data", "0x!0h(!0d)", 1),

87

ENCODING_MAP(kThumbAdcRR, 0x4140,

88

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,

89

kFmtUnused, -1, -1,

90

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES | USES_CCODES,

91

"adcs", "!0C, !1C", 1),

92

ENCODING_MAP(kThumbAddRRI3, 0x1c00,

93

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 8, 6,

94

kFmtUnused, -1, -1,

95

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

96

"adds", "!0C, !1C, #!2d", 1),

97

ENCODING_MAP(kThumbAddRI8, 0x3000,

98

kFmtBitBlt, 10, 8, kFmtBitBlt, 7, 0, kFmtUnused, -1, -1,

99

kFmtUnused, -1, -1,

100

IS_BINARY_OP | REG_DEF0_USE0 | SETS_CCODES,

101

"adds", "!0C, !0C, #!1d", 1),

102

ENCODING_MAP(kThumbAddRRR, 0x1800,

103

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 8, 6,

104

kFmtUnused, -1, -1,

105

IS_TERTIARY_OP | REG_DEF0_USE12 | SETS_CCODES,

106

"adds", "!0C, !1C, !2C", 1),

107

ENCODING_MAP(kThumbAddRRLH, 0x4440,

108

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,

109

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE01,

110

"add", "!0C, !1C", 1),

111

ENCODING_MAP(kThumbAddRRHL, 0x4480,

112

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,

113

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE01,

114

"add", "!0C, !1C", 1),

115

ENCODING_MAP(kThumbAddRRHH, 0x44c0,

116

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,

117

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE01,

118

"add", "!0C, !1C", 1),

119

ENCODING_MAP(kThumbAddPcRel, 0xa000,

120

kFmtBitBlt, 10, 8, kFmtBitBlt, 7, 0, kFmtUnused, -1, -1,

buzbee

2012-01-31 17:01:43 -0800

[diff] [blame]

121

kFmtUnused, -1, -1, IS_TERTIARY_OP | IS_BRANCH | NEEDS_FIXUP,

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

122

"add", "!0C, pc, #!1E", 1),

123

ENCODING_MAP(kThumbAddSpRel, 0xa800,

124

kFmtBitBlt, 10, 8, kFmtUnused, -1, -1, kFmtBitBlt, 7, 0,

125

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF_SP | REG_USE_SP,

126

"add", "!0C, sp, #!2E", 1),

127

ENCODING_MAP(kThumbAddSpI7, 0xb000,

128

kFmtBitBlt, 6, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,

129

kFmtUnused, -1, -1, IS_UNARY_OP | REG_DEF_SP | REG_USE_SP,

130

"add", "sp, #!0d*4", 1),

131

ENCODING_MAP(kThumbAndRR, 0x4000,

132

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,

133

kFmtUnused, -1, -1,

134

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,

135

"ands", "!0C, !1C", 1),

136

ENCODING_MAP(kThumbAsrRRI5, 0x1000,

137

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 10, 6,

138

kFmtUnused, -1, -1,

139

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

140

"asrs", "!0C, !1C, #!2d", 1),

141

ENCODING_MAP(kThumbAsrRR, 0x4100,

142

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,

143

kFmtUnused, -1, -1,

144

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,

145

"asrs", "!0C, !1C", 1),

146

ENCODING_MAP(kThumbBCond, 0xd000,

147

kFmtBitBlt, 7, 0, kFmtBitBlt, 11, 8, kFmtUnused, -1, -1,

buzbee

2012-01-31 17:01:43 -0800

[diff] [blame]

148

kFmtUnused, -1, -1, IS_BINARY_OP | IS_BRANCH | USES_CCODES |

149

NEEDS_FIXUP, "b!1c", "!0t", 1),

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

150

ENCODING_MAP(kThumbBUncond, 0xe000,

151

kFmtBitBlt, 10, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,

buzbee

2012-01-31 17:01:43 -0800

[diff] [blame]

152

kFmtUnused, -1, -1, NO_OPERAND | IS_BRANCH | NEEDS_FIXUP,

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

153

"b", "!0t", 1),

154

ENCODING_MAP(kThumbBicRR, 0x4380,

155

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,

156

kFmtUnused, -1, -1,

157

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,

158

"bics", "!0C, !1C", 1),

159

ENCODING_MAP(kThumbBkpt, 0xbe00,

160

kFmtBitBlt, 7, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,

161

kFmtUnused, -1, -1, IS_UNARY_OP | IS_BRANCH,

162

"bkpt", "!0d", 1),

163

ENCODING_MAP(kThumbBlx1, 0xf000,

164

kFmtBitBlt, 10, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,

buzbee

2012-01-31 17:01:43 -0800

[diff] [blame]

165

kFmtUnused, -1, -1, IS_BINARY_OP | IS_BRANCH | REG_DEF_LR |

166

NEEDS_FIXUP, "blx_1", "!0u", 1),

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

167

ENCODING_MAP(kThumbBlx2, 0xe800,

168

kFmtBitBlt, 10, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,

buzbee

2012-01-31 17:01:43 -0800

[diff] [blame]

169

kFmtUnused, -1, -1, IS_BINARY_OP | IS_BRANCH | REG_DEF_LR |

170

NEEDS_FIXUP, "blx_2", "!0v", 1),

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

171

ENCODING_MAP(kThumbBl1, 0xf000,

172

kFmtBitBlt, 10, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,

173

kFmtUnused, -1, -1, IS_UNARY_OP | IS_BRANCH | REG_DEF_LR,

174

"bl_1", "!0u", 1),

175

ENCODING_MAP(kThumbBl2, 0xf800,

176

kFmtBitBlt, 10, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,

177

kFmtUnused, -1, -1, IS_UNARY_OP | IS_BRANCH | REG_DEF_LR,

178

"bl_2", "!0v", 1),

179

ENCODING_MAP(kThumbBlxR, 0x4780,

180

kFmtBitBlt, 6, 3, kFmtUnused, -1, -1, kFmtUnused, -1, -1,

181

kFmtUnused, -1, -1,

182

IS_UNARY_OP | REG_USE0 | IS_BRANCH | REG_DEF_LR,

183

"blx", "!0C", 1),

184

ENCODING_MAP(kThumbBx, 0x4700,

185

kFmtBitBlt, 6, 3, kFmtUnused, -1, -1, kFmtUnused, -1, -1,

186

kFmtUnused, -1, -1, IS_UNARY_OP | IS_BRANCH,

187

"bx", "!0C", 1),

188

ENCODING_MAP(kThumbCmnRR, 0x42c0,

189

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,

190

kFmtUnused, -1, -1, IS_BINARY_OP | REG_USE01 | SETS_CCODES,

191

"cmn", "!0C, !1C", 1),

192

ENCODING_MAP(kThumbCmpRI8, 0x2800,

193

kFmtBitBlt, 10, 8, kFmtBitBlt, 7, 0, kFmtUnused, -1, -1,

194

kFmtUnused, -1, -1, IS_BINARY_OP | REG_USE0 | SETS_CCODES,

195

"cmp", "!0C, #!1d", 1),

196

ENCODING_MAP(kThumbCmpRR, 0x4280,

197

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,

198

kFmtUnused, -1, -1, IS_BINARY_OP | REG_USE01 | SETS_CCODES,

199

"cmp", "!0C, !1C", 1),

200

ENCODING_MAP(kThumbCmpLH, 0x4540,

201

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,

202

kFmtUnused, -1, -1, IS_BINARY_OP | REG_USE01 | SETS_CCODES,

203

"cmp", "!0C, !1C", 1),

204

ENCODING_MAP(kThumbCmpHL, 0x4580,

205

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,

206

kFmtUnused, -1, -1, IS_BINARY_OP | REG_USE01 | SETS_CCODES,

207

"cmp", "!0C, !1C", 1),

208

ENCODING_MAP(kThumbCmpHH, 0x45c0,

209

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,

210

kFmtUnused, -1, -1, IS_BINARY_OP | REG_USE01 | SETS_CCODES,

211

"cmp", "!0C, !1C", 1),

212

ENCODING_MAP(kThumbEorRR, 0x4040,

213

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,

214

kFmtUnused, -1, -1,

215

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,

216

"eors", "!0C, !1C", 1),

217

ENCODING_MAP(kThumbLdmia, 0xc800,

218

kFmtBitBlt, 10, 8, kFmtBitBlt, 7, 0, kFmtUnused, -1, -1,

219

kFmtUnused, -1, -1,

220

IS_BINARY_OP | REG_DEF0_USE0 | REG_DEF_LIST1 | IS_LOAD,

221

"ldmia", "!0C!!, <!1R>", 1),

222

ENCODING_MAP(kThumbLdrRRI5, 0x6800,

223

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 10, 6,

224

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1 | IS_LOAD,

225

"ldr", "!0C, [!1C, #!2E]", 1),

226

ENCODING_MAP(kThumbLdrRRR, 0x5800,

227

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 8, 6,

228

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12 | IS_LOAD,

229

"ldr", "!0C, [!1C, !2C]", 1),

230

ENCODING_MAP(kThumbLdrPcRel, 0x4800,

231

kFmtBitBlt, 10, 8, kFmtBitBlt, 7, 0, kFmtUnused, -1, -1,

232

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0 | REG_USE_PC

buzbee

2012-01-31 17:01:43 -0800

[diff] [blame]

233

| IS_LOAD | NEEDS_FIXUP, "ldr", "!0C, [pc, #!1E]", 1),

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

234

ENCODING_MAP(kThumbLdrSpRel, 0x9800,

235

kFmtBitBlt, 10, 8, kFmtUnused, -1, -1, kFmtBitBlt, 7, 0,

236

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0 | REG_USE_SP

237

| IS_LOAD, "ldr", "!0C, [sp, #!2E]", 1),

238

ENCODING_MAP(kThumbLdrbRRI5, 0x7800,

239

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 10, 6,

240

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1 | IS_LOAD,

241

"ldrb", "!0C, [!1C, #2d]", 1),

242

ENCODING_MAP(kThumbLdrbRRR, 0x5c00,

243

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 8, 6,

244

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12 | IS_LOAD,

245

"ldrb", "!0C, [!1C, !2C]", 1),

246

ENCODING_MAP(kThumbLdrhRRI5, 0x8800,

247

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 10, 6,

248

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1 | IS_LOAD,

249

"ldrh", "!0C, [!1C, #!2F]", 1),

250

ENCODING_MAP(kThumbLdrhRRR, 0x5a00,

251

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 8, 6,

252

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12 | IS_LOAD,

253

"ldrh", "!0C, [!1C, !2C]", 1),

254

ENCODING_MAP(kThumbLdrsbRRR, 0x5600,

255

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 8, 6,

256

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12 | IS_LOAD,

257

"ldrsb", "!0C, [!1C, !2C]", 1),

258

ENCODING_MAP(kThumbLdrshRRR, 0x5e00,

259

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 8, 6,

260

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12 | IS_LOAD,

261

"ldrsh", "!0C, [!1C, !2C]", 1),

262

ENCODING_MAP(kThumbLslRRI5, 0x0000,

263

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 10, 6,

264

kFmtUnused, -1, -1,

265

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

266

"lsls", "!0C, !1C, #!2d", 1),

267

ENCODING_MAP(kThumbLslRR, 0x4080,

268

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,

269

kFmtUnused, -1, -1,

270

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,

271

"lsls", "!0C, !1C", 1),

272

ENCODING_MAP(kThumbLsrRRI5, 0x0800,

273

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 10, 6,

274

kFmtUnused, -1, -1,

275

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

276

"lsrs", "!0C, !1C, #!2d", 1),

277

ENCODING_MAP(kThumbLsrRR, 0x40c0,

278

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,

279

kFmtUnused, -1, -1,

280

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,

281

"lsrs", "!0C, !1C", 1),

282

ENCODING_MAP(kThumbMovImm, 0x2000,

283

kFmtBitBlt, 10, 8, kFmtBitBlt, 7, 0, kFmtUnused, -1, -1,

284

kFmtUnused, -1, -1,

285

IS_BINARY_OP | REG_DEF0 | SETS_CCODES,

286

"movs", "!0C, #!1d", 1),

287

ENCODING_MAP(kThumbMovRR, 0x1c00,

288

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,

289

kFmtUnused, -1, -1,

290

IS_BINARY_OP | REG_DEF0_USE1 | SETS_CCODES,

291

"movs", "!0C, !1C", 1),

292

ENCODING_MAP(kThumbMovRR_H2H, 0x46c0,

293

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,

294

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,

295

"mov", "!0C, !1C", 1),

296

ENCODING_MAP(kThumbMovRR_H2L, 0x4640,

297

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,

298

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,

299

"mov", "!0C, !1C", 1),

300

ENCODING_MAP(kThumbMovRR_L2H, 0x4680,

301

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,

302

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,

303

"mov", "!0C, !1C", 1),

304

ENCODING_MAP(kThumbMul, 0x4340,

305

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,

306

kFmtUnused, -1, -1,

307

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,

308

"muls", "!0C, !1C", 1),

309

ENCODING_MAP(kThumbMvn, 0x43c0,

310

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,

311

kFmtUnused, -1, -1,

312

IS_BINARY_OP | REG_DEF0_USE1 | SETS_CCODES,

313

"mvns", "!0C, !1C", 1),

314

ENCODING_MAP(kThumbNeg, 0x4240,

315

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,

316

kFmtUnused, -1, -1,

317

IS_BINARY_OP | REG_DEF0_USE1 | SETS_CCODES,

318

"negs", "!0C, !1C", 1),

319

ENCODING_MAP(kThumbOrr, 0x4300,

320

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,

321

kFmtUnused, -1, -1,

322

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,

323

"orrs", "!0C, !1C", 1),

324

ENCODING_MAP(kThumbPop, 0xbc00,

325

kFmtBitBlt, 8, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,

326

kFmtUnused, -1, -1,

327

IS_UNARY_OP | REG_DEF_SP | REG_USE_SP | REG_DEF_LIST0

328

| IS_LOAD, "pop", "<!0R>", 1),

329

ENCODING_MAP(kThumbPush, 0xb400,

330

kFmtBitBlt, 8, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,

331

kFmtUnused, -1, -1,

332

IS_UNARY_OP | REG_DEF_SP | REG_USE_SP | REG_USE_LIST0

333

| IS_STORE, "push", "<!0R>", 1),

334

ENCODING_MAP(kThumbRorRR, 0x41c0,

335

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,

336

kFmtUnused, -1, -1,

337

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,

338

"rors", "!0C, !1C", 1),

339

ENCODING_MAP(kThumbSbc, 0x4180,

340

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,

341

kFmtUnused, -1, -1,

342

IS_BINARY_OP | REG_DEF0_USE01 | USES_CCODES | SETS_CCODES,

343

"sbcs", "!0C, !1C", 1),

344

ENCODING_MAP(kThumbStmia, 0xc000,

345

kFmtBitBlt, 10, 8, kFmtBitBlt, 7, 0, kFmtUnused, -1, -1,

346

kFmtUnused, -1, -1,

347

IS_BINARY_OP | REG_DEF0 | REG_USE0 | REG_USE_LIST1 | IS_STORE,

348

"stmia", "!0C!!, <!1R>", 1),

349

ENCODING_MAP(kThumbStrRRI5, 0x6000,

350

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 10, 6,

351

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_USE01 | IS_STORE,

352

"str", "!0C, [!1C, #!2E]", 1),

353

ENCODING_MAP(kThumbStrRRR, 0x5000,

354

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 8, 6,

355

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_USE012 | IS_STORE,

356

"str", "!0C, [!1C, !2C]", 1),

357

ENCODING_MAP(kThumbStrSpRel, 0x9000,

358

kFmtBitBlt, 10, 8, kFmtUnused, -1, -1, kFmtBitBlt, 7, 0,

359

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_USE0 | REG_USE_SP

360

| IS_STORE, "str", "!0C, [sp, #!2E]", 1),

361

ENCODING_MAP(kThumbStrbRRI5, 0x7000,

362

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 10, 6,

363

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_USE01 | IS_STORE,

364

"strb", "!0C, [!1C, #!2d]", 1),

365

ENCODING_MAP(kThumbStrbRRR, 0x5400,

366

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 8, 6,

367

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_USE012 | IS_STORE,

368

"strb", "!0C, [!1C, !2C]", 1),

369

ENCODING_MAP(kThumbStrhRRI5, 0x8000,

370

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 10, 6,

371

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_USE01 | IS_STORE,

372

"strh", "!0C, [!1C, #!2F]", 1),

373

ENCODING_MAP(kThumbStrhRRR, 0x5200,

374

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 8, 6,

375

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_USE012 | IS_STORE,

376

"strh", "!0C, [!1C, !2C]", 1),

377

ENCODING_MAP(kThumbSubRRI3, 0x1e00,

378

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 8, 6,

379

kFmtUnused, -1, -1,

380

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

381

"subs", "!0C, !1C, #!2d", 1),

382

ENCODING_MAP(kThumbSubRI8, 0x3800,

383

kFmtBitBlt, 10, 8, kFmtBitBlt, 7, 0, kFmtUnused, -1, -1,

384

kFmtUnused, -1, -1,

385

IS_BINARY_OP | REG_DEF0_USE0 | SETS_CCODES,

386

"subs", "!0C, #!1d", 1),

387

ENCODING_MAP(kThumbSubRRR, 0x1a00,

388

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 8, 6,

389

kFmtUnused, -1, -1,

390

IS_TERTIARY_OP | REG_DEF0_USE12 | SETS_CCODES,

391

"subs", "!0C, !1C, !2C", 1),

392

ENCODING_MAP(kThumbSubSpI7, 0xb080,

393

kFmtBitBlt, 6, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,

394

kFmtUnused, -1, -1,

395

IS_UNARY_OP | REG_DEF_SP | REG_USE_SP,

396

"sub", "sp, #!0d*4", 1),

397

ENCODING_MAP(kThumbSwi, 0xdf00,

Ian Rogers

408f79a

2011-08-23 18:22:33 -0700

[diff] [blame]

398

kFmtBitBlt, 7, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,

399

kFmtUnused, -1, -1, IS_UNARY_OP | IS_BRANCH,

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

400

"swi", "!0d", 1),

401

ENCODING_MAP(kThumbTst, 0x4200,

402

kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,

403

kFmtUnused, -1, -1, IS_UNARY_OP | REG_USE01 | SETS_CCODES,

404

"tst", "!0C, !1C", 1),

405

ENCODING_MAP(kThumb2Vldrs, 0xed900a00,

406

kFmtSfp, 22, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 7, 0,

buzbee

2011-11-28 16:06:57 -0800

[diff] [blame]

407

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1 | IS_LOAD |

buzbee

2012-01-31 17:01:43 -0800

[diff] [blame]

408

REG_DEF_LR | NEEDS_FIXUP, "vldr", "!0s, [!1C, #!2E]", 2),

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

409

ENCODING_MAP(kThumb2Vldrd, 0xed900b00,

410

kFmtDfp, 22, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 7, 0,

buzbee

2011-11-28 16:06:57 -0800

[diff] [blame]

411

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1 | IS_LOAD |

buzbee

2012-01-31 17:01:43 -0800

[diff] [blame]

412

REG_DEF_LR | NEEDS_FIXUP, "vldr", "!0S, [!1C, #!2E]", 2),

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

413

ENCODING_MAP(kThumb2Vmuls, 0xee200a00,

414

kFmtSfp, 22, 12, kFmtSfp, 7, 16, kFmtSfp, 5, 0,

415

kFmtUnused, -1, -1,

416

IS_TERTIARY_OP | REG_DEF0_USE12,

417

"vmuls", "!0s, !1s, !2s", 2),

418

ENCODING_MAP(kThumb2Vmuld, 0xee200b00,

419

kFmtDfp, 22, 12, kFmtDfp, 7, 16, kFmtDfp, 5, 0,

420

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,

421

"vmuld", "!0S, !1S, !2S", 2),

422

ENCODING_MAP(kThumb2Vstrs, 0xed800a00,

423

kFmtSfp, 22, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 7, 0,

424

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_USE01 | IS_STORE,

425

"vstr", "!0s, [!1C, #!2E]", 2),

426

ENCODING_MAP(kThumb2Vstrd, 0xed800b00,

427

kFmtDfp, 22, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 7, 0,

428

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_USE01 | IS_STORE,

429

"vstr", "!0S, [!1C, #!2E]", 2),

430

ENCODING_MAP(kThumb2Vsubs, 0xee300a40,

431

kFmtSfp, 22, 12, kFmtSfp, 7, 16, kFmtSfp, 5, 0,

432

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,

433

"vsub", "!0s, !1s, !2s", 2),

434

ENCODING_MAP(kThumb2Vsubd, 0xee300b40,

435

kFmtDfp, 22, 12, kFmtDfp, 7, 16, kFmtDfp, 5, 0,

436

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,

437

"vsub", "!0S, !1S, !2S", 2),

438

ENCODING_MAP(kThumb2Vadds, 0xee300a00,

439

kFmtSfp, 22, 12, kFmtSfp, 7, 16, kFmtSfp, 5, 0,

440

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,

441

"vadd", "!0s, !1s, !2s", 2),

442

ENCODING_MAP(kThumb2Vaddd, 0xee300b00,

443

kFmtDfp, 22, 12, kFmtDfp, 7, 16, kFmtDfp, 5, 0,

444

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,

445

"vadd", "!0S, !1S, !2S", 2),

446

ENCODING_MAP(kThumb2Vdivs, 0xee800a00,

447

kFmtSfp, 22, 12, kFmtSfp, 7, 16, kFmtSfp, 5, 0,

448

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,

449

"vdivs", "!0s, !1s, !2s", 2),

450

ENCODING_MAP(kThumb2Vdivd, 0xee800b00,

451

kFmtDfp, 22, 12, kFmtDfp, 7, 16, kFmtDfp, 5, 0,

452

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,

453

"vdivd", "!0S, !1S, !2S", 2),

454

ENCODING_MAP(kThumb2VcvtIF, 0xeeb80ac0,

455

kFmtSfp, 22, 12, kFmtSfp, 5, 0, kFmtUnused, -1, -1,

456

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,

457

"vcvt.f32", "!0s, !1s", 2),

458

ENCODING_MAP(kThumb2VcvtID, 0xeeb80bc0,

459

kFmtDfp, 22, 12, kFmtSfp, 5, 0, kFmtUnused, -1, -1,

460

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,

461

"vcvt.f64", "!0S, !1s", 2),

462

ENCODING_MAP(kThumb2VcvtFI, 0xeebd0ac0,

463

kFmtSfp, 22, 12, kFmtSfp, 5, 0, kFmtUnused, -1, -1,

464

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,

465

"vcvt.s32.f32 ", "!0s, !1s", 2),

466

ENCODING_MAP(kThumb2VcvtDI, 0xeebd0bc0,

467

kFmtSfp, 22, 12, kFmtDfp, 5, 0, kFmtUnused, -1, -1,

468

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,

469

"vcvt.s32.f64 ", "!0s, !1S", 2),

470

ENCODING_MAP(kThumb2VcvtFd, 0xeeb70ac0,

471

kFmtDfp, 22, 12, kFmtSfp, 5, 0, kFmtUnused, -1, -1,

472

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,

473

"vcvt.f64.f32 ", "!0S, !1s", 2),

474

ENCODING_MAP(kThumb2VcvtDF, 0xeeb70bc0,

475

kFmtSfp, 22, 12, kFmtDfp, 5, 0, kFmtUnused, -1, -1,

476

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,

477

"vcvt.f32.f64 ", "!0s, !1S", 2),

478

ENCODING_MAP(kThumb2Vsqrts, 0xeeb10ac0,

479

kFmtSfp, 22, 12, kFmtSfp, 5, 0, kFmtUnused, -1, -1,

480

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,

481

"vsqrt.f32 ", "!0s, !1s", 2),

482

ENCODING_MAP(kThumb2Vsqrtd, 0xeeb10bc0,

483

kFmtDfp, 22, 12, kFmtDfp, 5, 0, kFmtUnused, -1, -1,

484

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,

485

"vsqrt.f64 ", "!0S, !1S", 2),

486

ENCODING_MAP(kThumb2MovImmShift, 0xf04f0000, /* no setflags encoding */

487

kFmtBitBlt, 11, 8, kFmtModImm, -1, -1, kFmtUnused, -1, -1,

488

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0,

489

"mov", "!0C, #!1m", 2),

490

ENCODING_MAP(kThumb2MovImm16, 0xf2400000,

491

kFmtBitBlt, 11, 8, kFmtImm16, -1, -1, kFmtUnused, -1, -1,

492

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0,

493

"mov", "!0C, #!1M", 2),

494

ENCODING_MAP(kThumb2StrRRI12, 0xf8c00000,

495

kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 11, 0,

496

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_USE01 | IS_STORE,

497

"str", "!0C, [!1C, #!2d]", 2),

498

ENCODING_MAP(kThumb2LdrRRI12, 0xf8d00000,

499

kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 11, 0,

500

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1 | IS_LOAD,

501

"ldr", "!0C, [!1C, #!2d]", 2),

502

ENCODING_MAP(kThumb2StrRRI8Predec, 0xf8400c00,

503

kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 8, 0,

504

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_USE01 | IS_STORE,

505

"str", "!0C, [!1C, #-!2d]", 2),

506

ENCODING_MAP(kThumb2LdrRRI8Predec, 0xf8500c00,

507

kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 8, 0,

508

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1 | IS_LOAD,

509

"ldr", "!0C, [!1C, #-!2d]", 2),

510

ENCODING_MAP(kThumb2Cbnz, 0xb900, /* Note: does not affect flags */

511

kFmtBitBlt, 2, 0, kFmtImm6, -1, -1, kFmtUnused, -1, -1,

buzbee

2012-01-31 17:01:43 -0800

[diff] [blame]

512

kFmtUnused, -1, -1, IS_BINARY_OP | REG_USE0 | IS_BRANCH |

513

NEEDS_FIXUP, "cbnz", "!0C,!1t", 1),

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

514

ENCODING_MAP(kThumb2Cbz, 0xb100, /* Note: does not affect flags */

515

kFmtBitBlt, 2, 0, kFmtImm6, -1, -1, kFmtUnused, -1, -1,

buzbee

2012-01-31 17:01:43 -0800

[diff] [blame]

516

kFmtUnused, -1, -1, IS_BINARY_OP | REG_USE0 | IS_BRANCH |

517

NEEDS_FIXUP, "cbz", "!0C,!1t", 1),

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

518

ENCODING_MAP(kThumb2AddRRI12, 0xf2000000,

519

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtImm12, -1, -1,

520

kFmtUnused, -1, -1,

521

IS_TERTIARY_OP | REG_DEF0_USE1,/* Note: doesn't affect flags */

522

"add", "!0C,!1C,#!2d", 2),

523

ENCODING_MAP(kThumb2MovRR, 0xea4f0000, /* no setflags encoding */

524

kFmtBitBlt, 11, 8, kFmtBitBlt, 3, 0, kFmtUnused, -1, -1,

525

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,

526

"mov", "!0C, !1C", 2),

527

ENCODING_MAP(kThumb2Vmovs, 0xeeb00a40,

528

kFmtSfp, 22, 12, kFmtSfp, 5, 0, kFmtUnused, -1, -1,

529

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,

530

"vmov.f32 ", " !0s, !1s", 2),

531

ENCODING_MAP(kThumb2Vmovd, 0xeeb00b40,

532

kFmtDfp, 22, 12, kFmtDfp, 5, 0, kFmtUnused, -1, -1,

533

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,

534

"vmov.f64 ", " !0S, !1S", 2),

535

ENCODING_MAP(kThumb2Ldmia, 0xe8900000,

536

kFmtBitBlt, 19, 16, kFmtBitBlt, 15, 0, kFmtUnused, -1, -1,

537

kFmtUnused, -1, -1,

538

IS_BINARY_OP | REG_DEF0_USE0 | REG_DEF_LIST1 | IS_LOAD,

539

"ldmia", "!0C!!, <!1R>", 2),

540

ENCODING_MAP(kThumb2Stmia, 0xe8800000,

541

kFmtBitBlt, 19, 16, kFmtBitBlt, 15, 0, kFmtUnused, -1, -1,

542

kFmtUnused, -1, -1,

543

IS_BINARY_OP | REG_DEF0_USE0 | REG_USE_LIST1 | IS_STORE,

544

"stmia", "!0C!!, <!1R>", 2),

545

ENCODING_MAP(kThumb2AddRRR, 0xeb100000, /* setflags encoding */

546

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,

547

kFmtShift, -1, -1,

548

IS_QUAD_OP | REG_DEF0_USE12 | SETS_CCODES,

549

"adds", "!0C, !1C, !2C!3H", 2),

550

ENCODING_MAP(kThumb2SubRRR, 0xebb00000, /* setflags enconding */

551

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,

552

kFmtShift, -1, -1,

553

IS_QUAD_OP | REG_DEF0_USE12 | SETS_CCODES,

554

"subs", "!0C, !1C, !2C!3H", 2),

555

ENCODING_MAP(kThumb2SbcRRR, 0xeb700000, /* setflags encoding */

556

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,

557

kFmtShift, -1, -1,

558

IS_QUAD_OP | REG_DEF0_USE12 | USES_CCODES | SETS_CCODES,

559

"sbcs", "!0C, !1C, !2C!3H", 2),

560

ENCODING_MAP(kThumb2CmpRR, 0xebb00f00,

561

kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0, kFmtShift, -1, -1,

562

kFmtUnused, -1, -1,

563

IS_TERTIARY_OP | REG_USE01 | SETS_CCODES,

564

"cmp", "!0C, !1C", 2),

565

ENCODING_MAP(kThumb2SubRRI12, 0xf2a00000,

566

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtImm12, -1, -1,

567

kFmtUnused, -1, -1,

568

IS_TERTIARY_OP | REG_DEF0_USE1,/* Note: doesn't affect flags */

569

"sub", "!0C,!1C,#!2d", 2),

buzbee

58f9274

2011-10-01 11:22:17 -0700

[diff] [blame]

570

ENCODING_MAP(kThumb2MvnImm12, 0xf06f0000, /* no setflags encoding */

571

kFmtBitBlt, 11, 8, kFmtImm12, -1, -1, kFmtUnused, -1, -1,

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

572

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0,

573

"mvn", "!0C, #!1n", 2),

574

ENCODING_MAP(kThumb2Sel, 0xfaa0f080,

575

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,

576

kFmtUnused, -1, -1,

577

IS_TERTIARY_OP | REG_DEF0_USE12 | USES_CCODES,

578

"sel", "!0C, !1C, !2C", 2),

579

ENCODING_MAP(kThumb2Ubfx, 0xf3c00000,

580

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtLsb, -1, -1,

581

kFmtBWidth, 4, 0, IS_QUAD_OP | REG_DEF0_USE1,

582

"ubfx", "!0C, !1C, #!2d, #!3d", 2),

583

ENCODING_MAP(kThumb2Sbfx, 0xf3400000,

584

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtLsb, -1, -1,

585

kFmtBWidth, 4, 0, IS_QUAD_OP | REG_DEF0_USE1,

586

"sbfx", "!0C, !1C, #!2d, #!3d", 2),

587

ENCODING_MAP(kThumb2LdrRRR, 0xf8500000,

588

kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,

589

kFmtBitBlt, 5, 4, IS_QUAD_OP | REG_DEF0_USE12 | IS_LOAD,

590

"ldr", "!0C, [!1C, !2C, LSL #!3d]", 2),

591

ENCODING_MAP(kThumb2LdrhRRR, 0xf8300000,

592

kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,

593

kFmtBitBlt, 5, 4, IS_QUAD_OP | REG_DEF0_USE12 | IS_LOAD,

594

"ldrh", "!0C, [!1C, !2C, LSL #!3d]", 2),

595

ENCODING_MAP(kThumb2LdrshRRR, 0xf9300000,

596

kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,

597

kFmtBitBlt, 5, 4, IS_QUAD_OP | REG_DEF0_USE12 | IS_LOAD,

598

"ldrsh", "!0C, [!1C, !2C, LSL #!3d]", 2),

599

ENCODING_MAP(kThumb2LdrbRRR, 0xf8100000,

600

kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,

601

kFmtBitBlt, 5, 4, IS_QUAD_OP | REG_DEF0_USE12 | IS_LOAD,

602

"ldrb", "!0C, [!1C, !2C, LSL #!3d]", 2),

603

ENCODING_MAP(kThumb2LdrsbRRR, 0xf9100000,

604

kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,

605

kFmtBitBlt, 5, 4, IS_QUAD_OP | REG_DEF0_USE12 | IS_LOAD,

606

"ldrsb", "!0C, [!1C, !2C, LSL #!3d]", 2),

607

ENCODING_MAP(kThumb2StrRRR, 0xf8400000,

608

kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,

609

kFmtBitBlt, 5, 4, IS_QUAD_OP | REG_USE012 | IS_STORE,

610

"str", "!0C, [!1C, !2C, LSL #!3d]", 2),

611

ENCODING_MAP(kThumb2StrhRRR, 0xf8200000,

612

kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,

613

kFmtBitBlt, 5, 4, IS_QUAD_OP | REG_USE012 | IS_STORE,

614

"strh", "!0C, [!1C, !2C, LSL #!3d]", 2),

615

ENCODING_MAP(kThumb2StrbRRR, 0xf8000000,

616

kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,

617

kFmtBitBlt, 5, 4, IS_QUAD_OP | REG_USE012 | IS_STORE,

618

"strb", "!0C, [!1C, !2C, LSL #!3d]", 2),

619

ENCODING_MAP(kThumb2LdrhRRI12, 0xf8b00000,

620

kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 11, 0,

621

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1 | IS_LOAD,

622

"ldrh", "!0C, [!1C, #!2d]", 2),

623

ENCODING_MAP(kThumb2LdrshRRI12, 0xf9b00000,

624

kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 11, 0,

625

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1 | IS_LOAD,

626

"ldrsh", "!0C, [!1C, #!2d]", 2),

627

ENCODING_MAP(kThumb2LdrbRRI12, 0xf8900000,

628

kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 11, 0,

629

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1 | IS_LOAD,

630

"ldrb", "!0C, [!1C, #!2d]", 2),

631

ENCODING_MAP(kThumb2LdrsbRRI12, 0xf9900000,

632

kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 11, 0,

633

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1 | IS_LOAD,

634

"ldrsb", "!0C, [!1C, #!2d]", 2),

635

ENCODING_MAP(kThumb2StrhRRI12, 0xf8a00000,

636

kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 11, 0,

637

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_USE01 | IS_STORE,

638

"strh", "!0C, [!1C, #!2d]", 2),

639

ENCODING_MAP(kThumb2StrbRRI12, 0xf8800000,

640

kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 11, 0,

641

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_USE01 | IS_STORE,

642

"strb", "!0C, [!1C, #!2d]", 2),

643

ENCODING_MAP(kThumb2Pop, 0xe8bd0000,

644

kFmtBitBlt, 15, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,

645

kFmtUnused, -1, -1,

646

IS_UNARY_OP | REG_DEF_SP | REG_USE_SP | REG_DEF_LIST0

buzbee

2012-01-31 17:01:43 -0800

[diff] [blame]

647

| IS_LOAD | NEEDS_FIXUP, "pop", "<!0R>", 2),

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

648

ENCODING_MAP(kThumb2Push, 0xe92d0000,

649

kFmtBitBlt, 15, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,

650

kFmtUnused, -1, -1,

651

IS_UNARY_OP | REG_DEF_SP | REG_USE_SP | REG_USE_LIST0

buzbee

2012-01-31 17:01:43 -0800

[diff] [blame]

652

| IS_STORE | NEEDS_FIXUP, "push", "<!0R>", 2),

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

653

ENCODING_MAP(kThumb2CmpRI8, 0xf1b00f00,

654

kFmtBitBlt, 19, 16, kFmtModImm, -1, -1, kFmtUnused, -1, -1,

655

kFmtUnused, -1, -1,

656

IS_BINARY_OP | REG_USE0 | SETS_CCODES,

657

"cmp", "!0C, #!1m", 2),

658

ENCODING_MAP(kThumb2AdcRRR, 0xeb500000, /* setflags encoding */

659

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,

660

kFmtShift, -1, -1,

661

IS_QUAD_OP | REG_DEF0_USE12 | SETS_CCODES,

662

"adcs", "!0C, !1C, !2C!3H", 2),

663

ENCODING_MAP(kThumb2AndRRR, 0xea000000,

664

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,

665

kFmtShift, -1, -1, IS_QUAD_OP | REG_DEF0_USE12,

666

"and", "!0C, !1C, !2C!3H", 2),

667

ENCODING_MAP(kThumb2BicRRR, 0xea200000,

668

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,

669

kFmtShift, -1, -1, IS_QUAD_OP | REG_DEF0_USE12,

670

"bic", "!0C, !1C, !2C!3H", 2),

671

ENCODING_MAP(kThumb2CmnRR, 0xeb000000,

672

kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0, kFmtShift, -1, -1,

673

kFmtUnused, -1, -1,

674

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

675

"cmn", "!0C, !1C, shift !2d", 2),

676

ENCODING_MAP(kThumb2EorRRR, 0xea800000,

677

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,

678

kFmtShift, -1, -1, IS_QUAD_OP | REG_DEF0_USE12,

679

"eor", "!0C, !1C, !2C!3H", 2),

680

ENCODING_MAP(kThumb2MulRRR, 0xfb00f000,

681

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,

682

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,

683

"mul", "!0C, !1C, !2C", 2),

684

ENCODING_MAP(kThumb2MnvRR, 0xea6f0000,

685

kFmtBitBlt, 11, 8, kFmtBitBlt, 3, 0, kFmtShift, -1, -1,

686

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,

687

"mvn", "!0C, !1C, shift !2d", 2),

688

ENCODING_MAP(kThumb2RsubRRI8, 0xf1d00000,

689

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtModImm, -1, -1,

690

kFmtUnused, -1, -1,

691

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

692

"rsb", "!0C,!1C,#!2m", 2),

693

ENCODING_MAP(kThumb2NegRR, 0xf1d00000, /* instance of rsub */

694

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtUnused, -1, -1,

695

kFmtUnused, -1, -1,

696

IS_BINARY_OP | REG_DEF0_USE1 | SETS_CCODES,

697

"neg", "!0C,!1C", 2),

698

ENCODING_MAP(kThumb2OrrRRR, 0xea400000,

699

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,

700

kFmtShift, -1, -1, IS_QUAD_OP | REG_DEF0_USE12,

701

"orr", "!0C, !1C, !2C!3H", 2),

702

ENCODING_MAP(kThumb2TstRR, 0xea100f00,

703

kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0, kFmtShift, -1, -1,

704

kFmtUnused, -1, -1,

705

IS_TERTIARY_OP | REG_USE01 | SETS_CCODES,

706

"tst", "!0C, !1C, shift !2d", 2),

707

ENCODING_MAP(kThumb2LslRRR, 0xfa00f000,

708

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,

709

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,

710

"lsl", "!0C, !1C, !2C", 2),

711

ENCODING_MAP(kThumb2LsrRRR, 0xfa20f000,

712

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,

713

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,

714

"lsr", "!0C, !1C, !2C", 2),

715

ENCODING_MAP(kThumb2AsrRRR, 0xfa40f000,

716

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,

717

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,

718

"asr", "!0C, !1C, !2C", 2),

719

ENCODING_MAP(kThumb2RorRRR, 0xfa60f000,

720

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,

721

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,

722

"ror", "!0C, !1C, !2C", 2),

723

ENCODING_MAP(kThumb2LslRRI5, 0xea4f0000,

724

kFmtBitBlt, 11, 8, kFmtBitBlt, 3, 0, kFmtShift5, -1, -1,

725

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,

726

"lsl", "!0C, !1C, #!2d", 2),

727

ENCODING_MAP(kThumb2LsrRRI5, 0xea4f0010,

728

kFmtBitBlt, 11, 8, kFmtBitBlt, 3, 0, kFmtShift5, -1, -1,

729

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,

730

"lsr", "!0C, !1C, #!2d", 2),

731

ENCODING_MAP(kThumb2AsrRRI5, 0xea4f0020,

732

kFmtBitBlt, 11, 8, kFmtBitBlt, 3, 0, kFmtShift5, -1, -1,

733

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,

734

"asr", "!0C, !1C, #!2d", 2),

735

ENCODING_MAP(kThumb2RorRRI5, 0xea4f0030,

736

kFmtBitBlt, 11, 8, kFmtBitBlt, 3, 0, kFmtShift5, -1, -1,

737

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,

738

"ror", "!0C, !1C, #!2d", 2),

739

ENCODING_MAP(kThumb2BicRRI8, 0xf0200000,

740

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtModImm, -1, -1,

741

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,

742

"bic", "!0C, !1C, #!2m", 2),

743

ENCODING_MAP(kThumb2AndRRI8, 0xf0000000,

744

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtModImm, -1, -1,

745

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,

746

"and", "!0C, !1C, #!2m", 2),

747

ENCODING_MAP(kThumb2OrrRRI8, 0xf0400000,

748

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtModImm, -1, -1,

749

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,

750

"orr", "!0C, !1C, #!2m", 2),

751

ENCODING_MAP(kThumb2EorRRI8, 0xf0800000,

752

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtModImm, -1, -1,

753

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,

754

"eor", "!0C, !1C, #!2m", 2),

755

ENCODING_MAP(kThumb2AddRRI8, 0xf1100000,

756

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtModImm, -1, -1,

757

kFmtUnused, -1, -1,

758

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

759

"adds", "!0C, !1C, #!2m", 2),

760

ENCODING_MAP(kThumb2AdcRRI8, 0xf1500000,

761

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtModImm, -1, -1,

762

kFmtUnused, -1, -1,

763

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES | USES_CCODES,

764

"adcs", "!0C, !1C, #!2m", 2),

765

ENCODING_MAP(kThumb2SubRRI8, 0xf1b00000,

766

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtModImm, -1, -1,

767

kFmtUnused, -1, -1,

768

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

769

"subs", "!0C, !1C, #!2m", 2),

770

ENCODING_MAP(kThumb2SbcRRI8, 0xf1700000,

771

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtModImm, -1, -1,

772

kFmtUnused, -1, -1,

773

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES | USES_CCODES,

774

"sbcs", "!0C, !1C, #!2m", 2),

775

ENCODING_MAP(kThumb2It, 0xbf00,

776

kFmtBitBlt, 7, 4, kFmtBitBlt, 3, 0, kFmtModImm, -1, -1,

777

kFmtUnused, -1, -1, IS_BINARY_OP | IS_IT | USES_CCODES,

778

"it:!1b", "!0c", 1),

779

ENCODING_MAP(kThumb2Fmstat, 0xeef1fa10,

780

kFmtUnused, -1, -1, kFmtUnused, -1, -1, kFmtUnused, -1, -1,

781

kFmtUnused, -1, -1, NO_OPERAND | SETS_CCODES,

782

"fmstat", "", 2),

783

ENCODING_MAP(kThumb2Vcmpd, 0xeeb40b40,

784

kFmtDfp, 22, 12, kFmtDfp, 5, 0, kFmtUnused, -1, -1,

785

kFmtUnused, -1, -1, IS_BINARY_OP | REG_USE01,

786

"vcmp.f64", "!0S, !1S", 2),

787

ENCODING_MAP(kThumb2Vcmps, 0xeeb40a40,

788

kFmtSfp, 22, 12, kFmtSfp, 5, 0, kFmtUnused, -1, -1,

789

kFmtUnused, -1, -1, IS_BINARY_OP | REG_USE01,

790

"vcmp.f32", "!0s, !1s", 2),

791

ENCODING_MAP(kThumb2LdrPcRel12, 0xf8df0000,

792

kFmtBitBlt, 15, 12, kFmtBitBlt, 11, 0, kFmtUnused, -1, -1,

793

kFmtUnused, -1, -1,

buzbee

2012-01-31 17:01:43 -0800

[diff] [blame]

794

IS_TERTIARY_OP | REG_DEF0 | REG_USE_PC | IS_LOAD | NEEDS_FIXUP,

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

795

"ldr", "!0C, [r15pc, #!1d]", 2),

796

ENCODING_MAP(kThumb2BCond, 0xf0008000,

797

kFmtBrOffset, -1, -1, kFmtBitBlt, 25, 22, kFmtUnused, -1, -1,

798

kFmtUnused, -1, -1,

buzbee

2012-01-31 17:01:43 -0800

[diff] [blame]

799

IS_BINARY_OP | IS_BRANCH | USES_CCODES | NEEDS_FIXUP,

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

800

"b!1c", "!0t", 2),

801

ENCODING_MAP(kThumb2Vmovd_RR, 0xeeb00b40,

802

kFmtDfp, 22, 12, kFmtDfp, 5, 0, kFmtUnused, -1, -1,

803

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,

804

"vmov.f64", "!0S, !1S", 2),

805

ENCODING_MAP(kThumb2Vmovs_RR, 0xeeb00a40,

806

kFmtSfp, 22, 12, kFmtSfp, 5, 0, kFmtUnused, -1, -1,

807

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,

808

"vmov.f32", "!0s, !1s", 2),

809

ENCODING_MAP(kThumb2Fmrs, 0xee100a10,

810

kFmtBitBlt, 15, 12, kFmtSfp, 7, 16, kFmtUnused, -1, -1,

811

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,

812

"fmrs", "!0C, !1s", 2),

813

ENCODING_MAP(kThumb2Fmsr, 0xee000a10,

814

kFmtSfp, 7, 16, kFmtBitBlt, 15, 12, kFmtUnused, -1, -1,

815

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,

816

"fmsr", "!0s, !1C", 2),

817

ENCODING_MAP(kThumb2Fmrrd, 0xec500b10,

818

kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtDfp, 5, 0,

819

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF01_USE2,

820

"fmrrd", "!0C, !1C, !2S", 2),

821

ENCODING_MAP(kThumb2Fmdrr, 0xec400b10,

822

kFmtDfp, 5, 0, kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16,

823

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,

824

"fmdrr", "!0S, !1C, !2C", 2),

825

ENCODING_MAP(kThumb2Vabsd, 0xeeb00bc0,

826

kFmtDfp, 22, 12, kFmtDfp, 5, 0, kFmtUnused, -1, -1,

827

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,

828

"vabs.f64", "!0S, !1S", 2),

829

ENCODING_MAP(kThumb2Vabss, 0xeeb00ac0,

830

kFmtSfp, 22, 12, kFmtSfp, 5, 0, kFmtUnused, -1, -1,

831

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,

832

"vabs.f32", "!0s, !1s", 2),

833

ENCODING_MAP(kThumb2Vnegd, 0xeeb10b40,

834

kFmtDfp, 22, 12, kFmtDfp, 5, 0, kFmtUnused, -1, -1,

835

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,

836

"vneg.f64", "!0S, !1S", 2),

837

ENCODING_MAP(kThumb2Vnegs, 0xeeb10a40,

838

kFmtSfp, 22, 12, kFmtSfp, 5, 0, kFmtUnused, -1, -1,

839

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,

840

"vneg.f32", "!0s, !1s", 2),

841

ENCODING_MAP(kThumb2Vmovs_IMM8, 0xeeb00a00,

842

kFmtSfp, 22, 12, kFmtFPImm, 16, 0, kFmtUnused, -1, -1,

843

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0,

844

"vmov.f32", "!0s, #0x!1h", 2),

845

ENCODING_MAP(kThumb2Vmovd_IMM8, 0xeeb00b00,

846

kFmtDfp, 22, 12, kFmtFPImm, 16, 0, kFmtUnused, -1, -1,

847

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0,

848

"vmov.f64", "!0S, #0x!1h", 2),

849

ENCODING_MAP(kThumb2Mla, 0xfb000000,

850

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,

851

kFmtBitBlt, 15, 12,

852

IS_QUAD_OP | REG_DEF0 | REG_USE1 | REG_USE2 | REG_USE3,

853

"mla", "!0C, !1C, !2C, !3C", 2),

854

ENCODING_MAP(kThumb2Umull, 0xfba00000,

855

kFmtBitBlt, 15, 12, kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16,

856

kFmtBitBlt, 3, 0,

857

IS_QUAD_OP | REG_DEF0 | REG_DEF1 | REG_USE2 | REG_USE3,

858

"umull", "!0C, !1C, !2C, !3C", 2),

859

ENCODING_MAP(kThumb2Ldrex, 0xe8500f00,

860

kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 7, 0,

861

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1 | IS_LOAD,

862

"ldrex", "!0C, [!1C, #!2E]", 2),

863

ENCODING_MAP(kThumb2Strex, 0xe8400000,

864

kFmtBitBlt, 11, 8, kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16,

865

kFmtBitBlt, 7, 0, IS_QUAD_OP | REG_DEF0_USE12 | IS_STORE,

866

"strex", "!0C,!1C, [!2C, #!2E]", 2),

867

ENCODING_MAP(kThumb2Clrex, 0xf3bf8f2f,

868

kFmtUnused, -1, -1, kFmtUnused, -1, -1, kFmtUnused, -1, -1,

869

kFmtUnused, -1, -1, NO_OPERAND,

870

"clrex", "", 2),

871

ENCODING_MAP(kThumb2Bfi, 0xf3600000,

872

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtShift5, -1, -1,

873

kFmtBitBlt, 4, 0, IS_QUAD_OP | REG_DEF0_USE1,

874

"bfi", "!0C,!1C,#!2d,#!3d", 2),

875

ENCODING_MAP(kThumb2Bfc, 0xf36f0000,

876

kFmtBitBlt, 11, 8, kFmtShift5, -1, -1, kFmtBitBlt, 4, 0,

877

kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0,

878

"bfc", "!0C,#!1d,#!2d", 2),

879

ENCODING_MAP(kThumb2Dmb, 0xf3bf8f50,

880

kFmtBitBlt, 3, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,

881

kFmtUnused, -1, -1, IS_UNARY_OP,

882

"dmb","#!0B",2),

883

ENCODING_MAP(kThumb2LdrPcReln12, 0xf85f0000,

884

kFmtBitBlt, 15, 12, kFmtBitBlt, 11, 0, kFmtUnused, -1, -1,

885

kFmtUnused, -1, -1,

886

IS_BINARY_OP | REG_DEF0 | REG_USE_PC | IS_LOAD,

887

"ldr", "!0C, [r15pc, -#!1d]", 2),

888

ENCODING_MAP(kThumb2Stm, 0xe9000000,

889

kFmtBitBlt, 19, 16, kFmtBitBlt, 12, 0, kFmtUnused, -1, -1,

890

kFmtUnused, -1, -1,

891

IS_BINARY_OP | REG_USE0 | REG_USE_LIST1 | IS_STORE,

892

"stm", "!0C, <!1R>", 2),

893

ENCODING_MAP(kThumbUndefined, 0xde00,

894

kFmtUnused, -1, -1, kFmtUnused, -1, -1, kFmtUnused, -1, -1,

895

kFmtUnused, -1, -1, NO_OPERAND,

896

"undefined", "", 1),

897

// NOTE: vpop, vpush hard-encoded for s16+ reg list

898

ENCODING_MAP(kThumb2VPopCS, 0xecbd8a00,

899

kFmtBitBlt, 7, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,

900

kFmtUnused, -1, -1,

901

IS_UNARY_OP | REG_DEF_SP | REG_USE_SP | REG_DEF_FPCS_LIST0

902

| IS_LOAD, "vpop", "<!0P>", 2),

903

ENCODING_MAP(kThumb2VPushCS, 0xed2d8a00,

904

kFmtBitBlt, 7, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,

905

kFmtUnused, -1, -1,

906

IS_UNARY_OP | REG_DEF_SP | REG_USE_SP | REG_USE_FPCS_LIST0

907

| IS_STORE, "vpush", "<!0P>", 2),

908

ENCODING_MAP(kThumb2Vldms, 0xec900a00,

909

kFmtBitBlt, 19, 16, kFmtSfp, 22, 12, kFmtBitBlt, 7, 0,

910

kFmtUnused, -1, -1,

911

IS_TERTIARY_OP | REG_USE0 | REG_DEF_FPCS_LIST2

912

| IS_LOAD, "vldms", "!0C, <!2Q>", 2),

913

ENCODING_MAP(kThumb2Vstms, 0xec800a00,

914

kFmtBitBlt, 19, 16, kFmtSfp, 22, 12, kFmtBitBlt, 7, 0,

915

kFmtUnused, -1, -1,

916

IS_TERTIARY_OP | REG_USE0 | REG_USE_FPCS_LIST2

917

| IS_STORE, "vstms", "!0C, <!2Q>", 2),

918

ENCODING_MAP(kThumb2BUncond, 0xf0009000,

919

kFmtOff24, -1, -1, kFmtUnused, -1, -1, kFmtUnused, -1, -1,

920

kFmtUnused, -1, -1, NO_OPERAND | IS_BRANCH,

921

"b", "!0t", 2),

922

ENCODING_MAP(kThumb2MovImm16H, 0xf2c00000,

923

kFmtBitBlt, 11, 8, kFmtImm16, -1, -1, kFmtUnused, -1, -1,

924

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0,

925

"movh", "!0C, #!1M", 2),

926

ENCODING_MAP(kThumb2AddPCR, 0x4487,

927

kFmtBitBlt, 6, 3, kFmtUnused, -1, -1, kFmtUnused, -1, -1,

928

kFmtUnused, -1, -1,

929

IS_UNARY_OP | REG_USE0 | IS_BRANCH,

930

"add", "rPC, !0C", 1),

buzbee

03fa263

2011-09-20 17:10:57 -0700

[diff] [blame]

931

ENCODING_MAP(kThumb2Adr, 0xf20f0000,

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

932

kFmtBitBlt, 11, 8, kFmtImm12, -1, -1, kFmtUnused, -1, -1,

933

kFmtUnused, -1, -1,

buzbee

2012-01-31 17:01:43 -0800

[diff] [blame]

934

/* Note: doesn't affect flags */

935

IS_TERTIARY_OP | REG_DEF0 | NEEDS_FIXUP,

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

936

"adr", "!0C,#!1d", 2),

937

ENCODING_MAP(kThumb2MovImm16LST, 0xf2400000,

938

kFmtBitBlt, 11, 8, kFmtImm16, -1, -1, kFmtUnused, -1, -1,

buzbee

2012-01-31 17:01:43 -0800

[diff] [blame]

939

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0 | NEEDS_FIXUP,

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

940

"mov", "!0C, #!1M", 2),

941

ENCODING_MAP(kThumb2MovImm16HST, 0xf2c00000,

942

kFmtBitBlt, 11, 8, kFmtImm16, -1, -1, kFmtUnused, -1, -1,

buzbee

2012-01-31 17:01:43 -0800

[diff] [blame]

943

kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0 | NEEDS_FIXUP,

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

944

"movh", "!0C, #!1M", 2),

945

ENCODING_MAP(kThumb2LdmiaWB, 0xe8b00000,

946

kFmtBitBlt, 19, 16, kFmtBitBlt, 15, 0, kFmtUnused, -1, -1,

947

kFmtUnused, -1, -1,

948

IS_BINARY_OP | REG_DEF0_USE0 | REG_DEF_LIST1 | IS_LOAD,

949

"ldmia", "!0C!!, <!1R>", 2),

950

ENCODING_MAP(kThumb2SubsRRI12, 0xf1b00000,

951

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtImm12, -1, -1,

952

kFmtUnused, -1, -1,

953

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

954

"subs", "!0C,!1C,#!2d", 2),

buzbee

58f9274

2011-10-01 11:22:17 -0700

[diff] [blame]

955

ENCODING_MAP(kThumb2OrrRRRs, 0xea500000,

956

kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,

957

kFmtShift, -1, -1, IS_QUAD_OP | REG_DEF0_USE12 | SETS_CCODES,

958

"orrs", "!0C, !1C, !2C!3H", 2),

buzbee

e707080

2011-10-09 17:56:06 -0700

[diff] [blame]

959

ENCODING_MAP(kThumb2Push1, 0xf84d0d04,

960

kFmtBitBlt, 15, 12, kFmtUnused, -1, -1, kFmtUnused, -1, -1,

961

kFmtUnused, -1, -1,

962

IS_UNARY_OP | REG_DEF_SP | REG_USE_SP | REG_USE0

963

| IS_STORE, "push1", "!0C", 2),

964

ENCODING_MAP(kThumb2Pop1, 0xf85d0b04,

965

kFmtBitBlt, 15, 12, kFmtUnused, -1, -1, kFmtUnused, -1, -1,

966

kFmtUnused, -1, -1,

967

IS_UNARY_OP | REG_DEF_SP | REG_USE_SP | REG_DEF0

968

| IS_LOAD, "pop1", "!0C", 2),

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

};

/*

* The fake NOP of moving r0 to r0 actually will incur data stalls if r0 is

974

* not ready. Since r5FP is not updated often, it is less likely to

975

* generate unnecessary stall cycles.

976

* TUNING: No longer true - find new NOP pattern.

977

*/

978

#define PADDING_MOV_R5_R5 0x1C2D

979

Brian Carlstrom

e7d856b

2012-01-11 18:10:55 -0800

[diff] [blame]

980

STATIC void pushWord(std::vector<uint16_t>&buf, int data) {

buzbee

2011-08-20 17:38:58 -0700

[diff] [blame]

981

buf.push_back( data & 0xffff);

buzbee

9e0f9b0

2011-08-24 15:32:46 -0700

[diff] [blame]

982

buf.push_back( (data >> 16) & 0xffff);

buzbee

2011-08-20 17:38:58 -0700

[diff] [blame]

983

}

984

Brian Carlstrom

e7d856b

2012-01-11 18:10:55 -0800

[diff] [blame]

985

void alignBuffer(std::vector<uint16_t>&buf, size_t offset) {

buzbee

2011-08-20 17:38:58 -0700

[diff] [blame]

986

while (buf.size() < (offset/2))

buf.push_back(0);

}

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

990

/* Write the numbers in the constant to the output stream */

buzbee

2011-09-23 17:34:19 -0700

[diff] [blame]

991

STATIC void installLiteralPools(CompilationUnit* cUnit)

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

992

{

buzbee

2011-08-20 17:38:58 -0700

[diff] [blame]

993

alignBuffer(cUnit->codeBuffer, cUnit->dataOffset);

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

994

ArmLIR* dataLIR = (ArmLIR*) cUnit->literalList;

995

while (dataLIR) {

buzbee

2011-08-20 17:38:58 -0700

[diff] [blame]

996

pushWord(cUnit->codeBuffer, dataLIR->operands[0]);

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

997

dataLIR = NEXT_LIR(dataLIR);

}

}

/* Write the switch tables to the output stream */

buzbee

2011-09-23 17:34:19 -0700

[diff] [blame]

1002

STATIC void installSwitchTables(CompilationUnit* cUnit)

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1003

{

1004

GrowableListIterator iterator;

1005

oatGrowableListIteratorInit(&cUnit->switchTables, &iterator);

1006

while (true) {

1007

SwitchTable* tabRec = (SwitchTable *) oatGrowableListIteratorNext(

1008

&iterator);

1009

if (tabRec == NULL) break;

buzbee

2011-08-20 17:38:58 -0700

[diff] [blame]

1010

alignBuffer(cUnit->codeBuffer, tabRec->offset);

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1011

int bxOffset = tabRec->bxInst->generic.offset + 4;

1012

if (cUnit->printMe) {

buzbee

9e0f9b0

2011-08-24 15:32:46 -0700

[diff] [blame]

1013

LOG(INFO) << "Switch table for offset 0x" << std::hex << bxOffset;

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1014

}

1015

if (tabRec->table[0] == kSparseSwitchSignature) {

1016

int* keys = (int*)&(tabRec->table[2]);

1017

for (int elems = 0; elems < tabRec->table[1]; elems++) {

1018

int disp = tabRec->targets[elems]->generic.offset - bxOffset;

1019

if (cUnit->printMe) {

1020

LOG(INFO) << " Case[" << elems << "] key: 0x" <<

1021

std::hex << keys[elems] << ", disp: 0x" <<

1022

std::hex << disp;

1023

}

buzbee

2011-08-20 17:38:58 -0700

[diff] [blame]

1024

pushWord(cUnit->codeBuffer, keys[elems]);

1025

pushWord(cUnit->codeBuffer,

1026

tabRec->targets[elems]->generic.offset - bxOffset);

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1027

}

1028

} else {

buzbee

2011-09-23 17:34:19 -0700

[diff] [blame]

1029

DCHECK_EQ(tabRec->table[0], kPackedSwitchSignature);

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1030

for (int elems = 0; elems < tabRec->table[1]; elems++) {

1031

int disp = tabRec->targets[elems]->generic.offset - bxOffset;

1032

if (cUnit->printMe) {

1033

LOG(INFO) << " Case[" << elems << "] disp: 0x" <<

1034

std::hex << disp;

1035

}

buzbee

2011-08-20 17:38:58 -0700

[diff] [blame]

1036

pushWord(cUnit->codeBuffer,

1037

tabRec->targets[elems]->generic.offset - bxOffset);

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

}

}

}

}

/* Write the fill array dta to the output stream */

buzbee

2011-09-23 17:34:19 -0700

[diff] [blame]

1044

STATIC void installFillArrayData(CompilationUnit* cUnit)

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1045

{

1046

GrowableListIterator iterator;

1047

oatGrowableListIteratorInit(&cUnit->fillArrayData, &iterator);

1048

while (true) {

1049

FillArrayData *tabRec = (FillArrayData *) oatGrowableListIteratorNext(

1050

&iterator);

1051

if (tabRec == NULL) break;

buzbee

2011-08-20 17:38:58 -0700

[diff] [blame]

1052

alignBuffer(cUnit->codeBuffer, tabRec->offset);

buzbee

58f9274

2011-10-01 11:22:17 -0700

[diff] [blame]

1053

for (int i = 0; i < ((tabRec->size + 1) / 2) ; i++) {

buzbee

e6d6196

2011-08-27 11:58:19 -0700

[diff] [blame]

1054

cUnit->codeBuffer.push_back( tabRec->table[i]);

1055

}

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

}

}

/*

* Assemble the LIR into binary instruction format. Note that we may

1061

* discover that pc-relative displacements may not fit the selected

1062

* instruction.

1063

*/

buzbee

2011-09-23 17:34:19 -0700

[diff] [blame]

1064

STATIC AssemblerStatus assembleInstructions(CompilationUnit* cUnit,

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1065

intptr_t startAddr)

1066

{

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1067

ArmLIR* lir;

1068

AssemblerStatus res = kSuccess; // Assume success

1069

1070

for (lir = (ArmLIR *) cUnit->firstLIRInsn; lir; lir = NEXT_LIR(lir)) {

buzbee

2012-01-31 17:01:43 -0800

[diff] [blame]

1071

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1072

if (lir->opcode < 0) {

1073

if ((lir->opcode == kArmPseudoPseudoAlign4) &&

1074

/* 1 means padding is needed */

1075

(lir->operands[0] == 1)) {

buzbee

2011-08-20 17:38:58 -0700

[diff] [blame]

1076

cUnit->codeBuffer.push_back(PADDING_MOV_R5_R5);

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

}

continue;

}

if (lir->flags.isNop) {

continue;

}

/*

* For PC-relative displacements we won't know if the

1087

* selected instruction will work until late (i.e. - now).

1088

* If something doesn't fit, we must replace the short-form

1089

* operation with a longer-form one. Note, though, that this

1090

* can change code we've already processed, so we'll need to

1091

* re-calculate offsets and restart. To limit the number of

1092

* restarts, the entire list will be scanned and patched.

1093

* Of course, the patching itself may cause new overflows so this

1094

* is an iterative process.

1095

*/

buzbee

2012-01-31 17:01:43 -0800

[diff] [blame]

1096

if (lir->flags.pcRelFixup) {

1097

if (lir->opcode == kThumbLdrPcRel ||

1098

lir->opcode == kThumb2LdrPcRel12 ||

1099

lir->opcode == kThumbAddPcRel ||

1100

((lir->opcode == kThumb2Vldrd) && (lir->operands[1] == r15pc)) ||

1101

((lir->opcode == kThumb2Vldrs) && (lir->operands[1] == r15pc))) {

buzbee

2011-11-28 16:06:57 -0800

[diff] [blame]

1102

/*

buzbee

2012-01-31 17:01:43 -0800

[diff] [blame]

1103

* PC-relative loads are mostly used to load immediates

1104

* that are too large to materialize directly in one shot.

1105

* However, if the load displacement exceeds the limit,

1106

* we revert to a 2-instruction materialization sequence.

buzbee

2011-11-28 16:06:57 -0800

[diff] [blame]

1107

*/

buzbee

2012-01-31 17:01:43 -0800

[diff] [blame]

1108

ArmLIR *lirTarget = (ArmLIR *) lir->generic.target;

1109

intptr_t pc = (lir->generic.offset + 4) & ~3;

1110

intptr_t target = lirTarget->generic.offset;

1111

int delta = target - pc;

1112

if (delta & 0x3) {

1113

LOG(FATAL) << "PC-rel offset not multiple of 4: " << delta;

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1114

}

buzbee

2012-01-31 17:01:43 -0800

[diff] [blame]

1115

// First, a sanity check for cases we shouldn't see now

1116

if (((lir->opcode == kThumbAddPcRel) && (delta > 1020)) ||

1117

((lir->opcode == kThumbLdrPcRel) && (delta > 1020))) {

1118

// Shouldn't happen in current codegen.

1119

LOG(FATAL) << "Unexpected pc-rel offset " << delta;

1120

}

1121

// Now, check for the two difficult cases

1122

if (((lir->opcode == kThumb2LdrPcRel12) && (delta > 4091)) ||

1123

((lir->opcode == kThumb2Vldrs) && (delta > 1020)) ||

1124

((lir->opcode == kThumb2Vldrd) && (delta > 1020))) {

1125

/*

1126

* Note: because rLR may be used to fix up out-of-range

1127

* vldrs/vldrd we include REG_DEF_LR in the resource

1128

* masks for these instructions.

1129

*/

1130

int baseReg = (lir->opcode == kThumb2LdrPcRel12) ?

1131

lir->operands[0] : rLR;

1132

1133

// Add new Adr to generate the address

1134

ArmLIR *newAdr =

1135

(ArmLIR *)oatNew(sizeof(ArmLIR), true, kAllocLIR);

1136

newAdr->generic.dalvikOffset = lir->generic.dalvikOffset;

1137

newAdr->generic.target = lir->generic.target;

1138

newAdr->opcode = kThumb2Adr;

1139

newAdr->operands[0] = baseReg;

1140

oatSetupResourceMasks(newAdr);

1141

oatInsertLIRBefore((LIR*)lir, (LIR*)newAdr);

1142

1143

// Convert to normal load

1144

if (lir->opcode == kThumb2LdrPcRel12) {

1145

lir->opcode = kThumb2LdrRRI12;

1146

}

1147

// Change the load to be relative to the new Adr base

1148

lir->operands[1] = baseReg;

1149

lir->operands[2] = 0;

1150

oatSetupResourceMasks(lir);

1151

res = kRetryAll;

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1152

} else {

buzbee

2012-01-31 17:01:43 -0800

[diff] [blame]

1153

if ((lir->opcode == kThumb2Vldrs) ||

1154

(lir->opcode == kThumb2Vldrd)) {

1155

lir->operands[2] = delta >> 2;

buzbee

e707080

2011-10-09 17:56:06 -0700

[diff] [blame]

1156

} else {

buzbee

2012-01-31 17:01:43 -0800

[diff] [blame]

1157

lir->operands[1] = (lir->opcode == kThumb2LdrPcRel12) ?

1158

delta : delta >> 2;

buzbee

e707080

2011-10-09 17:56:06 -0700

[diff] [blame]

1159

}

1160

}

buzbee

2012-01-31 17:01:43 -0800

[diff] [blame]

1161

} else if (lir->opcode == kThumb2Cbnz || lir->opcode == kThumb2Cbz) {

1162

ArmLIR *targetLIR = (ArmLIR *) lir->generic.target;

1163

intptr_t pc = lir->generic.offset + 4;

1164

intptr_t target = targetLIR->generic.offset;

1165

int delta = target - pc;

1166

if (delta > 126 || delta < 0) {

1167

/* Convert to cmp rx,#0 / b[eq/ne] tgt pair */

1168

ArmLIR *newInst =

1169

(ArmLIR *)oatNew(sizeof(ArmLIR), true, kAllocLIR);

1170

/* Make new branch instruction and insert after */

1171

newInst->generic.dalvikOffset = lir->generic.dalvikOffset;

1172

newInst->opcode = kThumbBCond;

1173

newInst->operands[0] = 0;

1174

newInst->operands[1] = (lir->opcode == kThumb2Cbz) ?

1175

kArmCondEq : kArmCondNe;

1176

newInst->generic.target = lir->generic.target;

1177

oatSetupResourceMasks(newInst);

1178

oatInsertLIRAfter((LIR *)lir, (LIR *)newInst);

1179

/* Convert the cb[n]z to a cmp rx, #0 ] */

1180

lir->opcode = kThumbCmpRI8;

1181

/* operand[0] is src1 in both cb[n]z & CmpRI8 */

1182

lir->operands[1] = 0;

1183

lir->generic.target = 0;

1184

oatSetupResourceMasks(lir);

1185

res = kRetryAll;

1186

} else {

1187

lir->operands[1] = delta >> 1;

1188

}

1189

} else if (lir->opcode == kThumb2Push ||

1190

lir->opcode == kThumb2Pop) {

1191

if (__builtin_popcount(lir->operands[0]) == 1) {

1192

/*

1193

* The standard push/pop multiple instruction

1194

* requires at least two registers in the list.

1195

* If we've got just one, switch to the single-reg

1196

* encoding.

1197

*/

1198

lir->opcode = (lir->opcode == kThumb2Push)

1199

? kThumb2Push1 : kThumb2Pop1;

1200

int reg = 0;

1201

while (lir->operands[0]) {

1202

if (lir->operands[0] & 0x1) {

break;

} else {

reg++;

lir->operands[0] >>= 1;

1207

}

1208

}

1209

lir->operands[0] = reg;

1210

oatSetupResourceMasks(lir);

1211

res = kRetryAll;

1212

}

1213

} else if (lir->opcode == kThumbBCond ||

1214

lir->opcode == kThumb2BCond) {

1215

ArmLIR *targetLIR = (ArmLIR *) lir->generic.target;

1216

int delta = 0;

1217

DCHECK(targetLIR);

1218

intptr_t pc = lir->generic.offset + 4;

1219

intptr_t target = targetLIR->generic.offset;

1220

delta = target - pc;

1221

if ((lir->opcode == kThumbBCond) &&

1222

(delta > 254 || delta < -256)) {

1223

lir->opcode = kThumb2BCond;

1224

oatSetupResourceMasks(lir);

1225

res = kRetryAll;

1226

}

1227

lir->operands[0] = delta >> 1;

1228

} else if (lir->opcode == kThumb2BUncond) {

1229

ArmLIR *targetLIR = (ArmLIR *) lir->generic.target;

1230

intptr_t pc = lir->generic.offset + 4;

1231

intptr_t target = targetLIR->generic.offset;

1232

int delta = target - pc;

1233

lir->operands[0] = delta >> 1;

1234

if (lir->operands[0] == 0) { // Useless branch?

1235

lir->flags.isNop = true;

1236

res = kRetryAll;

1237

}

1238

} else if (lir->opcode == kThumbBUncond) {

1239

ArmLIR *targetLIR = (ArmLIR *) lir->generic.target;

1240

intptr_t pc = lir->generic.offset + 4;

1241

intptr_t target = targetLIR->generic.offset;

1242

int delta = target - pc;

1243

if (delta > 2046 || delta < -2048) {

1244

// Convert to Thumb2BCond w/ kArmCondAl

1245

lir->opcode = kThumb2BUncond;

1246

lir->operands[0] = 0;

1247

oatSetupResourceMasks(lir);

1248

res = kRetryAll;

1249

}

1250

lir->operands[0] = delta >> 1;

1251

if ((lir->operands[0] == 0) ||

1252

(lir->operands[0] == -1)) { // Useless branch?

1253

lir->flags.isNop = true;

1254

res = kRetryAll;

1255

}

1256

} else if (lir->opcode == kThumbBlx1) {

1257

DCHECK(NEXT_LIR(lir)->opcode == kThumbBlx2);

1258

/* curPC is Thumb */

1259

intptr_t curPC = (startAddr + lir->generic.offset + 4) & ~3;

1260

intptr_t target = lir->operands[1];

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1261

buzbee

2012-01-31 17:01:43 -0800

[diff] [blame]

1262

/* Match bit[1] in target with base */

if (curPC & 0x2) {

target |= 0x2;

}

int delta = target - curPC;

1267

DCHECK((delta >= -(1<<22)) && (delta <= ((1<<22)-2)));

1268

1269

lir->operands[0] = (delta >> 12) & 0x7ff;

1270

NEXT_LIR(lir)->operands[0] = (delta>> 1) & 0x7ff;

1271

} else if (lir->opcode == kThumbBl1) {

1272

DCHECK(NEXT_LIR(lir)->opcode == kThumbBl2);

1273

/* Both curPC and target are Thumb */

1274

intptr_t curPC = startAddr + lir->generic.offset + 4;

1275

intptr_t target = lir->operands[1];

1276

1277

int delta = target - curPC;

1278

DCHECK((delta >= -(1<<22)) && (delta <= ((1<<22)-2)));

1279

1280

lir->operands[0] = (delta >> 12) & 0x7ff;

1281

NEXT_LIR(lir)->operands[0] = (delta>> 1) & 0x7ff;

1282

} else if (lir->opcode == kThumb2Adr) {

1283

SwitchTable *tabRec = (SwitchTable*)lir->operands[2];

1284

ArmLIR* target = (ArmLIR*)lir->generic.target;

1285

int targetDisp = tabRec ? tabRec->offset

1286

: target->generic.offset;

1287

int disp = targetDisp - ((lir->generic.offset + 4) & ~3);

1288

if (disp < 4096) {

1289

lir->operands[1] = disp;

1290

} else {

1291

// convert to ldimm16l, ldimm16h, add tgt, pc, operands[0]

1292

ArmLIR *newMov16L =

1293

(ArmLIR *)oatNew(sizeof(ArmLIR), true, kAllocLIR);

1294

newMov16L->generic.dalvikOffset = lir->generic.dalvikOffset;

1295

newMov16L->generic.target = lir->generic.target;

1296

newMov16L->opcode = kThumb2MovImm16LST;

1297

newMov16L->operands[0] = lir->operands[0];

1298

newMov16L->operands[2] = (intptr_t)lir;

1299

newMov16L->operands[3] = (intptr_t)tabRec;

1300

oatSetupResourceMasks(newMov16L);

1301

oatInsertLIRBefore((LIR*)lir, (LIR*)newMov16L);

1302

ArmLIR *newMov16H =

1303

(ArmLIR *)oatNew(sizeof(ArmLIR), true, kAllocLIR);

1304

newMov16H->generic.dalvikOffset = lir->generic.dalvikOffset;

1305

newMov16H->generic.target = lir->generic.target;

1306

newMov16H->opcode = kThumb2MovImm16HST;

1307

newMov16H->operands[0] = lir->operands[0];

1308

newMov16H->operands[2] = (intptr_t)lir;

1309

newMov16H->operands[3] = (intptr_t)tabRec;

1310

oatSetupResourceMasks(newMov16H);

1311

oatInsertLIRBefore((LIR*)lir, (LIR*)newMov16H);

1312

lir->opcode = kThumb2AddRRR;

1313

lir->operands[1] = rPC;

1314

lir->operands[2] = lir->operands[0];

1315

oatSetupResourceMasks(lir);

1316

res = kRetryAll;

1317

}

1318

} else if (lir->opcode == kThumb2MovImm16LST) {

1319

// operands[1] should hold disp, [2] has add, [3] has tabRec

1320

ArmLIR *addPCInst = (ArmLIR*)lir->operands[2];

1321

SwitchTable *tabRec = (SwitchTable*)lir->operands[3];

1322

// If tabRec is null, this is a literal load. Use generic.target

1323

ArmLIR* target = (ArmLIR*)lir->generic.target;

1324

int targetDisp = tabRec ? tabRec->offset

1325

: target->generic.offset;

1326

lir->operands[1] = (targetDisp -

1327

(addPCInst->generic.offset + 4)) & 0xffff;

1328

} else if (lir->opcode == kThumb2MovImm16HST) {

1329

// operands[1] should hold disp, [2] has add, [3] has tabRec

1330

ArmLIR *addPCInst = (ArmLIR*)lir->operands[2];

1331

SwitchTable *tabRec = (SwitchTable*)lir->operands[3];

1332

// If tabRec is null, this is a literal load. Use generic.target

1333

ArmLIR* target = (ArmLIR*)lir->generic.target;

1334

int targetDisp = tabRec ? tabRec->offset

1335

: target->generic.offset;

1336

lir->operands[1] = ((targetDisp -

1337

(addPCInst->generic.offset + 4)) >> 16) & 0xffff;

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1338

}

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1339

}

buzbee

f16600b

2012-02-02 18:19:29 -0800

[diff] [blame^]

1340

/*

1341

* If one of the pc-relative instructions expanded we'll have

1342

* to make another pass. Don't bother to fully assemble the

1343

* instruction.

1344

*/

1345

if (res != kSuccess) {

1346

continue;

1347

}

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1348

ArmEncodingMap *encoder = &EncodingMap[lir->opcode];

1349

u4 bits = encoder->skeleton;

1350

int i;

1351

for (i = 0; i < 4; i++) {

1352

u4 operand;

1353

u4 value;

1354

operand = lir->operands[i];

1355

switch(encoder->fieldLoc[i].kind) {

case kFmtUnused:

break;

case kFmtFPImm:

value = ((operand & 0xF0) >> 4) << encoder->fieldLoc[i].end;

1360

value |= (operand & 0x0F) << encoder->fieldLoc[i].start;

bits |= value;

break;

case kFmtBrOffset:

value = ((operand & 0x80000) >> 19) << 26;

1365

value |= ((operand & 0x40000) >> 18) << 11;

1366

value |= ((operand & 0x20000) >> 17) << 13;

1367

value |= ((operand & 0x1f800) >> 11) << 16;

1368

value |= (operand & 0x007ff);

bits |= value;

break;

case kFmtShift5:

value = ((operand & 0x1c) >> 2) << 12;

1373

value |= (operand & 0x03) << 6;

bits |= value;

break;

case kFmtShift:

value = ((operand & 0x70) >> 4) << 12;

1378

value |= (operand & 0x0f) << 4;

bits |= value;

break;

case kFmtBWidth:

value = operand - 1;

bits |= value;

break;

case kFmtLsb:

value = ((operand & 0x1c) >> 2) << 12;

1387

value |= (operand & 0x03) << 6;

bits |= value;

break;

case kFmtImm6:

value = ((operand & 0x20) >> 5) << 9;

1392

value |= (operand & 0x1f) << 3;

bits |= value;

break;

case kFmtBitBlt:

value = (operand << encoder->fieldLoc[i].start) &

1397

((1 << (encoder->fieldLoc[i].end + 1)) - 1);

1398

bits |= value;

1399

break;

1400

case kFmtDfp: {

buzbee

2011-09-23 17:34:19 -0700

[diff] [blame]

1401

DCHECK(DOUBLEREG(operand));

1402

DCHECK((operand & 0x1) == 0);

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1403

int regName = (operand & FP_REG_MASK) >> 1;

1404

/* Snag the 1-bit slice and position it */

1405

value = ((regName & 0x10) >> 4) <<

1406

encoder->fieldLoc[i].end;

1407

/* Extract and position the 4-bit slice */

1408

value |= (regName & 0x0f) <<

1409

encoder->fieldLoc[i].start;

bits |= value;

break;

}

case kFmtSfp:

buzbee

2011-09-23 17:34:19 -0700

[diff] [blame]

1414

DCHECK(SINGLEREG(operand));

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1415

/* Snag the 1-bit slice and position it */

1416

value = (operand & 0x1) <<

1417

encoder->fieldLoc[i].end;

1418

/* Extract and position the 4-bit slice */

1419

value |= ((operand & 0x1e) >> 1) <<

1420

encoder->fieldLoc[i].start;

bits |= value;

break;

case kFmtImm12:

case kFmtModImm:

value = ((operand & 0x800) >> 11) << 26;

1426

value |= ((operand & 0x700) >> 8) << 12;

1427

value |= operand & 0x0ff;

bits |= value;

break;

case kFmtImm16:

value = ((operand & 0x0800) >> 11) << 26;

1432

value |= ((operand & 0xf000) >> 12) << 16;

1433

value |= ((operand & 0x0700) >> 8) << 12;

1434

value |= operand & 0x0ff;

bits |= value;

break;

case kFmtOff24: {

u4 signbit = (operand >> 31) & 0x1;

1439

u4 i1 = (operand >> 22) & 0x1;

1440

u4 i2 = (operand >> 21) & 0x1;

1441

u4 imm10 = (operand >> 11) & 0x03ff;

1442

u4 imm11 = operand & 0x07ff;

1443

u4 j1 = (i1 ^ signbit) ? 0 : 1;

1444

u4 j2 = (i2 ^ signbit) ? 0 : 1;

1445

value = (signbit << 26) | (j1 << 13) | (j2 << 11) |

1446

(imm10 << 16) | imm11;

bits |= value;

}

break;

default:

buzbee

2011-09-23 17:34:19 -0700

[diff] [blame]

1451

LOG(FATAL) << "Bad fmt:" << (int)encoder->fieldLoc[i].kind;

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1452

}

1453

}

1454

if (encoder->size == 2) {

buzbee

2011-08-20 17:38:58 -0700

[diff] [blame]

1455

cUnit->codeBuffer.push_back((bits >> 16) & 0xffff);

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1456

}

buzbee

2011-08-20 17:38:58 -0700

[diff] [blame]

1457

cUnit->codeBuffer.push_back(bits & 0xffff);

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

}

return res;

}

buzbee

2011-09-23 17:34:19 -0700

[diff] [blame]

1462

STATIC int assignLiteralOffsetCommon(LIR* lir, int offset)

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1463

{

1464

for (;lir != NULL; lir = lir->next) {

1465

lir->offset = offset;

offset += 4;

}

return offset;

}

buzbee

2011-09-23 17:34:19 -0700

[diff] [blame]

1471

STATIC void createMappingTable(CompilationUnit* cUnit)

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1472

{

1473

ArmLIR* armLIR;

1474

int currentDalvikOffset = -1;

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1475

1476

for (armLIR = (ArmLIR *) cUnit->firstLIRInsn;

1477

armLIR;

1478

armLIR = NEXT_LIR(armLIR)) {

1479

if ((armLIR->opcode >= 0) && !armLIR->flags.isNop &&

1480

(currentDalvikOffset != armLIR->generic.dalvikOffset)) {

1481

// Changed - need to emit a record

buzbee

4ef7652

2011-09-08 10:00:32 -0700

[diff] [blame]

1482

cUnit->mappingTable.push_back(armLIR->generic.offset);

1483

cUnit->mappingTable.push_back(armLIR->generic.dalvikOffset);

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1484

currentDalvikOffset = armLIR->generic.dalvikOffset;

1485

}

1486

}

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1487

}

1488

1489

/* Determine the offset of each literal field */

buzbee

2011-09-23 17:34:19 -0700

[diff] [blame]

1490

STATIC int assignLiteralOffset(CompilationUnit* cUnit, int offset)

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1491

{

1492

offset = assignLiteralOffsetCommon(cUnit->literalList, offset);

return offset;

}

buzbee

2011-09-23 17:34:19 -0700

[diff] [blame]

1496

STATIC int assignSwitchTablesOffset(CompilationUnit* cUnit, int offset)

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1497

{

1498

GrowableListIterator iterator;

1499

oatGrowableListIteratorInit(&cUnit->switchTables, &iterator);

1500

while (true) {

1501

SwitchTable *tabRec = (SwitchTable *) oatGrowableListIteratorNext(

1502

&iterator);

1503

if (tabRec == NULL) break;

1504

tabRec->offset = offset;

1505

if (tabRec->table[0] == kSparseSwitchSignature) {

1506

offset += tabRec->table[1] * (sizeof(int) * 2);

1507

} else {

buzbee

2011-09-23 17:34:19 -0700

[diff] [blame]

1508

DCHECK_EQ(tabRec->table[0], kPackedSwitchSignature);

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1509

offset += tabRec->table[1] * sizeof(int);

}

}

return offset;

}

buzbee

2011-09-23 17:34:19 -0700

[diff] [blame]

1515

STATIC int assignFillArrayDataOffset(CompilationUnit* cUnit, int offset)

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1516

{

1517

GrowableListIterator iterator;

1518

oatGrowableListIteratorInit(&cUnit->fillArrayData, &iterator);

1519

while (true) {

1520

FillArrayData *tabRec = (FillArrayData *) oatGrowableListIteratorNext(

1521

&iterator);

1522

if (tabRec == NULL) break;

1523

tabRec->offset = offset;

1524

offset += tabRec->size;

1525

// word align

1526

offset = (offset + 3) & ~3;

}

return offset;

}

/*

* Walk the compilation unit and assign offsets to instructions

1533

* and literals and compute the total size of the compiled unit.

1534

*/

1535

void assignOffsets(CompilationUnit* cUnit)

{

ArmLIR* armLIR;

int offset = 0;

for (armLIR = (ArmLIR *) cUnit->firstLIRInsn;

1541

armLIR;

1542

armLIR = NEXT_LIR(armLIR)) {

1543

armLIR->generic.offset = offset;

buzbee

2012-01-31 17:01:43 -0800

[diff] [blame]

1544

if (armLIR->opcode >= 0) {

1545

if (!armLIR->flags.isNop) {

1546

armLIR->flags.size = EncodingMap[armLIR->opcode].size * 2;

1547

offset += armLIR->flags.size;

1548

}

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1549

} else if (armLIR->opcode == kArmPseudoPseudoAlign4) {

1550

if (offset & 0x2) {

1551

offset += 2;

1552

armLIR->operands[0] = 1;

1553

} else {

1554

armLIR->operands[0] = 0;

1555

}

1556

}

1557

/* Pseudo opcodes don't consume space */

1558

}

1559

1560

/* Const values have to be word aligned */

1561

offset = (offset + 3) & ~3;

1562

1563

/* Set up offsets for literals */

1564

cUnit->dataOffset = offset;

1565

1566

offset = assignLiteralOffset(cUnit, offset);

1567

1568

offset = assignSwitchTablesOffset(cUnit, offset);

1569

1570

offset = assignFillArrayDataOffset(cUnit, offset);

1571

1572

cUnit->totalSize = offset;

1573

}

1574

/*

1575

* Go over each instruction in the list and calculate the offset from the top

1576

* before sending them off to the assembler. If out-of-range branch distance is

1577

* seen rearrange the instructions a bit to correct it.

1578

*/

1579

void oatAssembleLIR(CompilationUnit* cUnit)

1580

{

1581

assignOffsets(cUnit);

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1582

/*

1583

* Assemble here. Note that we generate code with optimistic assumptions

1584

* and if found now to work, we'll have to redo the sequence and retry.

1585

*/

1586

1587

while (true) {

Brian Carlstrom

2e3d1b2

2012-01-09 18:01:56 -0800

[diff] [blame]

1588

AssemblerStatus res = assembleInstructions(cUnit, 0);

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1589

if (res == kSuccess) {

1590

break;

1591

} else {

1592

cUnit->assemblerRetries++;

1593

if (cUnit->assemblerRetries > MAX_ASSEMBLER_RETRIES) {

1594

LOG(FATAL) << "Assembler error - too many retries";

1595

}

1596

// Redo offsets and try again

1597

assignOffsets(cUnit);

buzbee

2011-08-20 17:38:58 -0700

[diff] [blame]

1598

cUnit->codeBuffer.clear();

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

}

}

// Install literals

installLiteralPools(cUnit);

1604

1605

// Install switch tables

1606

installSwitchTables(cUnit);

1607

1608

// Install fill array data

1609

installFillArrayData(cUnit);

1610

1611

/*

1612

* Create the mapping table

1613

*/

buzbee

4ef7652

2011-09-08 10:00:32 -0700

[diff] [blame]

1614

createMappingTable(cUnit);

buzbee