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

buzbee

67bf885

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 */

//#define TESTMODE

#ifdef TESTMODE

#include <cutils/ashmem.h> /* for oat testing */

#include <unistd.h>

#endif

#define MAX_ASSEMBLER_RETRIES 50

30

31

/*

32

* opcode: ArmOpcode enum

33

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

34

* k0: key to applying ds/de

35

* ds: dest start bit position

36

* de: dest end bit position

37

* k1: key to applying s1s/s1e

38

* s1s: src1 start bit position

39

* s1e: src1 end bit position

40

* k2: key to applying s2s/s2e

41

* s2s: src2 start bit position

42

* s2e: src2 end bit position

43

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

44

* name: mnemonic name

45

* fmt: for pretty-printing

46

*/

47

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

48

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

49

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

50

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

51

52

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

53

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

* print format.

*

* [p]ositions:

* 0 -> operands[0] (dest)

58

* 1 -> operands[1] (src1)

59

* 2 -> operands[2] (src2)

60

* 3 -> operands[3] (extra)

*

* [f]ormats:

* h -> 4-digit hex

* d -> decimal

* E -> decimal*4

* F -> decimal*2

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

68

* t -> pc-relative target

69

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

70

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

71

* R -> register list

72

* s -> single precision floating point register

73

* S -> double precision floating point register

74

* m -> Thumb2 modified immediate

75

* n -> complimented Thumb2 modified immediate

76

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

77

* b -> 4-digit binary

78

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

79

* H -> operand shift

80

* C -> core register name

81

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

82

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

83

*

84

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

85

*/

86

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

87

