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

buzbee

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

[diff] [blame]

23

#define MAX_ASSEMBLER_RETRIES 50

24

25

/*

26

* opcode: ArmOpcode enum

27

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

28

* k0: key to applying ds/de

29

* ds: dest start bit position

30

* de: dest end bit position

31

* k1: key to applying s1s/s1e

32

* s1s: src1 start bit position

33

* s1e: src1 end bit position

34

* k2: key to applying s2s/s2e

35

* s2s: src2 start bit position

36

* s2e: src2 end bit position

37

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

38

* name: mnemonic name

39

* fmt: for pretty-printing

40

*/

41

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

42

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

43

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

44

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

45

46

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

47

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

* print format.

*

* [p]ositions:

* 0 -> operands[0] (dest)

52

* 1 -> operands[1] (src1)

53

* 2 -> operands[2] (src2)

54

* 3 -> operands[3] (extra)

*

* [f]ormats:

* h -> 4-digit hex

* d -> decimal

* E -> decimal*4

* F -> decimal*2

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

62

* t -> pc-relative target

63

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

64

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

65

* R -> register list

66

* s -> single precision floating point register

67

* S -> double precision floating point register

68

* m -> Thumb2 modified immediate

69

* n -> complimented Thumb2 modified immediate

70

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

71

* b -> 4-digit binary

72

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

73

* H -> operand shift

74

* C -> core register name

75

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

76

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

77

*

78

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

79

*/

80

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

81

