Lines Matching refs:LIR
78 /* NOTE: must be kept in sync with enum ArmOpcode from LIR.h */
1041 void ArmMir2Lir::ReplaceFixup(LIR* prev_lir, LIR* orig_lir, LIR* new_lir) {
1052 void ArmMir2Lir::InsertFixupBefore(LIR* prev_lir, LIR* orig_lir, LIR* new_lir) {
1070 uint8_t* ArmMir2Lir::EncodeLIRs(uint8_t* write_pos, LIR* lir) {
1071 for (; lir != NULL; lir = NEXT_LIR(lir)) {
1072 if (!lir->flags.is_nop) {
1073 int opcode = lir->opcode;
1077 if (lir->offset & 0x2) {
1083 } else if (LIKELY(!lir->flags.is_nop)) {
1084 const ArmEncodingMap *encoder = &EncodingMap[lir->opcode];
1089 operand = lir->operands[i];
1209 // Assemble the LIR into binary instruction format.
1211 LIR* lir;
1212 LIR* prev_lir;
1230 lir = first_fixup_;
1232 while (lir != NULL) {
1234 * NOTE: the lir being considered here will be encoded following the switch (so long as
1240 lir->offset += offset_adjustment;
1242 lir->flags.generation = generation;
1243 switch (static_cast<FixupKind>(lir->flags.fixup)) {
1248 if (lir->operands[1] != rs_r15pc.GetReg()) {
1259 LIR *lir_target = lir->target;
1260 CodeOffset pc = (lir->offset + 4) & ~3;
1262 ((lir_target->flags.generation == lir->flags.generation) ? 0 : offset_adjustment);
1273 if (kIsDebugBuild && (((lir->opcode == kThumbAddPcRel) && (delta > 1020)) ||
1274 ((lir->opcode == kThumbLdrPcRel) && (delta > 1020)))) {
1279 if (((lir->opcode == kThumb2LdrPcRel12) && (delta > 4091)) ||
1280 ((lir->opcode == kThumb2LdrdPcRel8) && (delta > 1020)) ||
1281 ((lir->opcode == kThumb2Vldrs) && (delta > 1020)) ||
1282 ((lir->opcode == kThumb2Vldrd) && (delta > 1020))) {
1288 int base_reg = ((lir->opcode == kThumb2LdrdPcRel8) ||
1289 (lir->opcode == kThumb2LdrPcRel12)) ? lir->operands[0] :
1293 LIR* new_adr = RawLIR(lir->dalvik_offset, kThumb2Adr,
1294 base_reg, 0, 0, 0, 0, lir->target);
1295 new_adr->offset = lir->offset;
1298 InsertLIRBefore(lir, new_adr);
1299 lir->offset += new_adr->flags.size;
1302 // lir no longer pcrel, unlink and link in new_adr.
1303 ReplaceFixup(prev_lir, lir, new_adr);
1306 offset_adjustment -= lir->flags.size;
1307 if (lir->opcode == kThumb2LdrPcRel12) {
1308 lir->opcode = kThumb2LdrRRI12;
1309 } else if (lir->opcode == kThumb2LdrdPcRel8) {
1310 lir->opcode = kThumb2LdrdI8;
1312 lir->flags.size = EncodingMap[lir->opcode].size;
1313 offset_adjustment += lir->flags.size;
1315 if (lir->opcode == kThumb2LdrdI8) {
1316 lir->operands[3] = 0;
1317 lir->operands[2] = base_reg;
1319 lir->operands[2] = 0;
1320 lir->operands[1] = base_reg;
1323 lir = new_adr->u.a.pcrel_next;
1327 if ((lir->opcode == kThumb2Vldrs) ||
1328 (lir->opcode == kThumb2Vldrd) ||
1329 (lir->opcode == kThumb2LdrdPcRel8)) {
1330 lir->operands[2] = delta >> 2;
1332 lir->operands[1] = (lir->opcode == kThumb2LdrPcRel12) ? delta :
1339 LIR *target_lir = lir->target;
1340 CodeOffset pc = lir->offset + 4;
1342 ((target_lir->flags.generation == lir->flags.generation) ? 0 : offset_adjustment);
1349 LIR* new_inst =
1350 RawLIR(lir->dalvik_offset, kThumbBCond, 0,
1351 (lir->opcode == kThumb2Cbz) ? kArmCondEq : kArmCondNe,
1352 0, 0, 0, lir->target);
1353 InsertLIRAfter(lir, new_inst);
1357 offset_adjustment -= lir->flags.size;
1358 lir->opcode = kThumbCmpRI8;
1360 lir->operands[1] = 0;
1361 lir->target = 0;
1362 lir->flags.size = EncodingMap[lir->opcode].size;
1364 offset_adjustment += lir->flags.size;
1366 new_inst->offset = lir->offset + lir->flags.size;
1371 // lir no longer pcrel, unlink and link in new_inst.
1372 ReplaceFixup(prev_lir, lir, new_inst);
1374 lir = new_inst->u.a.pcrel_next;
1378 lir->operands[1] = delta >> 1;
1383 if (__builtin_popcount(lir->operands[0]) == 1) {
1390 lir->opcode = (lir->opcode == kThumb2Push) ? kThumb2Push1 :
1393 while (lir->operands[0]) {
1394 if (lir->operands[0] & 0x1) {
1398 lir->operands[0] >>= 1;
1401 lir->operands[0] = reg;
1403 lir->flags.fixup = kFixupNone;
1408 LIR *target_lir = lir->target;
1411 CodeOffset pc = lir->offset + 4;
1413 ((target_lir->flags.generation == lir->flags.generation) ? 0 : offset_adjustment);
1415 if ((lir->opcode == kThumbBCond) && (delta > 254 || delta < -256)) {
1416 offset_adjustment -= lir->flags.size;
1417 lir->opcode = kThumb2BCond;
1418 lir->flags.size = EncodingMap[lir->opcode].size;
1420 offset_adjustment += lir->flags.size;
1423 lir->operands[0] = delta >> 1;
1427 LIR *target_lir = lir->target;
1428 CodeOffset pc = lir->offset + 4;
1430 ((target_lir->flags.generation == lir->flags.generation) ? 0 : offset_adjustment);
1432 lir->operands[0] = delta >> 1;
1433 if (!(cu_->disable_opt & (1 << kSafeOptimizations)) && lir->operands[0] == 0) {
1435 offset_adjustment -= lir->flags.size;
1436 lir->flags.is_nop = true;
1438 lir->flags.fixup = kFixupNone;
1444 LIR *target_lir = lir->target;
1445 CodeOffset pc = lir->offset + 4;
1447 ((target_lir->flags.generation == lir->flags.generation) ? 0 : offset_adjustment);
1451 offset_adjustment -= lir->flags.size;
1452 lir->opcode = kThumb2BUncond;
1453 lir->operands[0] = 0;
1454 lir->flags.size = EncodingMap[lir->opcode].size;
1455 lir->flags.fixup = kFixupT2Branch;
1456 offset_adjustment += lir->flags.size;
1459 lir->operands[0] = delta >> 1;
1460 if (!(cu_->disable_opt & (1 << kSafeOptimizations)) && lir->operands[0] == -1) {
1462 offset_adjustment -= lir->flags.size;
1463 lir->flags.is_nop = true;
1465 lir->flags.fixup = kFixupNone;
1472 DCHECK(NEXT_LIR(lir)->opcode == kThumbBlx2);
1474 CodeOffset cur_pc = (lir->offset + 4) & ~3;
1475 CodeOffset target = lir->operands[1];
1484 lir->operands[0] = (delta >> 12) & 0x7ff;
1485 NEXT_LIR(lir)->operands[0] = (delta>> 1) & 0x7ff;
1489 DCHECK(NEXT_LIR(lir)->opcode == kThumbBl2);
1491 CodeOffset cur_pc = lir->offset + 4;
1492 CodeOffset target = lir->operands[1];
1497 lir->operands[0] = (delta >> 12) & 0x7ff;
1498 NEXT_LIR(lir)->operands[0] = (delta>> 1) & 0x7ff;
1502 EmbeddedData *tab_rec = reinterpret_cast<EmbeddedData*>(UnwrapPointer(lir->operands[2]));
1503 LIR* target = lir->target;
1505 : target->offset + ((target->flags.generation == lir->flags.generation) ? 0 :
1507 int32_t disp = target_disp - ((lir->offset + 4) & ~3);
1509 lir->operands[1] = disp;
1513 LIR *new_mov16L =
1514 RawLIR(lir->dalvik_offset, kThumb2MovImm16LST, lir->operands[0], 0,
1515 WrapPointer(lir), WrapPointer(tab_rec), 0, lir->target);
1518 new_mov16L->offset = lir->offset;
1519 // Link the new instruction, retaining lir.
1520 InsertLIRBefore(lir, new_mov16L);
1521 lir->offset += new_mov16L->flags.size;
1523 InsertFixupBefore(prev_lir, lir, new_mov16L);
1525 LIR *new_mov16H =
1526 RawLIR(lir->dalvik_offset, kThumb2MovImm16HST, lir->operands[0], 0,
1527 WrapPointer(lir), WrapPointer(tab_rec), 0, lir->target);
1530 new_mov16H->offset = lir->offset;
1531 // Link the new instruction, retaining lir.
1532 InsertLIRBefore(lir, new_mov16H);
1533 lir->offset += new_mov16H->flags.size;
1535 InsertFixupBefore(prev_lir, lir, new_mov16H);
1538 offset_adjustment -= lir->flags.size;
1539 if (RegStorage::RegNum(lir->operands[0]) < 8) {
1540 lir->opcode = kThumbAddRRLH;
1542 lir->opcode = kThumbAddRRHH;
1544 lir->operands[1] = rs_rARM_PC.GetReg();
1545 lir->flags.size = EncodingMap[lir->opcode].size;
1546 offset_adjustment += lir->flags.size;
1548 lir->flags.fixup = kFixupNone;
1555 LIR *addPCInst = reinterpret_cast<LIR*>(UnwrapPointer(lir->operands[2]));
1556 EmbeddedData *tab_rec = reinterpret_cast<EmbeddedData*>(UnwrapPointer(lir->operands[3]));
1558 LIR* target = lir->target;
1560 lir->operands[1] = (target_disp - (addPCInst->offset + 4)) & 0xffff;
1565 LIR *addPCInst = reinterpret_cast<LIR*>(UnwrapPointer(lir->operands[2]));
1566 EmbeddedData *tab_rec = reinterpret_cast<EmbeddedData*>(UnwrapPointer(lir->operands[3]));
1568 LIR* target = lir->target;
1570 lir->operands[1] =
1575 int32_t required_size = lir->offset & 0x2;
1576 if (lir->flags.size != required_size) {
1577 offset_adjustment += required_size - lir->flags.size;
1578 lir->flags.size = required_size;
1584 LOG(FATAL) << "Unexpected case " << lir->flags.fixup;
1586 prev_lir = lir;
1587 lir = lir->u.a.pcrel_next;
1631 size_t ArmMir2Lir::GetInsnSize(LIR* lir) {
1632 DCHECK(!IsPseudoLirOp(lir->opcode));
1633 return EncodingMap[lir->opcode].size;
1637 uint32_t ArmMir2Lir::LinkFixupInsns(LIR* head_lir, LIR* tail_lir, uint32_t offset) {
1638 LIR* end_lir = tail_lir->next;
1640 LIR* last_fixup = NULL;
1641 for (LIR* lir = head_lir; lir != end_lir; lir = NEXT_LIR(lir)) {
1642 if (!lir->flags.is_nop) {
1643 if (lir->flags.fixup != kFixupNone) {
1644 if (!IsPseudoLirOp(lir->opcode)) {
1645 lir->flags.size = EncodingMap[lir->opcode].size;
1646 lir->flags.fixup = EncodingMap[lir->opcode].fixup;
1647 } else if (UNLIKELY(lir->opcode == kPseudoPseudoAlign4)) {
1648 lir->flags.size = (offset & 0x2);
1649 lir->flags.fixup = kFixupAlign4;
1651 lir->flags.size = 0;
1652 lir->flags.fixup = kFixupLabel;
1655 lir->flags.use_def_invalid = true;
1656 lir->u.a.pcrel_next = NULL;
1658 first_fixup_ = lir;
1660 last_fixup->u.a.pcrel_next = lir;
1662 last_fixup = lir;
1663 lir->offset = offset;
1665 offset += lir->flags.size;