ArmEncodingMap EncodingMap[kArmLast] = {

88

ENCODING_MAP(kArm16BitData, 0x0000,

89

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

90

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

91

ENCODING_MAP(kThumbAdcRR, 0x4140,

92

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

93

kFmtUnused, -1, -1,

94

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES | USES_CCODES,

95

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

96

ENCODING_MAP(kThumbAddRRI3, 0x1c00,

97

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

98

kFmtUnused, -1, -1,

99

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

100

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

101

ENCODING_MAP(kThumbAddRI8, 0x3000,

102

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

103

kFmtUnused, -1, -1,

104

IS_BINARY_OP | REG_DEF0_USE0 | SETS_CCODES,

105

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

106

ENCODING_MAP(kThumbAddRRR, 0x1800,

107

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

108

kFmtUnused, -1, -1,

109

IS_TERTIARY_OP | REG_DEF0_USE12 | SETS_CCODES,

110

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

111

ENCODING_MAP(kThumbAddRRLH, 0x4440,

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(kThumbAddRRHL, 0x4480,

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(kThumbAddRRHH, 0x44c0,

120

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

121

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

122

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

123

ENCODING_MAP(kThumbAddPcRel, 0xa000,

124

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

125

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

126

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

127

ENCODING_MAP(kThumbAddSpRel, 0xa800,

128

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

129

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

130

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

131

ENCODING_MAP(kThumbAddSpI7, 0xb000,

132

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

133

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

134

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

135

ENCODING_MAP(kThumbAndRR, 0x4000,

136

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

137

kFmtUnused, -1, -1,

138

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,

139

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

140

ENCODING_MAP(kThumbAsrRRI5, 0x1000,

141

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

142

kFmtUnused, -1, -1,

143

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

144

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

145

ENCODING_MAP(kThumbAsrRR, 0x4100,

146

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

147

kFmtUnused, -1, -1,

148

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,

149

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

150

ENCODING_MAP(kThumbBCond, 0xd000,

151

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

152

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

153

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

154

ENCODING_MAP(kThumbBUncond, 0xe000,

155

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

156

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

157

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

158

ENCODING_MAP(kThumbBicRR, 0x4380,

159

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

160

kFmtUnused, -1, -1,

161

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,

162

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

163

ENCODING_MAP(kThumbBkpt, 0xbe00,

164

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

165

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

166

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

167

ENCODING_MAP(kThumbBlx1, 0xf000,

168

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

169

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

170

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

171

ENCODING_MAP(kThumbBlx2, 0xe800,

172

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

173

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

174

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

175

ENCODING_MAP(kThumbBl1, 0xf000,

176

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

177

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

178

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

179

ENCODING_MAP(kThumbBl2, 0xf800,

180

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

181

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

182

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

183

ENCODING_MAP(kThumbBlxR, 0x4780,

184

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

185

kFmtUnused, -1, -1,

186

IS_UNARY_OP | REG_USE0 | IS_BRANCH | REG_DEF_LR,

187

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

188

ENCODING_MAP(kThumbBx, 0x4700,

189

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

190

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

191

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

192

ENCODING_MAP(kThumbCmnRR, 0x42c0,

193

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

194

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

195

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

196

ENCODING_MAP(kThumbCmpRI8, 0x2800,

197

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

198

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

199

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

200

ENCODING_MAP(kThumbCmpRR, 0x4280,

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(kThumbCmpLH, 0x4540,

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(kThumbCmpHL, 0x4580,

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(kThumbCmpHH, 0x45c0,

213

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

214

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

215

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

216

ENCODING_MAP(kThumbEorRR, 0x4040,

217

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

218

kFmtUnused, -1, -1,

219

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,

220

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

221

ENCODING_MAP(kThumbLdmia, 0xc800,

222

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

223

kFmtUnused, -1, -1,

224

IS_BINARY_OP | REG_DEF0_USE0 | REG_DEF_LIST1 | IS_LOAD,

225

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

226

ENCODING_MAP(kThumbLdrRRI5, 0x6800,

227

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

228

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

229

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

230

ENCODING_MAP(kThumbLdrRRR, 0x5800,

231

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

232

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

233

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

234

ENCODING_MAP(kThumbLdrPcRel, 0x4800,

235

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

236

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

237

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

238

ENCODING_MAP(kThumbLdrSpRel, 0x9800,

239

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

240

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

241

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

242

ENCODING_MAP(kThumbLdrbRRI5, 0x7800,

243

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

244

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

245

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

246

ENCODING_MAP(kThumbLdrbRRR, 0x5c00,

247

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

248

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

249

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

250

ENCODING_MAP(kThumbLdrhRRI5, 0x8800,

251

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

252

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

253

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

254

ENCODING_MAP(kThumbLdrhRRR, 0x5a00,

255

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

256

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

257

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

258

ENCODING_MAP(kThumbLdrsbRRR, 0x5600,

259

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

260

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

261

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

262

ENCODING_MAP(kThumbLdrshRRR, 0x5e00,

263

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

264

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

265

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

266

ENCODING_MAP(kThumbLslRRI5, 0x0000,

267

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

268

kFmtUnused, -1, -1,

269

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

270

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

271

ENCODING_MAP(kThumbLslRR, 0x4080,

272

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

273

kFmtUnused, -1, -1,

274

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,

275

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

276

ENCODING_MAP(kThumbLsrRRI5, 0x0800,

277

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

278

kFmtUnused, -1, -1,

279

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

280

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

281

ENCODING_MAP(kThumbLsrRR, 0x40c0,

282

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

283

kFmtUnused, -1, -1,

284

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,

285

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

286

ENCODING_MAP(kThumbMovImm, 0x2000,

287

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

288

kFmtUnused, -1, -1,

289

IS_BINARY_OP | REG_DEF0 | SETS_CCODES,

290

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

291

ENCODING_MAP(kThumbMovRR, 0x1c00,

292

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

293

kFmtUnused, -1, -1,

294

IS_BINARY_OP | REG_DEF0_USE1 | SETS_CCODES,

295

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

296

ENCODING_MAP(kThumbMovRR_H2H, 0x46c0,

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_H2L, 0x4640,

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(kThumbMovRR_L2H, 0x4680,

305

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

306

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

307

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

308

ENCODING_MAP(kThumbMul, 0x4340,

309

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

310

kFmtUnused, -1, -1,

311

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,

312

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

313

ENCODING_MAP(kThumbMvn, 0x43c0,

314

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

315

kFmtUnused, -1, -1,

316

IS_BINARY_OP | REG_DEF0_USE1 | SETS_CCODES,

317

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

318

ENCODING_MAP(kThumbNeg, 0x4240,

319

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

320

kFmtUnused, -1, -1,

321

IS_BINARY_OP | REG_DEF0_USE1 | SETS_CCODES,

322

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

323

ENCODING_MAP(kThumbOrr, 0x4300,

324

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

325

kFmtUnused, -1, -1,

326

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,

327

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

328

ENCODING_MAP(kThumbPop, 0xbc00,

329

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

330

kFmtUnused, -1, -1,

331

IS_UNARY_OP | REG_DEF_SP | REG_USE_SP | REG_DEF_LIST0

332

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

333

ENCODING_MAP(kThumbPush, 0xb400,

334

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

335

kFmtUnused, -1, -1,

336

IS_UNARY_OP | REG_DEF_SP | REG_USE_SP | REG_USE_LIST0

337

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

338

ENCODING_MAP(kThumbRorRR, 0x41c0,

339

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

340

kFmtUnused, -1, -1,

341

IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,

342

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

343

ENCODING_MAP(kThumbSbc, 0x4180,

344

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

345

kFmtUnused, -1, -1,

346

IS_BINARY_OP | REG_DEF0_USE01 | USES_CCODES | SETS_CCODES,

347

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

348

ENCODING_MAP(kThumbStmia, 0xc000,

349

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

350

kFmtUnused, -1, -1,

351

IS_BINARY_OP | REG_DEF0 | REG_USE0 | REG_USE_LIST1 | IS_STORE,

352

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

353

ENCODING_MAP(kThumbStrRRI5, 0x6000,

354

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

355

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

356

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

357

ENCODING_MAP(kThumbStrRRR, 0x5000,

358

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

359

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

360

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

361

ENCODING_MAP(kThumbStrSpRel, 0x9000,

362

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

363

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

364

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

365

ENCODING_MAP(kThumbStrbRRI5, 0x7000,

366

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

367

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

368

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

369

ENCODING_MAP(kThumbStrbRRR, 0x5400,

370

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

371

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

372

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

373

ENCODING_MAP(kThumbStrhRRI5, 0x8000,

374

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

375

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

376

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

377

ENCODING_MAP(kThumbStrhRRR, 0x5200,

378

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

379

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

380

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

381

ENCODING_MAP(kThumbSubRRI3, 0x1e00,

382

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

383

kFmtUnused, -1, -1,

384

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

385

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

386

ENCODING_MAP(kThumbSubRI8, 0x3800,

387

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

388

kFmtUnused, -1, -1,

389

IS_BINARY_OP | REG_DEF0_USE0 | SETS_CCODES,

390

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

391

ENCODING_MAP(kThumbSubRRR, 0x1a00,

392

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

393

kFmtUnused, -1, -1,

394

IS_TERTIARY_OP | REG_DEF0_USE12 | SETS_CCODES,

395

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

396

ENCODING_MAP(kThumbSubSpI7, 0xb080,

397

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

398

kFmtUnused, -1, -1,

399

IS_UNARY_OP | REG_DEF_SP | REG_USE_SP,

400

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

401

ENCODING_MAP(kThumbSwi, 0xdf00,

402

kFmtBitBlt, 7, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1, kFmtUnused, -1, -1, IS_UNARY_OP | IS_BRANCH,

403

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

404

ENCODING_MAP(kThumbTst, 0x4200,

405

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

406

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

407

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

408

ENCODING_MAP(kThumb2Vldrs, 0xed900a00,

409

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

410

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

411

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

412

ENCODING_MAP(kThumb2Vldrd, 0xed900b00,

413

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

414

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

415

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

416

ENCODING_MAP(kThumb2Vmuls, 0xee200a00,

417

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

418

kFmtUnused, -1, -1,

419

IS_TERTIARY_OP | REG_DEF0_USE12,

420

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

421

ENCODING_MAP(kThumb2Vmuld, 0xee200b00,

422

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

423

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

424

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

425

ENCODING_MAP(kThumb2Vstrs, 0xed800a00,

426

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

427

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

428

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

429

ENCODING_MAP(kThumb2Vstrd, 0xed800b00,

430

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

431

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

432

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

433

ENCODING_MAP(kThumb2Vsubs, 0xee300a40,

434

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

435

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

436

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

437

ENCODING_MAP(kThumb2Vsubd, 0xee300b40,

438

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

439

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

440

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

441

ENCODING_MAP(kThumb2Vadds, 0xee300a00,

442

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

443

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

444

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

445

ENCODING_MAP(kThumb2Vaddd, 0xee300b00,

446

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

447

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

448

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

449

ENCODING_MAP(kThumb2Vdivs, 0xee800a00,

450

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

451

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

452

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

453

ENCODING_MAP(kThumb2Vdivd, 0xee800b00,

454

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

455

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

456

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

457

ENCODING_MAP(kThumb2VcvtIF, 0xeeb80ac0,

458

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

459

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

460

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

461

ENCODING_MAP(kThumb2VcvtID, 0xeeb80bc0,

462

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

463

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

464

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

465

ENCODING_MAP(kThumb2VcvtFI, 0xeebd0ac0,

466

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

467

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

468

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

469

ENCODING_MAP(kThumb2VcvtDI, 0xeebd0bc0,

470

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

471

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

472

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

473

ENCODING_MAP(kThumb2VcvtFd, 0xeeb70ac0,

474

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

475

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

476

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

477

ENCODING_MAP(kThumb2VcvtDF, 0xeeb70bc0,

478

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

479

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

480

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

481

ENCODING_MAP(kThumb2Vsqrts, 0xeeb10ac0,

482

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

483

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

484

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

485

ENCODING_MAP(kThumb2Vsqrtd, 0xeeb10bc0,

486

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

487

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

488

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

489

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

490

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

491

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

492

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

493

ENCODING_MAP(kThumb2MovImm16, 0xf2400000,

494

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

495

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

496

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

497

ENCODING_MAP(kThumb2StrRRI12, 0xf8c00000,

498

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

499

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

500

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

501

ENCODING_MAP(kThumb2LdrRRI12, 0xf8d00000,

502

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

503

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

504

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

505

ENCODING_MAP(kThumb2StrRRI8Predec, 0xf8400c00,

506

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

507

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

508

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

509

ENCODING_MAP(kThumb2LdrRRI8Predec, 0xf8500c00,

510

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

511

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

512

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

513

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

514

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

515

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

516

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

517

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

518

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

519

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

520

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

521

ENCODING_MAP(kThumb2AddRRI12, 0xf2000000,

522

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

523

kFmtUnused, -1, -1,

524

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

525

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

526

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

527

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

528

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

529

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

530

ENCODING_MAP(kThumb2Vmovs, 0xeeb00a40,

531

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

532

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

533

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

534

ENCODING_MAP(kThumb2Vmovd, 0xeeb00b40,

535

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

536

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

537

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

538

ENCODING_MAP(kThumb2Ldmia, 0xe8900000,

539

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

540

kFmtUnused, -1, -1,

541

IS_BINARY_OP | REG_DEF0_USE0 | REG_DEF_LIST1 | IS_LOAD,

542

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

543

ENCODING_MAP(kThumb2Stmia, 0xe8800000,

544

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

545

kFmtUnused, -1, -1,

546

IS_BINARY_OP | REG_DEF0_USE0 | REG_USE_LIST1 | IS_STORE,

547

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

548

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

549

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

550

kFmtShift, -1, -1,

551

IS_QUAD_OP | REG_DEF0_USE12 | SETS_CCODES,

552

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

553

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

554

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

555

kFmtShift, -1, -1,

556

IS_QUAD_OP | REG_DEF0_USE12 | SETS_CCODES,

557

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

558

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

559

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

560

kFmtShift, -1, -1,

561

IS_QUAD_OP | REG_DEF0_USE12 | USES_CCODES | SETS_CCODES,

562

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

563

ENCODING_MAP(kThumb2CmpRR, 0xebb00f00,

564

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

565

kFmtUnused, -1, -1,

566

IS_TERTIARY_OP | REG_USE01 | SETS_CCODES,

567

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

568

ENCODING_MAP(kThumb2SubRRI12, 0xf2a00000,

569

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

570

kFmtUnused, -1, -1,

571

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

572

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

573

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

574

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

575

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

576

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

577

ENCODING_MAP(kThumb2Sel, 0xfaa0f080,

578

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

579

kFmtUnused, -1, -1,

580

IS_TERTIARY_OP | REG_DEF0_USE12 | USES_CCODES,

581

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

582

ENCODING_MAP(kThumb2Ubfx, 0xf3c00000,

583

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

584

kFmtBWidth, 4, 0, IS_QUAD_OP | REG_DEF0_USE1,

585

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

586

ENCODING_MAP(kThumb2Sbfx, 0xf3400000,

587

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

588

kFmtBWidth, 4, 0, IS_QUAD_OP | REG_DEF0_USE1,

589

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

590

ENCODING_MAP(kThumb2LdrRRR, 0xf8500000,

591

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

592

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

593

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

594

ENCODING_MAP(kThumb2LdrhRRR, 0xf8300000,

595

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

596

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

597

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

598

ENCODING_MAP(kThumb2LdrshRRR, 0xf9300000,

599

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

600

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

601

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

602

ENCODING_MAP(kThumb2LdrbRRR, 0xf8100000,

603

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

604

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

605

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

606

ENCODING_MAP(kThumb2LdrsbRRR, 0xf9100000,

607

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

608

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

609

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

610

ENCODING_MAP(kThumb2StrRRR, 0xf8400000,

611

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

612

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

613

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

614

ENCODING_MAP(kThumb2StrhRRR, 0xf8200000,

615

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

616

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

617

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

618

ENCODING_MAP(kThumb2StrbRRR, 0xf8000000,

619

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

620

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

621

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

622

ENCODING_MAP(kThumb2LdrhRRI12, 0xf8b00000,

623

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

624

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

625

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

626

ENCODING_MAP(kThumb2LdrshRRI12, 0xf9b00000,

627

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

628

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

629

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

630

ENCODING_MAP(kThumb2LdrbRRI12, 0xf8900000,

631

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

632

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

633

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

634

ENCODING_MAP(kThumb2LdrsbRRI12, 0xf9900000,

635

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

636

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

637

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

638

ENCODING_MAP(kThumb2StrhRRI12, 0xf8a00000,

639

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

640

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

641

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

642

ENCODING_MAP(kThumb2StrbRRI12, 0xf8800000,

643

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

644

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

645

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

646

ENCODING_MAP(kThumb2Pop, 0xe8bd0000,

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_DEF_LIST0

650

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

651

ENCODING_MAP(kThumb2Push, 0xe92d0000,

652

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

653

kFmtUnused, -1, -1,

654

IS_UNARY_OP | REG_DEF_SP | REG_USE_SP | REG_USE_LIST0

655

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

656

ENCODING_MAP(kThumb2CmpRI8, 0xf1b00f00,

657

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

658

kFmtUnused, -1, -1,

659

IS_BINARY_OP | REG_USE0 | SETS_CCODES,

660

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

661

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

662

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

663

kFmtShift, -1, -1,

664

IS_QUAD_OP | REG_DEF0_USE12 | SETS_CCODES,

665

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

666

ENCODING_MAP(kThumb2AndRRR, 0xea000000,

667

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

668

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

669

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

670

ENCODING_MAP(kThumb2BicRRR, 0xea200000,

671

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

672

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

673

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

674

ENCODING_MAP(kThumb2CmnRR, 0xeb000000,

675

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

676

kFmtUnused, -1, -1,

677

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

678

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

679

ENCODING_MAP(kThumb2EorRRR, 0xea800000,

680

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

681

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

682

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

683

ENCODING_MAP(kThumb2MulRRR, 0xfb00f000,

684

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

685

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

686

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

687

ENCODING_MAP(kThumb2MnvRR, 0xea6f0000,

688

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

689

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

690

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

691

ENCODING_MAP(kThumb2RsubRRI8, 0xf1d00000,

692

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

693

kFmtUnused, -1, -1,

694

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

695

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

696

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

697

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

698

kFmtUnused, -1, -1,

699

IS_BINARY_OP | REG_DEF0_USE1 | SETS_CCODES,

700

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

701

ENCODING_MAP(kThumb2OrrRRR, 0xea400000,

702

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

703

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

704

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

705

ENCODING_MAP(kThumb2TstRR, 0xea100f00,

706

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

707

kFmtUnused, -1, -1,

708

IS_TERTIARY_OP | REG_USE01 | SETS_CCODES,

709

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

710

ENCODING_MAP(kThumb2LslRRR, 0xfa00f000,

711

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

712

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

713

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

714

ENCODING_MAP(kThumb2LsrRRR, 0xfa20f000,

715

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

716

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

717

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

718

ENCODING_MAP(kThumb2AsrRRR, 0xfa40f000,

719

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

720

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

721

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

722

ENCODING_MAP(kThumb2RorRRR, 0xfa60f000,

723

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

724

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

725

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

726

ENCODING_MAP(kThumb2LslRRI5, 0xea4f0000,

727

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

728

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

729

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

730

ENCODING_MAP(kThumb2LsrRRI5, 0xea4f0010,

731

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

732

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

733

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

734

ENCODING_MAP(kThumb2AsrRRI5, 0xea4f0020,

735

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

736

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

737

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

738

ENCODING_MAP(kThumb2RorRRI5, 0xea4f0030,

739

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

740

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

741

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

742

ENCODING_MAP(kThumb2BicRRI8, 0xf0200000,

743

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

744

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

745

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

746

ENCODING_MAP(kThumb2AndRRI8, 0xf0000000,

747

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

748

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

749

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

750

ENCODING_MAP(kThumb2OrrRRI8, 0xf0400000,

751

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

752

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

753

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

754

ENCODING_MAP(kThumb2EorRRI8, 0xf0800000,

755

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

756

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

757

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

758

ENCODING_MAP(kThumb2AddRRI8, 0xf1100000,

759

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

760

kFmtUnused, -1, -1,

761

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

762

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

763

ENCODING_MAP(kThumb2AdcRRI8, 0xf1500000,

764

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

765

kFmtUnused, -1, -1,

766

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES | USES_CCODES,

767

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

768

ENCODING_MAP(kThumb2SubRRI8, 0xf1b00000,

769

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

770

kFmtUnused, -1, -1,

771

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

772

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

773

ENCODING_MAP(kThumb2SbcRRI8, 0xf1700000,

774

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

775

kFmtUnused, -1, -1,

776

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES | USES_CCODES,

777

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

778

ENCODING_MAP(kThumb2It, 0xbf00,

779

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

780

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

781

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

782

ENCODING_MAP(kThumb2Fmstat, 0xeef1fa10,

783

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

784

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

785

"fmstat", "", 2),

786

ENCODING_MAP(kThumb2Vcmpd, 0xeeb40b40,

787

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

788

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

789

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

790

ENCODING_MAP(kThumb2Vcmps, 0xeeb40a40,

791

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

792

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

793

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

794

ENCODING_MAP(kThumb2LdrPcRel12, 0xf8df0000,

795

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

796

kFmtUnused, -1, -1,

797

IS_TERTIARY_OP | REG_DEF0 | REG_USE_PC | IS_LOAD,

798

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

799

ENCODING_MAP(kThumb2BCond, 0xf0008000,

800

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

801

kFmtUnused, -1, -1,

802

IS_BINARY_OP | IS_BRANCH | USES_CCODES,

803

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

804

ENCODING_MAP(kThumb2Vmovd_RR, 0xeeb00b40,

805

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

806

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

807

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

808

ENCODING_MAP(kThumb2Vmovs_RR, 0xeeb00a40,

809

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

810

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

811

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

812

ENCODING_MAP(kThumb2Fmrs, 0xee100a10,

813

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

814

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

815

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

816

ENCODING_MAP(kThumb2Fmsr, 0xee000a10,

817

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

818

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

819

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

820

ENCODING_MAP(kThumb2Fmrrd, 0xec500b10,

821

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

822

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

823

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

824

ENCODING_MAP(kThumb2Fmdrr, 0xec400b10,

825

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

826

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

827

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

828

ENCODING_MAP(kThumb2Vabsd, 0xeeb00bc0,

829

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

830

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

831

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

832

ENCODING_MAP(kThumb2Vabss, 0xeeb00ac0,

833

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

834

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

835

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

836

ENCODING_MAP(kThumb2Vnegd, 0xeeb10b40,

837

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

838

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

839

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

840

ENCODING_MAP(kThumb2Vnegs, 0xeeb10a40,

841

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

842

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

843

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

844

ENCODING_MAP(kThumb2Vmovs_IMM8, 0xeeb00a00,

845

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

846

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

847

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

848

ENCODING_MAP(kThumb2Vmovd_IMM8, 0xeeb00b00,

849

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

850

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

851

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

852

ENCODING_MAP(kThumb2Mla, 0xfb000000,

853

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

854

kFmtBitBlt, 15, 12,

855

IS_QUAD_OP | REG_DEF0 | REG_USE1 | REG_USE2 | REG_USE3,

856

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

857

ENCODING_MAP(kThumb2Umull, 0xfba00000,

858

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

859

kFmtBitBlt, 3, 0,

860

IS_QUAD_OP | REG_DEF0 | REG_DEF1 | REG_USE2 | REG_USE3,

861

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

862

ENCODING_MAP(kThumb2Ldrex, 0xe8500f00,

863

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

864

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

865

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

866

ENCODING_MAP(kThumb2Strex, 0xe8400000,

867

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

868

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

869

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

870

ENCODING_MAP(kThumb2Clrex, 0xf3bf8f2f,

871

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

872

kFmtUnused, -1, -1, NO_OPERAND,

873

"clrex", "", 2),

874

ENCODING_MAP(kThumb2Bfi, 0xf3600000,

875

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

876

kFmtBitBlt, 4, 0, IS_QUAD_OP | REG_DEF0_USE1,

877

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

878

ENCODING_MAP(kThumb2Bfc, 0xf36f0000,

879

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

880

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

881

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

882

ENCODING_MAP(kThumb2Dmb, 0xf3bf8f50,

883

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

884

kFmtUnused, -1, -1, IS_UNARY_OP,

885

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

886

ENCODING_MAP(kThumb2LdrPcReln12, 0xf85f0000,

887

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

888

kFmtUnused, -1, -1,

889

IS_BINARY_OP | REG_DEF0 | REG_USE_PC | IS_LOAD,

890

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

891

ENCODING_MAP(kThumb2Stm, 0xe9000000,

892

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

893

kFmtUnused, -1, -1,

894

IS_BINARY_OP | REG_USE0 | REG_USE_LIST1 | IS_STORE,

895

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

896

ENCODING_MAP(kThumbUndefined, 0xde00,

897

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

898

kFmtUnused, -1, -1, NO_OPERAND,

899

"undefined", "", 1),

900

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

901

ENCODING_MAP(kThumb2VPopCS, 0xecbd8a00,

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_DEF_FPCS_LIST0

905

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

906

ENCODING_MAP(kThumb2VPushCS, 0xed2d8a00,

907

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

908

kFmtUnused, -1, -1,

909

IS_UNARY_OP | REG_DEF_SP | REG_USE_SP | REG_USE_FPCS_LIST0

910

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

911

ENCODING_MAP(kThumb2Vldms, 0xec900a00,

912

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

913

kFmtUnused, -1, -1,

914

IS_TERTIARY_OP | REG_USE0 | REG_DEF_FPCS_LIST2

915

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

916

ENCODING_MAP(kThumb2Vstms, 0xec800a00,

917

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

918

kFmtUnused, -1, -1,

919

IS_TERTIARY_OP | REG_USE0 | REG_USE_FPCS_LIST2

920

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

921

ENCODING_MAP(kThumb2BUncond, 0xf0009000,

922

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

923

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

924

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

925

ENCODING_MAP(kThumb2MovImm16H, 0xf2c00000,

926

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

927

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

928

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

929

ENCODING_MAP(kThumb2AddPCR, 0x4487,

930

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

931

kFmtUnused, -1, -1,

932

IS_UNARY_OP | REG_USE0 | IS_BRANCH,

933

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

934

ENCODING_MAP(kThumb2AdrST, 0xf20f0000,

935

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

936

kFmtUnused, -1, -1,

937

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

938

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

939

ENCODING_MAP(kThumb2MovImm16LST, 0xf2400000,

940

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

941

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

942

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

943

ENCODING_MAP(kThumb2MovImm16HST, 0xf2c00000,

944

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

945

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

946

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

947

ENCODING_MAP(kThumb2LdmiaWB, 0xe8b00000,

948

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

949

kFmtUnused, -1, -1,

950

IS_BINARY_OP | REG_DEF0_USE0 | REG_DEF_LIST1 | IS_LOAD,

951

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

952

ENCODING_MAP(kThumb2SubsRRI12, 0xf1b00000,

953

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

954

kFmtUnused, -1, -1,

955

IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,

956

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

};

/*

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

962

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

963

* generate unnecessary stall cycles.

964

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

965

*/

966

#define PADDING_MOV_R5_R5 0x1C2D

967

968

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

969

static void installLiteralPools(CompilationUnit* cUnit)

970

{

971

int* dataPtr = (int*) ((char*) cUnit->baseAddr + cUnit->dataOffset);

972

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

973

while (dataLIR) {

974

*dataPtr++ = dataLIR->operands[0];

975

dataLIR = NEXT_LIR(dataLIR);

}

}

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

980

static void installSwitchTables(CompilationUnit* cUnit)

981

{

982

GrowableListIterator iterator;

983

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

984

while (true) {

985

SwitchTable* tabRec = (SwitchTable *) oatGrowableListIteratorNext(

986

&iterator);

987

if (tabRec == NULL) break;

988

int* dataPtr = (int*)((char*)cUnit->baseAddr + tabRec->offset);

989

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

990

if (cUnit->printMe) {

991

LOG(INFO) << "Switch table for offset 0x" /*<< hex*/ << bxOffset;

992

}

993

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

994

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

995

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

996

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

997

if (cUnit->printMe) {

998

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

999

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

1000

std::hex << disp;

1001

}

1002

*dataPtr++ = keys[elems];

1003

*dataPtr++ = tabRec->targets[elems]->generic.offset - bxOffset;

1004

}

1005

} else {

1006

assert(tabRec->table[0] == kPackedSwitchSignature);

1007

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

1008

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

1009

if (cUnit->printMe) {

1010

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

1011

std::hex << disp;

1012

}

1013

*dataPtr++ = tabRec->targets[elems]->generic.offset - bxOffset;

}

}

}

}

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

1020

static void installFillArrayData(CompilationUnit* cUnit)

1021

{

1022

GrowableListIterator iterator;

1023

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

1024

while (true) {

1025

FillArrayData *tabRec = (FillArrayData *) oatGrowableListIteratorNext(

1026

&iterator);

1027

if (tabRec == NULL) break;

1028

char* dataPtr = (char*)cUnit->baseAddr + tabRec->offset;

1029

memcpy(dataPtr, (char*)tabRec->table, tabRec->size);

}

}

/*

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

1035

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

1036

* instruction.

1037

*/

1038

static AssemblerStatus assembleInstructions(CompilationUnit* cUnit,

1039

intptr_t startAddr)

1040

{

1041

short* bufferAddr = (short*) cUnit->codeBuffer;

1042

ArmLIR* lir;

1043

AssemblerStatus res = kSuccess; // Assume success

1044

1045

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

1046

if (lir->opcode < 0) {

1047

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

1048

/* 1 means padding is needed */

1049

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

1050

*bufferAddr++ = PADDING_MOV_R5_R5;

}

continue;

}

if (lir->flags.isNop) {

continue;

}

/*

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

1061

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

1062

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

1063

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

1064

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

1065

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

1066

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

1067

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

1068

* is an iterative process.

1069

*/

1070

1071

if (lir->opcode == kThumbLdrPcRel ||

1072

lir->opcode == kThumb2LdrPcRel12 ||

1073

lir->opcode == kThumbAddPcRel ||

1074

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

1075

/*

1076

* PC-relative loads are mostly used to load immediates

1077

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

1078

* However, if the load displacement exceeds the limit,

1079

* we revert to a 2-instruction materialization sequence.

1080

*/

1081

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

1082

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

1083

intptr_t target = lirTarget->generic.offset;

1084

int delta = target - pc;

1085

if (delta & 0x3) {

1086

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

1087

}

1088

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

1089

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

1090

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

1091

// Shouldn't happen in current codegen.

1092

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

1093

}

1094

// Now, check for the two difficult cases

1095

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

1096

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

1097

/*

1098

* OK - the load doesn't work. We'll just materialize

1099

* the immediate directly using mov16l and mov16h.

1100

* It's a little ugly for float immediates as we don't have

1101

* float ops like the core mov imm16H/L. In this case

1102

* we'll materialize in a core register (rLR) and then copy.

1103

* NOTE/WARNING: This is a *very* fragile workaround that will

1104

* be addressed in a later release when we have a late spill

1105

* capability. We can get away with it for now because rLR

1106

* is currently only used during call setups, and our convention

1107

* requires all arguments to be passed in core register & the

1108

* frame (and thus, we won't see any vlrds in the sequence).

1109

* The normal resource mask mechanism will prevent any damaging

1110

* code motion.

1111

*/

1112

int tgtReg = (lir->opcode == kThumb2Vldrs) ? rLR :

1113

lir->operands[0];

1114

int immVal = lirTarget->operands[0];

1115

// The standard utilities won't work here - build manually

1116

ArmLIR *newMov16L =

1117

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

1118

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

1119

newMov16L->opcode = kThumb2MovImm16;

1120

newMov16L->operands[0] = tgtReg;

1121

newMov16L->operands[1] = immVal & 0xffff;

1122

oatSetupResourceMasks(newMov16L);

1123

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

1124

ArmLIR *newMov16H =

1125

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

1126

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

1127

newMov16H->opcode = kThumb2MovImm16H;

1128

newMov16H->operands[0] = tgtReg;

1129

newMov16H->operands[1] = (immVal >> 16) & 0xffff;

1130

oatSetupResourceMasks(newMov16H);

1131

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

1132

if (lir->opcode == kThumb2Vldrs) {

1133

// Convert the vldrs to a kThumb2Fmsr

1134

lir->opcode = kThumb2Fmsr;

1135

lir->operands[1] = rLR;

1136

lir->generic.target = NULL;

1137

lir->operands[2] = 0;

1138

oatSetupResourceMasks(lir);

1139

} else {

1140

// Nullify the original load

1141

lir->flags.isNop = true;

}

res = kRetryAll;

} else {

if (lir->opcode == kThumb2Vldrs) {

1146

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

1147

} else {

1148

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

delta : delta >> 2;

}

}

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

1153

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

1154

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

1155

intptr_t target = targetLIR->generic.offset;

1156

int delta = target - pc;

1157

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

1158

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

1159

ArmLIR *newInst =

1160

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

1161

/* Make new branch instruction and insert after */

1162

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

1163

newInst->opcode = kThumbBCond;

1164

newInst->operands[0] = 0;

1165

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

1166

kArmCondEq : kArmCondNe;

1167

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

1168

oatSetupResourceMasks(newInst);

1169

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

1170

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

1171

lir->opcode = kThumbCmpRI8;

1172

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

1173

lir->operands[1] = 0;

1174

lir->generic.target = 0;

1175

oatSetupResourceMasks(lir);

1176

res = kRetryAll;

1177

} else {

1178

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

1179

}

1180

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

1181

lir->opcode == kThumb2BCond) {

1182

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

1183

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

1184

intptr_t target = targetLIR->generic.offset;

1185

int delta = target - pc;

1186

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

1187

lir->opcode = kThumb2BCond;

1188

oatSetupResourceMasks(lir);

1189

res = kRetryAll;

1190

}

1191

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

1192

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

1193

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

1194

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

1195

intptr_t target = targetLIR->generic.offset;

1196

int delta = target - pc;

1197

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

1198

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

1199

lir->flags.isNop = true;

1200

res = kRetryAll;

1201

}

1202

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

1203

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

1204

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

1205

intptr_t target = targetLIR->generic.offset;

1206

int delta = target - pc;

1207

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

1208

// Convert to Thumb2BCond w/ kArmCondAl

1209

lir->opcode = kThumb2BUncond;

1210

lir->operands[0] = 0;

1211

oatSetupResourceMasks(lir);

1212

res = kRetryAll;

1213

}

1214

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

1215

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

1216

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

1217

lir->flags.isNop = true;

1218

res = kRetryAll;

1219

}

1220

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

1221

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

1222

/* curPC is Thumb */

1223

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

1224

intptr_t target = lir->operands[1];

1225

1226

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

if (curPC & 0x2) {

target |= 0x2;

}

int delta = target - curPC;

1231

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

1232

1233

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

1234

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

1235

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

1236

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

1237

/* Both curPC and target are Thumb */

1238

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

1239

intptr_t target = lir->operands[1];

1240

1241

int delta = target - curPC;

1242

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

1243

1244

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

1245

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

1246

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

1247

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

1248

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

1249

if (disp < 4096) {

1250

lir->operands[1] = disp;

1251

} else {

1252

// convert to ldimm16l, ldimm16h, add tgt, pc, r12

1253

ArmLIR *newMov16L =

1254

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

1255

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

1256

newMov16L->opcode = kThumb2MovImm16LST;

1257

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

1258

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

1259

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

1260

oatSetupResourceMasks(newMov16L);

1261

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

1262

ArmLIR *newMov16H =

1263

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

1264

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

1265

newMov16H->opcode = kThumb2MovImm16HST;

1266

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

1267

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

1268

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

1269

oatSetupResourceMasks(newMov16H);

1270

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

1271

lir->opcode = kThumb2AddRRR;

1272

lir->operands[1] = rPC;

1273

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

1274

oatSetupResourceMasks(lir);

1275

res = kRetryAll;

1276

}

1277

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

1278

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

1279

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

1280

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

1281

lir->operands[1] = (tabRec->offset -

1282

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

1283

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

1284

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

1285

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

1286

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

1287

lir->operands[1] = ((tabRec->offset -

1288

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

1289

}

1290

ArmEncodingMap *encoder = &EncodingMap[lir->opcode];

1291

u4 bits = encoder->skeleton;

1292

int i;

1293

for (i = 0; i < 4; i++) {

1294

u4 operand;

1295

u4 value;

1296

operand = lir->operands[i];

1297

switch(encoder->fieldLoc[i].kind) {

case kFmtUnused:

break;

case kFmtFPImm:

value = ((operand & 0xF0) >> 4) << encoder->fieldLoc[i].end;

1302

value |= (operand & 0x0F) << encoder->fieldLoc[i].start;

bits |= value;

break;

case kFmtBrOffset:

value = ((operand & 0x80000) >> 19) << 26;

1307

value |= ((operand & 0x40000) >> 18) << 11;

1308

value |= ((operand & 0x20000) >> 17) << 13;

1309

value |= ((operand & 0x1f800) >> 11) << 16;

1310

value |= (operand & 0x007ff);

bits |= value;

break;

case kFmtShift5:

value = ((operand & 0x1c) >> 2) << 12;

1315

value |= (operand & 0x03) << 6;

bits |= value;

break;

case kFmtShift:

value = ((operand & 0x70) >> 4) << 12;

1320

value |= (operand & 0x0f) << 4;

bits |= value;

break;

case kFmtBWidth:

value = operand - 1;

bits |= value;

break;

case kFmtLsb:

value = ((operand & 0x1c) >> 2) << 12;

1329

value |= (operand & 0x03) << 6;

bits |= value;

break;

case kFmtImm6:

value = ((operand & 0x20) >> 5) << 9;

1334

value |= (operand & 0x1f) << 3;

bits |= value;

break;

case kFmtBitBlt:

value = (operand << encoder->fieldLoc[i].start) &

1339

((1 << (encoder->fieldLoc[i].end + 1)) - 1);

bits |= value;

break;

case kFmtDfp: {

assert(DOUBLEREG(operand));

1344

assert((operand & 0x1) == 0);

1345

int regName = (operand & FP_REG_MASK) >> 1;

1346

/* Snag the 1-bit slice and position it */

1347

value = ((regName & 0x10) >> 4) <<

1348

encoder->fieldLoc[i].end;

1349

/* Extract and position the 4-bit slice */

1350

value |= (regName & 0x0f) <<

1351

encoder->fieldLoc[i].start;

bits |= value;

break;

}

case kFmtSfp:

assert(SINGLEREG(operand));

1357

/* Snag the 1-bit slice and position it */

1358

value = (operand & 0x1) <<

1359

encoder->fieldLoc[i].end;

1360

/* Extract and position the 4-bit slice */

1361

value |= ((operand & 0x1e) >> 1) <<

1362

encoder->fieldLoc[i].start;

bits |= value;

break;

case kFmtImm12:

case kFmtModImm:

value = ((operand & 0x800) >> 11) << 26;

1368

value |= ((operand & 0x700) >> 8) << 12;

1369

value |= operand & 0x0ff;

bits |= value;

break;

case kFmtImm16:

value = ((operand & 0x0800) >> 11) << 26;

1374

value |= ((operand & 0xf000) >> 12) << 16;

1375

value |= ((operand & 0x0700) >> 8) << 12;

1376

value |= operand & 0x0ff;

bits |= value;

break;

case kFmtOff24: {

u4 signbit = (operand >> 31) & 0x1;

1381

u4 i1 = (operand >> 22) & 0x1;

1382

u4 i2 = (operand >> 21) & 0x1;

1383

u4 imm10 = (operand >> 11) & 0x03ff;

1384

u4 imm11 = operand & 0x07ff;

1385

u4 j1 = (i1 ^ signbit) ? 0 : 1;

1386

u4 j2 = (i2 ^ signbit) ? 0 : 1;

1387

value = (signbit << 26) | (j1 << 13) | (j2 << 11) |

1388

(imm10 << 16) | imm11;

bits |= value;

}

break;

default:

assert(0);

}

}

if (encoder->size == 2) {

1397

*bufferAddr++ = (bits >> 16) & 0xffff;

1398

}

1399

*bufferAddr++ = bits & 0xffff;

}

return res;

}

static int assignLiteralOffsetCommon(LIR* lir, int offset)

1405

{

1406

for (;lir != NULL; lir = lir->next) {

1407

lir->offset = offset;

offset += 4;

}

return offset;

}

static int createMappingTable(CompilationUnit* cUnit, MappingTable** pTable)

1414

{

1415

ArmLIR* armLIR;

1416

int currentDalvikOffset = -1;

1417

int count = 0;

1418

1419

for (armLIR = (ArmLIR *) cUnit->firstLIRInsn;

1420

armLIR;

1421

armLIR = NEXT_LIR(armLIR)) {

1422

if ((armLIR->opcode >= 0) && !armLIR->flags.isNop &&

1423

(currentDalvikOffset != armLIR->generic.dalvikOffset)) {

1424

// Changed - need to emit a record

1425

if (pTable) {

1426

MappingTable *table = *pTable;

1427

assert(table);

1428

table[count].targetOffset = armLIR->generic.offset;

1429

table[count].dalvikOffset = armLIR->generic.dalvikOffset;

1430

}

1431

count++;

1432

currentDalvikOffset = armLIR->generic.dalvikOffset;

}

}

return count;

}

/* Determine the offset of each literal field */

1439

static int assignLiteralOffset(CompilationUnit* cUnit, int offset)

1440

{

1441

offset = assignLiteralOffsetCommon(cUnit->literalList, offset);

return offset;

}

static int assignSwitchTablesOffset(CompilationUnit* cUnit, int offset)

1446

{

1447

GrowableListIterator iterator;

1448

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

1449

while (true) {

1450

SwitchTable *tabRec = (SwitchTable *) oatGrowableListIteratorNext(

1451

&iterator);

1452

if (tabRec == NULL) break;

1453

tabRec->offset = offset;

1454

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

1455

offset += tabRec->table[1] * (sizeof(int) * 2);

1456

} else {

1457

assert(tabRec->table[0] == kPackedSwitchSignature);

1458

offset += tabRec->table[1] * sizeof(int);

}

}

return offset;

}

static int assignFillArrayDataOffset(CompilationUnit* cUnit, int offset)

1465

{

1466

GrowableListIterator iterator;

1467

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

1468

while (true) {

1469

FillArrayData *tabRec = (FillArrayData *) oatGrowableListIteratorNext(

1470

&iterator);

1471

if (tabRec == NULL) break;

1472

tabRec->offset = offset;

1473

offset += tabRec->size;

1474

// word align

1475

offset = (offset + 3) & ~3;

}

return offset;

}

/*

* Walk the compilation unit and assign offsets to instructions

1482

* and literals and compute the total size of the compiled unit.

1483

*/

1484

void assignOffsets(CompilationUnit* cUnit)

{

ArmLIR* armLIR;

int offset = 0;

for (armLIR = (ArmLIR *) cUnit->firstLIRInsn;

1490

armLIR;

1491

armLIR = NEXT_LIR(armLIR)) {

1492

armLIR->generic.offset = offset;

1493

if (armLIR->opcode >= 0 && !armLIR->flags.isNop) {

1494

armLIR->flags.size = EncodingMap[armLIR->opcode].size * 2;

1495

offset += armLIR->flags.size;

1496

} else if (armLIR->opcode == kArmPseudoPseudoAlign4) {

1497

if (offset & 0x2) {

1498

offset += 2;

1499

armLIR->operands[0] = 1;

1500

} else {

1501

armLIR->operands[0] = 0;

1502

}

1503

}

1504

/* Pseudo opcodes don't consume space */

1505

}

1506

1507

/* Const values have to be word aligned */

1508

offset = (offset + 3) & ~3;

1509

1510

/* Set up offsets for literals */

1511

cUnit->dataOffset = offset;

1512

1513

offset = assignLiteralOffset(cUnit, offset);

1514

1515

offset = assignSwitchTablesOffset(cUnit, offset);

1516

1517

offset = assignFillArrayDataOffset(cUnit, offset);

1518

1519

cUnit->totalSize = offset;

1520

}

1521

/*

1522

* Go over each instruction in the list and calculate the offset from the top

1523

* before sending them off to the assembler. If out-of-range branch distance is

1524

* seen rearrange the instructions a bit to correct it.

1525

*/

1526

void oatAssembleLIR(CompilationUnit* cUnit)

1527

{

1528

assignOffsets(cUnit);

1529

1530

#ifdef TESTMODE

1531

//For testing - caller will allocate buffer

1532

int testSize = 1024 * 1024;

1533

int fd = ashmem_create_region("dalvik-test-code-cache",testSize);

1534

if (fd < 0) {

1535

LOG(FATAL) << "Coudln't create ashmem region";

1536

}

1537

cUnit->baseAddr = cUnit->codeBuffer = (unsigned char *)

1538

mmap(NULL, testSize, PROT_READ | PROT_WRITE | PROT_EXEC,

1539

MAP_PRIVATE, fd, 0);

1540

close(fd);

1541

if (cUnit->baseAddr == MAP_FAILED) {

1542

LOG(FATAL) << "Failed to mmap the test region: " << strerror(errno);

}

#endif

/*

* Assemble here. Note that we generate code with optimistic assumptions

1548

* and if found now to work, we'll have to redo the sequence and retry.

*/

while (true) {

AssemblerStatus res = assembleInstructions(cUnit, NULL);

1553

if (res == kSuccess) {

1554

break;

1555

} else {

1556

cUnit->assemblerRetries++;

1557

if (cUnit->assemblerRetries > MAX_ASSEMBLER_RETRIES) {

1558

LOG(FATAL) << "Assembler error - too many retries";

1559

}

1560

// Redo offsets and try again

1561

assignOffsets(cUnit);

}

}

// Install literals

installLiteralPools(cUnit);

1567

1568

// Install switch tables

1569

installSwitchTables(cUnit);

1570

1571

// Install fill array data

1572

installFillArrayData(cUnit);

1573

1574

/*

1575

* Create the mapping table

1576

*/

1577

cUnit->mappingTableSize = createMappingTable(cUnit, NULL /* just count */);

1578

cUnit->mappingTable = (MappingTable*)oatNew(

1579

cUnit->mappingTableSize * sizeof(*cUnit->mappingTable), true);

1580

createMappingTable(cUnit, &cUnit->mappingTable);

1581

}