ArmEncodingMap EncodingMap[kArmLast] = {

82

ENCODING_MAP(kArm16BitData, 0x0000,

83

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

84

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

85

ENCODING_MAP(kThumbAdcRR, 0x4140,

86

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

87

kFmtUnused, -1, -1,

88

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES | USES_CCODES,

89

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

90

ENCODING_MAP(kThumbAddRRI3, 0x1c00,

91

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

92

kFmtUnused, -1, -1,

93

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

94

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

95

ENCODING_MAP(kThumbAddRI8, 0x3000,

96

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

97

kFmtUnused, -1, -1,

98

IS_BINARY_OP | REG_DEF0_USE0 | SETS_CCODES,

99

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

100

ENCODING_MAP(kThumbAddRRR, 0x1800,

101

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

102

kFmtUnused, -1, -1,

103

IS_TERTIARY_OP | REG_DEF0_USE12 | SETS_CCODES,

104

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

105

ENCODING_MAP(kThumbAddRRLH, 0x4440,

106

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

107

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

108

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

109

ENCODING_MAP(kThumbAddRRHL, 0x4480,

110

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

111

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

112

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

113

ENCODING_MAP(kThumbAddRRHH, 0x44c0,

114

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

115

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

116

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

117

ENCODING_MAP(kThumbAddPcRel, 0xa000,

118

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

119

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

120

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

121

ENCODING_MAP(kThumbAddSpRel, 0xa800,

122

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

123

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

124

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

125

ENCODING_MAP(kThumbAddSpI7, 0xb000,

126

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

127

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

128

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

129

ENCODING_MAP(kThumbAndRR, 0x4000,

130

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

131

kFmtUnused, -1, -1,

132

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,

133

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

134

ENCODING_MAP(kThumbAsrRRI5, 0x1000,

135

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

136

kFmtUnused, -1, -1,

137

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

138

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

139

ENCODING_MAP(kThumbAsrRR, 0x4100,

140

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

141

kFmtUnused, -1, -1,

142

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,

143

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

144

ENCODING_MAP(kThumbBCond, 0xd000,

145

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

146

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

147

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

148

ENCODING_MAP(kThumbBUncond, 0xe000,

149

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

150

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

151

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

152

ENCODING_MAP(kThumbBicRR, 0x4380,

153

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

154

kFmtUnused, -1, -1,

155

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,

156

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

157

ENCODING_MAP(kThumbBkpt, 0xbe00,

158

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

159

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

160

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

161

ENCODING_MAP(kThumbBlx1, 0xf000,

162

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

163

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

164

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

165

ENCODING_MAP(kThumbBlx2, 0xe800,

166

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

167

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

168

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

169

ENCODING_MAP(kThumbBl1, 0xf000,

170

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

171

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

172

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

173

ENCODING_MAP(kThumbBl2, 0xf800,

174

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

175

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

176

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

177

ENCODING_MAP(kThumbBlxR, 0x4780,

178

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

179

kFmtUnused, -1, -1,

180

IS_UNARY_OP | REG_USE0 | IS_BRANCH | REG_DEF_LR,

181

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

182

ENCODING_MAP(kThumbBx, 0x4700,

183

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

184

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

185

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

186

ENCODING_MAP(kThumbCmnRR, 0x42c0,

187

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

188

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

189

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

190

ENCODING_MAP(kThumbCmpRI8, 0x2800,

191

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

192

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

193

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

194

ENCODING_MAP(kThumbCmpRR, 0x4280,

195

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

196

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

197

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

198

ENCODING_MAP(kThumbCmpLH, 0x4540,

199

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

200

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

201

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

202

ENCODING_MAP(kThumbCmpHL, 0x4580,

203

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

204

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

205

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

206

ENCODING_MAP(kThumbCmpHH, 0x45c0,

207

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

208

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

209

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

210

ENCODING_MAP(kThumbEorRR, 0x4040,

211

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

212

kFmtUnused, -1, -1,

213

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,

214

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

215

ENCODING_MAP(kThumbLdmia, 0xc800,

216

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

217

kFmtUnused, -1, -1,

218

IS_BINARY_OP | REG_DEF0_USE0 | REG_DEF_LIST1 | IS_LOAD,

219

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

220

ENCODING_MAP(kThumbLdrRRI5, 0x6800,

221

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

222

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

223

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

224

ENCODING_MAP(kThumbLdrRRR, 0x5800,

225

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

226

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

227

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

228

ENCODING_MAP(kThumbLdrPcRel, 0x4800,

229

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

230

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

231

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

232

ENCODING_MAP(kThumbLdrSpRel, 0x9800,

233

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

234

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

235

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

236

ENCODING_MAP(kThumbLdrbRRI5, 0x7800,

237

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

238

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

239

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

240

ENCODING_MAP(kThumbLdrbRRR, 0x5c00,

241

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

242

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

243

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

244

ENCODING_MAP(kThumbLdrhRRI5, 0x8800,

245

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

246

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

247

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

248

ENCODING_MAP(kThumbLdrhRRR, 0x5a00,

249

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

250

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

251

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

252

ENCODING_MAP(kThumbLdrsbRRR, 0x5600,

253

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

254

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

255

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

256

ENCODING_MAP(kThumbLdrshRRR, 0x5e00,

257

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

258

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

259

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

260

ENCODING_MAP(kThumbLslRRI5, 0x0000,

261

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

262

kFmtUnused, -1, -1,

263

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

264

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

265

ENCODING_MAP(kThumbLslRR, 0x4080,

266

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

267

kFmtUnused, -1, -1,

268

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,

269

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

270

ENCODING_MAP(kThumbLsrRRI5, 0x0800,

271

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

272

kFmtUnused, -1, -1,

273

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

274

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

275

ENCODING_MAP(kThumbLsrRR, 0x40c0,

276

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

277

kFmtUnused, -1, -1,

278

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,

279

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

280

ENCODING_MAP(kThumbMovImm, 0x2000,

281

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

282

kFmtUnused, -1, -1,

283

IS_BINARY_OP | REG_DEF0 | SETS_CCODES,

284

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

285

ENCODING_MAP(kThumbMovRR, 0x1c00,

286

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

287

kFmtUnused, -1, -1,

288

IS_BINARY_OP | REG_DEF0_USE1 | SETS_CCODES,

289

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

290

ENCODING_MAP(kThumbMovRR_H2H, 0x46c0,

291

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

292

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

293

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

294

ENCODING_MAP(kThumbMovRR_H2L, 0x4640,

295

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

296

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

297

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

298

ENCODING_MAP(kThumbMovRR_L2H, 0x4680,

299

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

300

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

301

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

302

ENCODING_MAP(kThumbMul, 0x4340,

303

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

304

kFmtUnused, -1, -1,

305

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,

306

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

307

ENCODING_MAP(kThumbMvn, 0x43c0,

308

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

309

kFmtUnused, -1, -1,

310

IS_BINARY_OP | REG_DEF0_USE1 | SETS_CCODES,

311

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

312

ENCODING_MAP(kThumbNeg, 0x4240,

313

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

314

kFmtUnused, -1, -1,

315

IS_BINARY_OP | REG_DEF0_USE1 | SETS_CCODES,

316

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

317

ENCODING_MAP(kThumbOrr, 0x4300,

318

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

319

kFmtUnused, -1, -1,

320

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,

321

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

322

ENCODING_MAP(kThumbPop, 0xbc00,

323

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

324

kFmtUnused, -1, -1,

325

IS_UNARY_OP | REG_DEF_SP | REG_USE_SP | REG_DEF_LIST0

326

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

327

ENCODING_MAP(kThumbPush, 0xb400,

328

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

329

kFmtUnused, -1, -1,

330

IS_UNARY_OP | REG_DEF_SP | REG_USE_SP | REG_USE_LIST0

331

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

332

ENCODING_MAP(kThumbRorRR, 0x41c0,

333

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

334

kFmtUnused, -1, -1,

335

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,

336

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

337

ENCODING_MAP(kThumbSbc, 0x4180,

338

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

339

kFmtUnused, -1, -1,

340

IS_BINARY_OP | REG_DEF0_USE01 | USES_CCODES | SETS_CCODES,

341

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

342

ENCODING_MAP(kThumbStmia, 0xc000,

343

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

344

kFmtUnused, -1, -1,

345

IS_BINARY_OP | REG_DEF0 | REG_USE0 | REG_USE_LIST1 | IS_STORE,

346

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

347

ENCODING_MAP(kThumbStrRRI5, 0x6000,

348

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

349

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

350

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

351

ENCODING_MAP(kThumbStrRRR, 0x5000,

352

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

353

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

354

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

355

ENCODING_MAP(kThumbStrSpRel, 0x9000,

356

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

357

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

358

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

359

ENCODING_MAP(kThumbStrbRRI5, 0x7000,

360

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

361

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

362

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

363

ENCODING_MAP(kThumbStrbRRR, 0x5400,

364

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

365

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

366

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

367

ENCODING_MAP(kThumbStrhRRI5, 0x8000,

368

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

369

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

370

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

371

ENCODING_MAP(kThumbStrhRRR, 0x5200,

372

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

373

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

374

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

375

ENCODING_MAP(kThumbSubRRI3, 0x1e00,

376

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

377

kFmtUnused, -1, -1,

378

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

379

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

380

ENCODING_MAP(kThumbSubRI8, 0x3800,

381

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

382

kFmtUnused, -1, -1,

383

IS_BINARY_OP | REG_DEF0_USE0 | SETS_CCODES,

384

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

385

ENCODING_MAP(kThumbSubRRR, 0x1a00,

386

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

387

kFmtUnused, -1, -1,

388

IS_TERTIARY_OP | REG_DEF0_USE12 | SETS_CCODES,

389

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

390

ENCODING_MAP(kThumbSubSpI7, 0xb080,

391

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

392

kFmtUnused, -1, -1,

393

IS_UNARY_OP | REG_DEF_SP | REG_USE_SP,

394

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

395

ENCODING_MAP(kThumbSwi, 0xdf00,

Ian Rogers

408f79a

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

[diff] [blame]

396

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

397

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

buzbee

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

[diff] [blame]

398

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

399

ENCODING_MAP(kThumbTst, 0x4200,

400

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

401

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

402

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

403

ENCODING_MAP(kThumb2Vldrs, 0xed900a00,

404

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

buzbee

4965b66

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

[diff] [blame^]

405

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

406

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

buzbee

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

[diff] [blame]

407

ENCODING_MAP(kThumb2Vldrd, 0xed900b00,

408

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

buzbee

4965b66

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

[diff] [blame^]

409

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

410

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

buzbee

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

[diff] [blame]

411

ENCODING_MAP(kThumb2Vmuls, 0xee200a00,

412

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

413

kFmtUnused, -1, -1,

414

IS_TERTIARY_OP | REG_DEF0_USE12,

415

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

416

ENCODING_MAP(kThumb2Vmuld, 0xee200b00,

417

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

418

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

419

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

420

ENCODING_MAP(kThumb2Vstrs, 0xed800a00,

421

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

422

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

423

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

424

ENCODING_MAP(kThumb2Vstrd, 0xed800b00,

425

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

426

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

427

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

428

ENCODING_MAP(kThumb2Vsubs, 0xee300a40,

429

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

430

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

431

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

432

ENCODING_MAP(kThumb2Vsubd, 0xee300b40,

433

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

434

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

435

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

436

ENCODING_MAP(kThumb2Vadds, 0xee300a00,

437

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

438

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

439

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

440

ENCODING_MAP(kThumb2Vaddd, 0xee300b00,

441

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

442

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

443

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

444

ENCODING_MAP(kThumb2Vdivs, 0xee800a00,

445

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

446

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

447

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

448

ENCODING_MAP(kThumb2Vdivd, 0xee800b00,

449

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

450

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

451

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

452

ENCODING_MAP(kThumb2VcvtIF, 0xeeb80ac0,

453

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

454

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

455

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

456

ENCODING_MAP(kThumb2VcvtID, 0xeeb80bc0,

457

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

458

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

459

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

460

ENCODING_MAP(kThumb2VcvtFI, 0xeebd0ac0,

461

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

462

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

463

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

464

ENCODING_MAP(kThumb2VcvtDI, 0xeebd0bc0,

465

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

466

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

467

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

468

ENCODING_MAP(kThumb2VcvtFd, 0xeeb70ac0,

469

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

470

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

471

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

472

ENCODING_MAP(kThumb2VcvtDF, 0xeeb70bc0,

473

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

474

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

475

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

476

ENCODING_MAP(kThumb2Vsqrts, 0xeeb10ac0,

477

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

478

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

479

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

480

ENCODING_MAP(kThumb2Vsqrtd, 0xeeb10bc0,

481

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

482

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

483

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

484

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

485

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

486

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

487

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

488

ENCODING_MAP(kThumb2MovImm16, 0xf2400000,

489

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

490

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

491

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

492

ENCODING_MAP(kThumb2StrRRI12, 0xf8c00000,

493

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

494

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

495

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

496

ENCODING_MAP(kThumb2LdrRRI12, 0xf8d00000,

497

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

498

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

499

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

500

ENCODING_MAP(kThumb2StrRRI8Predec, 0xf8400c00,

501

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

502

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

503

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

504

ENCODING_MAP(kThumb2LdrRRI8Predec, 0xf8500c00,

505

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

506

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

507

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

508

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

509

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

510

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

511

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

512

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

513

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

514

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

515

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

516

ENCODING_MAP(kThumb2AddRRI12, 0xf2000000,

517

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

518

kFmtUnused, -1, -1,

519

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

520

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

521

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

522

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

523

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

524

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

525

ENCODING_MAP(kThumb2Vmovs, 0xeeb00a40,

526

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

527

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

528

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

529

ENCODING_MAP(kThumb2Vmovd, 0xeeb00b40,

530

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

531

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

532

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

533

ENCODING_MAP(kThumb2Ldmia, 0xe8900000,

534

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

535

kFmtUnused, -1, -1,

536

IS_BINARY_OP | REG_DEF0_USE0 | REG_DEF_LIST1 | IS_LOAD,

537

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

538

ENCODING_MAP(kThumb2Stmia, 0xe8800000,

539

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

540

kFmtUnused, -1, -1,

541

IS_BINARY_OP | REG_DEF0_USE0 | REG_USE_LIST1 | IS_STORE,

542

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

543

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

544

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

545

kFmtShift, -1, -1,

546

IS_QUAD_OP | REG_DEF0_USE12 | SETS_CCODES,

547

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

548

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

549

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

550

kFmtShift, -1, -1,

551

IS_QUAD_OP | REG_DEF0_USE12 | SETS_CCODES,

552

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

553

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

554

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

555

kFmtShift, -1, -1,

556

IS_QUAD_OP | REG_DEF0_USE12 | USES_CCODES | SETS_CCODES,

557

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

558

ENCODING_MAP(kThumb2CmpRR, 0xebb00f00,

559

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

560

kFmtUnused, -1, -1,

561

IS_TERTIARY_OP | REG_USE01 | SETS_CCODES,

562

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

563

ENCODING_MAP(kThumb2SubRRI12, 0xf2a00000,

564

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

565

kFmtUnused, -1, -1,

566

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

567

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

buzbee

58f9274

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

[diff] [blame]

568

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

569

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

buzbee

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

[diff] [blame]

570

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

571

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

572

ENCODING_MAP(kThumb2Sel, 0xfaa0f080,

573

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

574

kFmtUnused, -1, -1,

575

IS_TERTIARY_OP | REG_DEF0_USE12 | USES_CCODES,

576

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

577

ENCODING_MAP(kThumb2Ubfx, 0xf3c00000,

578

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

579

kFmtBWidth, 4, 0, IS_QUAD_OP | REG_DEF0_USE1,

580

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

581

ENCODING_MAP(kThumb2Sbfx, 0xf3400000,

582

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

583

kFmtBWidth, 4, 0, IS_QUAD_OP | REG_DEF0_USE1,

584

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

585

ENCODING_MAP(kThumb2LdrRRR, 0xf8500000,

586

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

587

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

588

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

589

ENCODING_MAP(kThumb2LdrhRRR, 0xf8300000,

590

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

591

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

592

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

593

ENCODING_MAP(kThumb2LdrshRRR, 0xf9300000,

594

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

595

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

596

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

597

ENCODING_MAP(kThumb2LdrbRRR, 0xf8100000,

598

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

599

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

600

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

601

ENCODING_MAP(kThumb2LdrsbRRR, 0xf9100000,

602

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

603

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

604

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

605

ENCODING_MAP(kThumb2StrRRR, 0xf8400000,

606

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

607

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

608

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

609

ENCODING_MAP(kThumb2StrhRRR, 0xf8200000,

610

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

611

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

612

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

613

ENCODING_MAP(kThumb2StrbRRR, 0xf8000000,

614

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

615

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

616

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

617

ENCODING_MAP(kThumb2LdrhRRI12, 0xf8b00000,

618

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

619

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

620

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

621

ENCODING_MAP(kThumb2LdrshRRI12, 0xf9b00000,

622

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

623

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

624

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

625

ENCODING_MAP(kThumb2LdrbRRI12, 0xf8900000,

626

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

627

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

628

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

629

ENCODING_MAP(kThumb2LdrsbRRI12, 0xf9900000,

630

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

631

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

632

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

633

ENCODING_MAP(kThumb2StrhRRI12, 0xf8a00000,

634

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

635

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

636

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

637

ENCODING_MAP(kThumb2StrbRRI12, 0xf8800000,

638

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

639

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

640

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

641

ENCODING_MAP(kThumb2Pop, 0xe8bd0000,

642

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

643

kFmtUnused, -1, -1,

644

IS_UNARY_OP | REG_DEF_SP | REG_USE_SP | REG_DEF_LIST0

645

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

646

ENCODING_MAP(kThumb2Push, 0xe92d0000,

647

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

648

kFmtUnused, -1, -1,

649

IS_UNARY_OP | REG_DEF_SP | REG_USE_SP | REG_USE_LIST0

650

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

651

ENCODING_MAP(kThumb2CmpRI8, 0xf1b00f00,

652

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

653

kFmtUnused, -1, -1,

654

IS_BINARY_OP | REG_USE0 | SETS_CCODES,

655

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

656

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

657

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

658

kFmtShift, -1, -1,

659

IS_QUAD_OP | REG_DEF0_USE12 | SETS_CCODES,

660

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

661

ENCODING_MAP(kThumb2AndRRR, 0xea000000,

662

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

663

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

664

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

665

ENCODING_MAP(kThumb2BicRRR, 0xea200000,

666

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

667

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

668

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

669

ENCODING_MAP(kThumb2CmnRR, 0xeb000000,

670

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

671

kFmtUnused, -1, -1,

672

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

673

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

674

ENCODING_MAP(kThumb2EorRRR, 0xea800000,

675

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

676

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

677

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

678

ENCODING_MAP(kThumb2MulRRR, 0xfb00f000,

679

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

680

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

681

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

682

ENCODING_MAP(kThumb2MnvRR, 0xea6f0000,

683

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

684

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

685

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

686

ENCODING_MAP(kThumb2RsubRRI8, 0xf1d00000,

687

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

688

kFmtUnused, -1, -1,

689

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

690

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

691

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

692

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

693

kFmtUnused, -1, -1,

694

IS_BINARY_OP | REG_DEF0_USE1 | SETS_CCODES,

695

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

696

ENCODING_MAP(kThumb2OrrRRR, 0xea400000,

697

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

698

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

699

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

700

ENCODING_MAP(kThumb2TstRR, 0xea100f00,

701

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

702

kFmtUnused, -1, -1,

703

IS_TERTIARY_OP | REG_USE01 | SETS_CCODES,

704

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

705

ENCODING_MAP(kThumb2LslRRR, 0xfa00f000,

706

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

707

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

708

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

709

ENCODING_MAP(kThumb2LsrRRR, 0xfa20f000,

710

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

711

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

712

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

713

ENCODING_MAP(kThumb2AsrRRR, 0xfa40f000,

714

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

715

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

716

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

717

ENCODING_MAP(kThumb2RorRRR, 0xfa60f000,

718

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

719

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

720

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

721

ENCODING_MAP(kThumb2LslRRI5, 0xea4f0000,

722

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

723

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

724

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

725

ENCODING_MAP(kThumb2LsrRRI5, 0xea4f0010,

726

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

727

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

728

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

729

ENCODING_MAP(kThumb2AsrRRI5, 0xea4f0020,

730

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

731

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

732

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

733

ENCODING_MAP(kThumb2RorRRI5, 0xea4f0030,

734

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

735

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

736

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

737

ENCODING_MAP(kThumb2BicRRI8, 0xf0200000,

738

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

739

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

740

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

741

ENCODING_MAP(kThumb2AndRRI8, 0xf0000000,

742

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

743

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

744

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

745

ENCODING_MAP(kThumb2OrrRRI8, 0xf0400000,

746

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

747

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

748

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

749

ENCODING_MAP(kThumb2EorRRI8, 0xf0800000,

750

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

751

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

752

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

753

ENCODING_MAP(kThumb2AddRRI8, 0xf1100000,

754

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

755

kFmtUnused, -1, -1,

756

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

757

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

758

ENCODING_MAP(kThumb2AdcRRI8, 0xf1500000,

759

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

760

kFmtUnused, -1, -1,

761

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES | USES_CCODES,

762

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

763

ENCODING_MAP(kThumb2SubRRI8, 0xf1b00000,

764

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

765

kFmtUnused, -1, -1,

766

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

767

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

768

ENCODING_MAP(kThumb2SbcRRI8, 0xf1700000,

769

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

770

kFmtUnused, -1, -1,

771

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES | USES_CCODES,

772

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

773

ENCODING_MAP(kThumb2It, 0xbf00,

774

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

775

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

776

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

777

ENCODING_MAP(kThumb2Fmstat, 0xeef1fa10,

778

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

779

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

780

"fmstat", "", 2),

781

ENCODING_MAP(kThumb2Vcmpd, 0xeeb40b40,

782

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

783

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

784

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

785

ENCODING_MAP(kThumb2Vcmps, 0xeeb40a40,

786

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

787

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

788

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

789

ENCODING_MAP(kThumb2LdrPcRel12, 0xf8df0000,

790

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

791

kFmtUnused, -1, -1,

792

IS_TERTIARY_OP | REG_DEF0 | REG_USE_PC | IS_LOAD,

793

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

794

ENCODING_MAP(kThumb2BCond, 0xf0008000,

795

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

796

kFmtUnused, -1, -1,

797

IS_BINARY_OP | IS_BRANCH | USES_CCODES,

798

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

799

ENCODING_MAP(kThumb2Vmovd_RR, 0xeeb00b40,

800

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

801

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

802

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

803

ENCODING_MAP(kThumb2Vmovs_RR, 0xeeb00a40,

804

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

805

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

806

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

807

ENCODING_MAP(kThumb2Fmrs, 0xee100a10,

808

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

809

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

810

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

811

ENCODING_MAP(kThumb2Fmsr, 0xee000a10,

812

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

813

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

814

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

815

ENCODING_MAP(kThumb2Fmrrd, 0xec500b10,

816

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

817

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

818

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

819

ENCODING_MAP(kThumb2Fmdrr, 0xec400b10,

820

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

821

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

822

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

823

ENCODING_MAP(kThumb2Vabsd, 0xeeb00bc0,

824

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

825

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

826

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

827

ENCODING_MAP(kThumb2Vabss, 0xeeb00ac0,

828

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

829

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

830

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

831

ENCODING_MAP(kThumb2Vnegd, 0xeeb10b40,

832

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

833

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

834

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

835

ENCODING_MAP(kThumb2Vnegs, 0xeeb10a40,

836

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

837

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

838

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

839

ENCODING_MAP(kThumb2Vmovs_IMM8, 0xeeb00a00,

840

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

841

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

842

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

843

ENCODING_MAP(kThumb2Vmovd_IMM8, 0xeeb00b00,

844

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

845

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

846

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

847

ENCODING_MAP(kThumb2Mla, 0xfb000000,

848

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

849

kFmtBitBlt, 15, 12,

850

IS_QUAD_OP | REG_DEF0 | REG_USE1 | REG_USE2 | REG_USE3,

851

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

852

ENCODING_MAP(kThumb2Umull, 0xfba00000,

853

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

854

kFmtBitBlt, 3, 0,

855

IS_QUAD_OP | REG_DEF0 | REG_DEF1 | REG_USE2 | REG_USE3,

856

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

857

ENCODING_MAP(kThumb2Ldrex, 0xe8500f00,

858

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

859

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

860

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

861

ENCODING_MAP(kThumb2Strex, 0xe8400000,

862

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

863

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

864

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

865

ENCODING_MAP(kThumb2Clrex, 0xf3bf8f2f,

866

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

867

kFmtUnused, -1, -1, NO_OPERAND,

868

"clrex", "", 2),

869

ENCODING_MAP(kThumb2Bfi, 0xf3600000,

870

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

871

kFmtBitBlt, 4, 0, IS_QUAD_OP | REG_DEF0_USE1,

872

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

873

ENCODING_MAP(kThumb2Bfc, 0xf36f0000,

874

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

875

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

876

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

877

ENCODING_MAP(kThumb2Dmb, 0xf3bf8f50,

878

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

879

kFmtUnused, -1, -1, IS_UNARY_OP,

880

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

881

ENCODING_MAP(kThumb2LdrPcReln12, 0xf85f0000,

882

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

883

kFmtUnused, -1, -1,

884

IS_BINARY_OP | REG_DEF0 | REG_USE_PC | IS_LOAD,

885

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

886

ENCODING_MAP(kThumb2Stm, 0xe9000000,

887

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

888

kFmtUnused, -1, -1,

889

IS_BINARY_OP | REG_USE0 | REG_USE_LIST1 | IS_STORE,

890

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

891

ENCODING_MAP(kThumbUndefined, 0xde00,

892

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

893

kFmtUnused, -1, -1, NO_OPERAND,

894

"undefined", "", 1),

895

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

896

ENCODING_MAP(kThumb2VPopCS, 0xecbd8a00,

897

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

898

kFmtUnused, -1, -1,

899

IS_UNARY_OP | REG_DEF_SP | REG_USE_SP | REG_DEF_FPCS_LIST0

900

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

901

ENCODING_MAP(kThumb2VPushCS, 0xed2d8a00,

902

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

903

kFmtUnused, -1, -1,

904

IS_UNARY_OP | REG_DEF_SP | REG_USE_SP | REG_USE_FPCS_LIST0

905

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

906

ENCODING_MAP(kThumb2Vldms, 0xec900a00,

907

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

908

kFmtUnused, -1, -1,

909

IS_TERTIARY_OP | REG_USE0 | REG_DEF_FPCS_LIST2

910

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

911

ENCODING_MAP(kThumb2Vstms, 0xec800a00,

912

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

913

kFmtUnused, -1, -1,

914

IS_TERTIARY_OP | REG_USE0 | REG_USE_FPCS_LIST2

915

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

916

ENCODING_MAP(kThumb2BUncond, 0xf0009000,

917

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

918

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

919

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

920

ENCODING_MAP(kThumb2MovImm16H, 0xf2c00000,

921

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

922

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

923

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

924

ENCODING_MAP(kThumb2AddPCR, 0x4487,

925

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

926

kFmtUnused, -1, -1,

927

IS_UNARY_OP | REG_USE0 | IS_BRANCH,

928

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

buzbee

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

[diff] [blame]

929

ENCODING_MAP(kThumb2Adr, 0xf20f0000,

buzbee

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

[diff] [blame]

930

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

931

kFmtUnused, -1, -1,

932

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

933

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

934

ENCODING_MAP(kThumb2MovImm16LST, 0xf2400000,

935

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

936

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

937

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

938

ENCODING_MAP(kThumb2MovImm16HST, 0xf2c00000,

939

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

940

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

941

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

942

ENCODING_MAP(kThumb2LdmiaWB, 0xe8b00000,

943

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

944

kFmtUnused, -1, -1,

945

IS_BINARY_OP | REG_DEF0_USE0 | REG_DEF_LIST1 | IS_LOAD,

946

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

947

ENCODING_MAP(kThumb2SubsRRI12, 0xf1b00000,

948

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

949

kFmtUnused, -1, -1,

950

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

951

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

buzbee

58f9274

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

[diff] [blame]

952

ENCODING_MAP(kThumb2OrrRRRs, 0xea500000,

953

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

954

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

955

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

buzbee

e707080

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

[diff] [blame]

956

ENCODING_MAP(kThumb2Push1, 0xf84d0d04,

957

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

958

kFmtUnused, -1, -1,

959

IS_UNARY_OP | REG_DEF_SP | REG_USE_SP | REG_USE0

960

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

961

ENCODING_MAP(kThumb2Pop1, 0xf85d0b04,

962

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

963

kFmtUnused, -1, -1,

964

IS_UNARY_OP | REG_DEF_SP | REG_USE_SP | REG_DEF0

965

| 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

971

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

972

* generate unnecessary stall cycles.

973

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

974

*/

975

#define PADDING_MOV_R5_R5 0x1C2D

976

buzbee

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

[diff] [blame]

977

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

buzbee

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

[diff] [blame]

978

buf.push_back( data & 0xffff);

buzbee

9e0f9b0

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

[diff] [blame]

979

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

buzbee

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

[diff] [blame]

980

}

981

982

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

983

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

buf.push_back(0);

}

buzbee

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

[diff] [blame]

987

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

buzbee

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

[diff] [blame]

988

STATIC void installLiteralPools(CompilationUnit* cUnit)

buzbee

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

[diff] [blame]

989

{

buzbee

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

[diff] [blame]

990

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

buzbee

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

[diff] [blame]

991

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

992

while (dataLIR) {

buzbee

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

[diff] [blame]

993

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

buzbee

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

[diff] [blame]

994

dataLIR = NEXT_LIR(dataLIR);

}

}

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

buzbee

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

[diff] [blame]

999

STATIC void installSwitchTables(CompilationUnit* cUnit)

buzbee

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

[diff] [blame]

1000

{

1001

GrowableListIterator iterator;

1002

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

1003

while (true) {

1004

SwitchTable* tabRec = (SwitchTable *) oatGrowableListIteratorNext(

1005

&iterator);

1006

if (tabRec == NULL) break;

buzbee

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

[diff] [blame]

1007

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

buzbee

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

[diff] [blame]

1008

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

1009

if (cUnit->printMe) {

buzbee

9e0f9b0

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

[diff] [blame]

1010

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

buzbee

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

[diff] [blame]

1011

}

1012

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

1013

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

1014

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

1015

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

1016

if (cUnit->printMe) {

1017

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

1018

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

1019

std::hex << disp;

1020

}

buzbee

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

[diff] [blame]

1021

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

1022

pushWord(cUnit->codeBuffer,

1023

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

buzbee

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

[diff] [blame]

1024

}

1025

} else {

buzbee

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

[diff] [blame]

1026

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

buzbee

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

[diff] [blame]

1027

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

1028

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

1029

if (cUnit->printMe) {

1030

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

1031

std::hex << disp;

1032

}

buzbee

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

[diff] [blame]

1033

pushWord(cUnit->codeBuffer,

1034

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]

1041

STATIC void installFillArrayData(CompilationUnit* cUnit)

buzbee

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

[diff] [blame]

1042

{

1043

GrowableListIterator iterator;

1044

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

1045

while (true) {

1046

FillArrayData *tabRec = (FillArrayData *) oatGrowableListIteratorNext(

1047

&iterator);

1048

if (tabRec == NULL) break;

buzbee

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

[diff] [blame]

1049

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

buzbee

58f9274

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

[diff] [blame]

1050

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

buzbee

e6d6196

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

[diff] [blame]

1051

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

1052

}

buzbee

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

[diff] [blame]

}

}

/*

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

1058

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

1059

* instruction.

1060

*/

buzbee

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

[diff] [blame]

1061

STATIC AssemblerStatus assembleInstructions(CompilationUnit* cUnit,

buzbee

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

[diff] [blame]

1062

intptr_t startAddr)

1063

{

buzbee

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

[diff] [blame]

1064

ArmLIR* lir;

1065

AssemblerStatus res = kSuccess; // Assume success

1066

1067

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

1068

if (lir->opcode < 0) {

1069

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

1070

/* 1 means padding is needed */

1071

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

buzbee

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

[diff] [blame]

1072

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

1083

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

1084

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

1085

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

1086

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

1087

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

1088

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

1089

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

1090

* is an iterative process.

1091

*/

1092

1093

if (lir->opcode == kThumbLdrPcRel ||

1094

lir->opcode == kThumb2LdrPcRel12 ||

1095

lir->opcode == kThumbAddPcRel ||

buzbee

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

[diff] [blame]

1096

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

buzbee

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

[diff] [blame]

1097

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

1098

/*

1099

* PC-relative loads are mostly used to load immediates

1100

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

1101

* However, if the load displacement exceeds the limit,

1102

* we revert to a 2-instruction materialization sequence.

1103

*/

1104

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

1105

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

1106

intptr_t target = lirTarget->generic.offset;

1107

int delta = target - pc;

1108

if (delta & 0x3) {

1109

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

1110

}

1111

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

1112

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

1113

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

1114

// Shouldn't happen in current codegen.

1115

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

1116

}

1117

// Now, check for the two difficult cases

buzbee

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

[diff] [blame]

1118

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

1119

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

1120

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

buzbee

4965b66

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

[diff] [blame^]

1121

/*

1122

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

1123

* vldrs/vldrd we include REG_DEF_LR in the resource

1124

* masks for these instructions.

1125

*/

buzbee

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

[diff] [blame]

1126

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

1127

lir->operands[0] : rLR;

1128

1129

// Add new Adr to generate the address

1130

ArmLIR *newAdr =

buzbee

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

[diff] [blame]

1131

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

buzbee

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

[diff] [blame]

1132

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

1133

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

1134

newAdr->opcode = kThumb2Adr;

1135

newAdr->operands[0] = baseReg;

1136

oatSetupResourceMasks(newAdr);

1137

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

1138

1139

// Convert to normal load

1140

if (lir->opcode == kThumb2LdrPcRel12) {

1141

lir->opcode = kThumb2LdrRRI12;

buzbee

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

[diff] [blame]

1142

}

buzbee

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

[diff] [blame]

1143

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

1144

lir->operands[1] = baseReg;

1145

lir->operands[2] = 0;

1146

oatSetupResourceMasks(lir);

buzbee

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

[diff] [blame]

1147

res = kRetryAll;

1148

} else {

buzbee

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

[diff] [blame]

1149

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

1150

(lir->opcode == kThumb2Vldrd)) {

buzbee

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

[diff] [blame]

1151

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

1152

} else {

1153

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

delta : delta >> 2;

}

}

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

1158

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

1159

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

1160

intptr_t target = targetLIR->generic.offset;

1161

int delta = target - pc;

1162

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

1163

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

1164

ArmLIR *newInst =

1165

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

1166

/* Make new branch instruction and insert after */

1167

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

1168

newInst->opcode = kThumbBCond;

1169

newInst->operands[0] = 0;

1170

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

1171

kArmCondEq : kArmCondNe;

1172

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

1173

oatSetupResourceMasks(newInst);

1174

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

1175

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

1176

lir->opcode = kThumbCmpRI8;

1177

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

1178

lir->operands[1] = 0;

1179

lir->generic.target = 0;

1180

oatSetupResourceMasks(lir);

1181

res = kRetryAll;

1182

} else {

1183

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

1184

}

buzbee

e707080

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

[diff] [blame]

1185

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

1186

lir->opcode == kThumb2Pop) {

1187

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

1188

/*

1189

* The standard push/pop multiple instruction

1190

* requires at least two registers in the list.

1191

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

1192

* encoding.

1193

*/

1194

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

1195

? kThumb2Push1 : kThumb2Pop1;

1196

int reg = 0;

1197

while (lir->operands[0]) {

1198

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

break;

} else {

reg++;

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

1203

}

1204

}

1205

lir->operands[0] = reg;

1206

oatSetupResourceMasks(lir);

1207

res = kRetryAll;

1208

}

buzbee

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

[diff] [blame]

1209

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

1210

lir->opcode == kThumb2BCond) {

1211

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

buzbee

7b1b86d

2011-08-26 18:59:10 -0700

[diff] [blame]

1212

int delta = 0;

buzbee

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

[diff] [blame]

1213

DCHECK(targetLIR);

buzbee

5ade1d2

2011-09-09 14:44:52 -0700

[diff] [blame]

1214

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

1215

intptr_t target = targetLIR->generic.offset;

1216

delta = target - pc;

1217

if ((lir->opcode == kThumbBCond) && (delta > 254 || delta < -256)) {

1218

lir->opcode = kThumb2BCond;

1219

oatSetupResourceMasks(lir);

1220

res = kRetryAll;

buzbee

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

[diff] [blame]

1221

}

1222

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

1223

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

1224

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

1225

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

1226

intptr_t target = targetLIR->generic.offset;

1227

int delta = target - pc;

1228

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

1229

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

1230

lir->flags.isNop = true;

1231

res = kRetryAll;

1232

}

1233

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

1234

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

1235

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

1236

intptr_t target = targetLIR->generic.offset;

1237

int delta = target - pc;

1238

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

1239

// Convert to Thumb2BCond w/ kArmCondAl

1240

lir->opcode = kThumb2BUncond;

1241

lir->operands[0] = 0;

1242

oatSetupResourceMasks(lir);

1243

res = kRetryAll;

1244

}

1245

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

1246

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

1247

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

1248

lir->flags.isNop = true;

1249

res = kRetryAll;

1250

}

1251

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

buzbee

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

[diff] [blame]

1252

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

buzbee

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

[diff] [blame]

1253

/* curPC is Thumb */

1254

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

1255

intptr_t target = lir->operands[1];

1256

1257

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

if (curPC & 0x2) {

target |= 0x2;

}

int delta = target - curPC;

buzbee

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

[diff] [blame]

1262

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

buzbee

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

[diff] [blame]

1263

1264

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

1265

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

1266

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

buzbee

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

[diff] [blame]

1267

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

buzbee

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

[diff] [blame]

1268

/* Both curPC and target are Thumb */

1269

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

1270

intptr_t target = lir->operands[1];

1271

1272

int delta = target - curPC;

buzbee

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

[diff] [blame]

1273

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

buzbee

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

[diff] [blame]

1274

1275

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

1276

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

buzbee

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

[diff] [blame]

1277

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

buzbee

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

[diff] [blame]

1278

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

buzbee

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

[diff] [blame]

1279

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

1280

int targetDisp = tabRec ? tabRec->offset : target->generic.offset;

1281

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

buzbee

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

[diff] [blame]

1282

if (disp < 4096) {

1283

lir->operands[1] = disp;

1284

} else {

buzbee

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

[diff] [blame]

1285

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

buzbee

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

[diff] [blame]

1286

ArmLIR *newMov16L =

1287

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

1288

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

buzbee

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

[diff] [blame]

1289

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

buzbee

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

[diff] [blame]

1290

newMov16L->opcode = kThumb2MovImm16LST;

1291

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

1292

newMov16L->operands[2] = (intptr_t)lir;

1293

newMov16L->operands[3] = (intptr_t)tabRec;

1294

oatSetupResourceMasks(newMov16L);

1295

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

1296

ArmLIR *newMov16H =

1297

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

1298

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

buzbee

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

[diff] [blame]

1299

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

buzbee

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

[diff] [blame]

1300

newMov16H->opcode = kThumb2MovImm16HST;

1301

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

1302

newMov16H->operands[2] = (intptr_t)lir;

1303

newMov16H->operands[3] = (intptr_t)tabRec;

1304

oatSetupResourceMasks(newMov16H);

1305

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

1306

lir->opcode = kThumb2AddRRR;

1307

lir->operands[1] = rPC;

1308

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

1309

oatSetupResourceMasks(lir);

1310

res = kRetryAll;

1311

}

1312

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

1313

// operands[1] should hold disp, [2] has add, [3] has tabRec

1314

ArmLIR *addPCInst = (ArmLIR*)lir->operands[2];

1315

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

buzbee

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

[diff] [blame]

1316

// If tabRec is null, this is a literal load - use generic.target

1317

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

1318

int targetDisp = tabRec ? tabRec->offset : target->generic.offset;

1319

lir->operands[1] = (targetDisp -

buzbee

3b80347

2011-09-18 13:48:32 -0700

[diff] [blame]

1320

(addPCInst->generic.offset + 4)) & 0xffff;

buzbee

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

[diff] [blame]

1321

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

1322

// operands[1] should hold disp, [2] has add, [3] has tabRec

1323

ArmLIR *addPCInst = (ArmLIR*)lir->operands[2];

1324

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

buzbee

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

[diff] [blame]

1325

// If tabRec is null, this is a literal load - use generic.target

1326

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

1327

int targetDisp = tabRec ? tabRec->offset : target->generic.offset;

1328

lir->operands[1] = ((targetDisp -

buzbee

3b80347

2011-09-18 13:48:32 -0700

[diff] [blame]

1329

(addPCInst->generic.offset + 4)) >> 16) & 0xffff;

buzbee

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

[diff] [blame]

1330

}

1331

ArmEncodingMap *encoder = &EncodingMap[lir->opcode];

1332

u4 bits = encoder->skeleton;

1333

int i;

1334

for (i = 0; i < 4; i++) {

1335

u4 operand;

1336

u4 value;

1337

operand = lir->operands[i];

1338

switch(encoder->fieldLoc[i].kind) {

case kFmtUnused:

break;

case kFmtFPImm:

value = ((operand & 0xF0) >> 4) << encoder->fieldLoc[i].end;

1343

value |= (operand & 0x0F) << encoder->fieldLoc[i].start;

bits |= value;

break;

case kFmtBrOffset:

value = ((operand & 0x80000) >> 19) << 26;

1348

value |= ((operand & 0x40000) >> 18) << 11;

1349

value |= ((operand & 0x20000) >> 17) << 13;

1350

value |= ((operand & 0x1f800) >> 11) << 16;

1351

value |= (operand & 0x007ff);

bits |= value;

break;

case kFmtShift5:

value = ((operand & 0x1c) >> 2) << 12;

1356

value |= (operand & 0x03) << 6;

bits |= value;

break;

case kFmtShift:

value = ((operand & 0x70) >> 4) << 12;

1361

value |= (operand & 0x0f) << 4;

bits |= value;

break;

case kFmtBWidth:

value = operand - 1;

bits |= value;

break;

case kFmtLsb:

value = ((operand & 0x1c) >> 2) << 12;

1370

value |= (operand & 0x03) << 6;

bits |= value;

break;

case kFmtImm6:

value = ((operand & 0x20) >> 5) << 9;

1375

value |= (operand & 0x1f) << 3;

bits |= value;

break;

case kFmtBitBlt:

value = (operand << encoder->fieldLoc[i].start) &

1380

((1 << (encoder->fieldLoc[i].end + 1)) - 1);

1381

bits |= value;

1382

break;

1383

case kFmtDfp: {

buzbee

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

[diff] [blame]

1384

DCHECK(DOUBLEREG(operand));

1385

DCHECK((operand & 0x1) == 0);

buzbee

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

[diff] [blame]

1386

int regName = (operand & FP_REG_MASK) >> 1;

1387

/* Snag the 1-bit slice and position it */

1388

value = ((regName & 0x10) >> 4) <<

1389

encoder->fieldLoc[i].end;

1390

/* Extract and position the 4-bit slice */

1391

value |= (regName & 0x0f) <<

1392

encoder->fieldLoc[i].start;

bits |= value;

break;

}

case kFmtSfp:

buzbee

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

[diff] [blame]

1397

DCHECK(SINGLEREG(operand));

buzbee

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

[diff] [blame]

1398

/* Snag the 1-bit slice and position it */

1399

value = (operand & 0x1) <<

1400

encoder->fieldLoc[i].end;

1401

/* Extract and position the 4-bit slice */

1402

value |= ((operand & 0x1e) >> 1) <<

1403

encoder->fieldLoc[i].start;

bits |= value;

break;

case kFmtImm12:

case kFmtModImm:

value = ((operand & 0x800) >> 11) << 26;

1409

value |= ((operand & 0x700) >> 8) << 12;

1410

value |= operand & 0x0ff;

bits |= value;

break;

case kFmtImm16:

value = ((operand & 0x0800) >> 11) << 26;

1415

value |= ((operand & 0xf000) >> 12) << 16;

1416

value |= ((operand & 0x0700) >> 8) << 12;

1417

value |= operand & 0x0ff;

bits |= value;

break;

case kFmtOff24: {

u4 signbit = (operand >> 31) & 0x1;

1422

u4 i1 = (operand >> 22) & 0x1;

1423

u4 i2 = (operand >> 21) & 0x1;

1424

u4 imm10 = (operand >> 11) & 0x03ff;

1425

u4 imm11 = operand & 0x07ff;

1426

u4 j1 = (i1 ^ signbit) ? 0 : 1;

1427

u4 j2 = (i2 ^ signbit) ? 0 : 1;

1428

value = (signbit << 26) | (j1 << 13) | (j2 << 11) |

1429

(imm10 << 16) | imm11;

bits |= value;

}

break;

default:

buzbee

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

[diff] [blame]

1434

LOG(FATAL) << "Bad fmt:" << (int)encoder->fieldLoc[i].kind;

buzbee

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

[diff] [blame]

1435

}

1436

}

1437

if (encoder->size == 2) {

buzbee

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

[diff] [blame]

1438

cUnit->codeBuffer.push_back((bits >> 16) & 0xffff);

buzbee

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

[diff] [blame]

1439

}

buzbee

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

[diff] [blame]

1440

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]

1445

STATIC int assignLiteralOffsetCommon(LIR* lir, int offset)

buzbee

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

[diff] [blame]

1446

{

1447

for (;lir != NULL; lir = lir->next) {

1448

lir->offset = offset;

offset += 4;

}

return offset;

}

buzbee

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

[diff] [blame]

1454

STATIC void createMappingTable(CompilationUnit* cUnit)

buzbee

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

[diff] [blame]

1455

{

1456

ArmLIR* armLIR;

1457

int currentDalvikOffset = -1;

buzbee

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

[diff] [blame]

1458

1459

for (armLIR = (ArmLIR *) cUnit->firstLIRInsn;

1460

armLIR;

1461

armLIR = NEXT_LIR(armLIR)) {

1462

if ((armLIR->opcode >= 0) && !armLIR->flags.isNop &&

1463

(currentDalvikOffset != armLIR->generic.dalvikOffset)) {

1464

// Changed - need to emit a record

buzbee

4ef7652

2011-09-08 10:00:32 -0700

[diff] [blame]

1465

cUnit->mappingTable.push_back(armLIR->generic.offset);

1466

cUnit->mappingTable.push_back(armLIR->generic.dalvikOffset);

buzbee

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

[diff] [blame]

1467

currentDalvikOffset = armLIR->generic.dalvikOffset;

1468

}

1469

}

buzbee

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

[diff] [blame]

1470

}

1471

1472

/* Determine the offset of each literal field */

buzbee

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

[diff] [blame]

1473

STATIC int assignLiteralOffset(CompilationUnit* cUnit, int offset)

buzbee

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

[diff] [blame]

1474

{

1475

offset = assignLiteralOffsetCommon(cUnit->literalList, offset);

return offset;

}

buzbee

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

[diff] [blame]

1479

STATIC int assignSwitchTablesOffset(CompilationUnit* cUnit, int offset)

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1480

{

1481

GrowableListIterator iterator;

1482

oatGrowableListIteratorInit(&cUnit->switchTables, &iterator);

1483

while (true) {

1484

SwitchTable *tabRec = (SwitchTable *) oatGrowableListIteratorNext(

1485

&iterator);

1486

if (tabRec == NULL) break;

1487

tabRec->offset = offset;

1488

if (tabRec->table[0] == kSparseSwitchSignature) {

1489

offset += tabRec->table[1] * (sizeof(int) * 2);

1490

} else {

buzbee

2011-09-23 17:34:19 -0700

[diff] [blame]

1491

DCHECK_EQ(tabRec->table[0], kPackedSwitchSignature);

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1492

offset += tabRec->table[1] * sizeof(int);

}

}

return offset;

}

buzbee

2011-09-23 17:34:19 -0700

[diff] [blame]

1498

STATIC int assignFillArrayDataOffset(CompilationUnit* cUnit, int offset)

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1499

{

1500

GrowableListIterator iterator;

1501

oatGrowableListIteratorInit(&cUnit->fillArrayData, &iterator);

1502

while (true) {

1503

FillArrayData *tabRec = (FillArrayData *) oatGrowableListIteratorNext(

1504

&iterator);

1505

if (tabRec == NULL) break;

1506

tabRec->offset = offset;

1507

offset += tabRec->size;

1508

// word align

1509

offset = (offset + 3) & ~3;

}

return offset;

}

/*

* Walk the compilation unit and assign offsets to instructions

1516

* and literals and compute the total size of the compiled unit.

1517

*/

1518

void assignOffsets(CompilationUnit* cUnit)

{

ArmLIR* armLIR;

int offset = 0;

for (armLIR = (ArmLIR *) cUnit->firstLIRInsn;

1524

armLIR;

1525

armLIR = NEXT_LIR(armLIR)) {

1526

armLIR->generic.offset = offset;

1527

if (armLIR->opcode >= 0 && !armLIR->flags.isNop) {

1528

armLIR->flags.size = EncodingMap[armLIR->opcode].size * 2;

1529

offset += armLIR->flags.size;

1530

} else if (armLIR->opcode == kArmPseudoPseudoAlign4) {

1531

if (offset & 0x2) {

1532

offset += 2;

1533

armLIR->operands[0] = 1;

1534

} else {

1535

armLIR->operands[0] = 0;

1536

}

1537

}

1538

/* Pseudo opcodes don't consume space */

1539

}

1540

1541

/* Const values have to be word aligned */

1542

offset = (offset + 3) & ~3;

1543

1544

/* Set up offsets for literals */

1545

cUnit->dataOffset = offset;

1546

1547

offset = assignLiteralOffset(cUnit, offset);

1548

1549

offset = assignSwitchTablesOffset(cUnit, offset);

1550

1551

offset = assignFillArrayDataOffset(cUnit, offset);

1552

1553

cUnit->totalSize = offset;

1554

}

1555

/*

1556

* Go over each instruction in the list and calculate the offset from the top

1557

* before sending them off to the assembler. If out-of-range branch distance is

1558

* seen rearrange the instructions a bit to correct it.

1559

*/

1560

void oatAssembleLIR(CompilationUnit* cUnit)

1561

{

1562

assignOffsets(cUnit);

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

1563

/*

1564

* Assemble here. Note that we generate code with optimistic assumptions

1565

* and if found now to work, we'll have to redo the sequence and retry.

*/

while (true) {

AssemblerStatus res = assembleInstructions(cUnit, NULL);

1570

if (res == kSuccess) {

1571

break;

1572

} else {

1573

cUnit->assemblerRetries++;

1574

if (cUnit->assemblerRetries > MAX_ASSEMBLER_RETRIES) {

1575

LOG(FATAL) << "Assembler error - too many retries";

1576

}

1577

// Redo offsets and try again

1578

assignOffsets(cUnit);

buzbee

2011-08-20 17:38:58 -0700

[diff] [blame]

1579

cUnit->codeBuffer.clear();

buzbee

2011-08-17 17:51:35 -0700

[diff] [blame]

}

}

// Install literals

installLiteralPools(cUnit);

1585

1586

// Install switch tables

1587

installSwitchTables(cUnit);

1588

1589

// Install fill array data

1590

installFillArrayData(cUnit);

1591

1592

/*

1593

* Create the mapping table

1594

*/

buzbee

4ef7652

2011-09-08 10:00:32 -0700

[diff] [blame]

1595

createMappingTable(cUnit);

buzbee