| /* |
| * Copyright (C) 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifndef ART_COMPILER_UTILS_ARM_ASSEMBLER_THUMB2_H_ |
| #define ART_COMPILER_UTILS_ARM_ASSEMBLER_THUMB2_H_ |
| |
| #include <deque> |
| #include <utility> |
| #include <vector> |
| |
| #include "base/arena_containers.h" |
| #include "base/logging.h" |
| #include "constants_arm.h" |
| #include "utils/arm/managed_register_arm.h" |
| #include "utils/arm/assembler_arm.h" |
| #include "utils/array_ref.h" |
| #include "offsets.h" |
| |
| namespace art { |
| namespace arm { |
| |
| class Thumb2Assembler FINAL : public ArmAssembler { |
| public: |
| explicit Thumb2Assembler(ArenaAllocator* arena, bool can_relocate_branches = true) |
| : ArmAssembler(arena), |
| can_relocate_branches_(can_relocate_branches), |
| force_32bit_(false), |
| it_cond_index_(kNoItCondition), |
| next_condition_(AL), |
| fixups_(arena->Adapter(kArenaAllocAssembler)), |
| fixup_dependents_(arena->Adapter(kArenaAllocAssembler)), |
| literals_(arena->Adapter(kArenaAllocAssembler)), |
| jump_tables_(arena->Adapter(kArenaAllocAssembler)), |
| last_position_adjustment_(0u), |
| last_old_position_(0u), |
| last_fixup_id_(0u) { |
| cfi().DelayEmittingAdvancePCs(); |
| } |
| |
| virtual ~Thumb2Assembler() { |
| } |
| |
| bool IsThumb() const OVERRIDE { |
| return true; |
| } |
| |
| bool IsForced32Bit() const { |
| return force_32bit_; |
| } |
| |
| bool CanRelocateBranches() const { |
| return can_relocate_branches_; |
| } |
| |
| void FinalizeCode() OVERRIDE; |
| |
| // Data-processing instructions. |
| virtual void and_(Register rd, Register rn, const ShifterOperand& so, |
| Condition cond = AL, SetCc set_cc = kCcDontCare) OVERRIDE; |
| |
| virtual void eor(Register rd, Register rn, const ShifterOperand& so, |
| Condition cond = AL, SetCc set_cc = kCcDontCare) OVERRIDE; |
| |
| virtual void sub(Register rd, Register rn, const ShifterOperand& so, |
| Condition cond = AL, SetCc set_cc = kCcDontCare) OVERRIDE; |
| |
| virtual void rsb(Register rd, Register rn, const ShifterOperand& so, |
| Condition cond = AL, SetCc set_cc = kCcDontCare) OVERRIDE; |
| |
| virtual void add(Register rd, Register rn, const ShifterOperand& so, |
| Condition cond = AL, SetCc set_cc = kCcDontCare) OVERRIDE; |
| |
| virtual void adc(Register rd, Register rn, const ShifterOperand& so, |
| Condition cond = AL, SetCc set_cc = kCcDontCare) OVERRIDE; |
| |
| virtual void sbc(Register rd, Register rn, const ShifterOperand& so, |
| Condition cond = AL, SetCc set_cc = kCcDontCare) OVERRIDE; |
| |
| virtual void rsc(Register rd, Register rn, const ShifterOperand& so, |
| Condition cond = AL, SetCc set_cc = kCcDontCare) OVERRIDE; |
| |
| void tst(Register rn, const ShifterOperand& so, Condition cond = AL) OVERRIDE; |
| |
| void teq(Register rn, const ShifterOperand& so, Condition cond = AL) OVERRIDE; |
| |
| void cmp(Register rn, const ShifterOperand& so, Condition cond = AL) OVERRIDE; |
| |
| void cmn(Register rn, const ShifterOperand& so, Condition cond = AL) OVERRIDE; |
| |
| virtual void orr(Register rd, Register rn, const ShifterOperand& so, |
| Condition cond = AL, SetCc set_cc = kCcDontCare) OVERRIDE; |
| |
| virtual void orn(Register rd, Register rn, const ShifterOperand& so, |
| Condition cond = AL, SetCc set_cc = kCcDontCare) OVERRIDE; |
| |
| virtual void mov(Register rd, const ShifterOperand& so, |
| Condition cond = AL, SetCc set_cc = kCcDontCare) OVERRIDE; |
| |
| virtual void bic(Register rd, Register rn, const ShifterOperand& so, |
| Condition cond = AL, SetCc set_cc = kCcDontCare) OVERRIDE; |
| |
| virtual void mvn(Register rd, const ShifterOperand& so, |
| Condition cond = AL, SetCc set_cc = kCcDontCare) OVERRIDE; |
| |
| // Miscellaneous data-processing instructions. |
| void clz(Register rd, Register rm, Condition cond = AL) OVERRIDE; |
| void movw(Register rd, uint16_t imm16, Condition cond = AL) OVERRIDE; |
| void movt(Register rd, uint16_t imm16, Condition cond = AL) OVERRIDE; |
| void rbit(Register rd, Register rm, Condition cond = AL) OVERRIDE; |
| void rev(Register rd, Register rm, Condition cond = AL) OVERRIDE; |
| void rev16(Register rd, Register rm, Condition cond = AL) OVERRIDE; |
| void revsh(Register rd, Register rm, Condition cond = AL) OVERRIDE; |
| |
| // Multiply instructions. |
| void mul(Register rd, Register rn, Register rm, Condition cond = AL) OVERRIDE; |
| void mla(Register rd, Register rn, Register rm, Register ra, |
| Condition cond = AL) OVERRIDE; |
| void mls(Register rd, Register rn, Register rm, Register ra, |
| Condition cond = AL) OVERRIDE; |
| void smull(Register rd_lo, Register rd_hi, Register rn, Register rm, |
| Condition cond = AL) OVERRIDE; |
| void umull(Register rd_lo, Register rd_hi, Register rn, Register rm, |
| Condition cond = AL) OVERRIDE; |
| |
| void sdiv(Register rd, Register rn, Register rm, Condition cond = AL) OVERRIDE; |
| void udiv(Register rd, Register rn, Register rm, Condition cond = AL) OVERRIDE; |
| |
| // Bit field extract instructions. |
| void sbfx(Register rd, Register rn, uint32_t lsb, uint32_t width, Condition cond = AL) OVERRIDE; |
| void ubfx(Register rd, Register rn, uint32_t lsb, uint32_t width, Condition cond = AL) OVERRIDE; |
| |
| // Load/store instructions. |
| void ldr(Register rd, const Address& ad, Condition cond = AL) OVERRIDE; |
| void str(Register rd, const Address& ad, Condition cond = AL) OVERRIDE; |
| |
| void ldrb(Register rd, const Address& ad, Condition cond = AL) OVERRIDE; |
| void strb(Register rd, const Address& ad, Condition cond = AL) OVERRIDE; |
| |
| void ldrh(Register rd, const Address& ad, Condition cond = AL) OVERRIDE; |
| void strh(Register rd, const Address& ad, Condition cond = AL) OVERRIDE; |
| |
| void ldrsb(Register rd, const Address& ad, Condition cond = AL) OVERRIDE; |
| void ldrsh(Register rd, const Address& ad, Condition cond = AL) OVERRIDE; |
| |
| // Load/store register dual instructions using registers `rd` and `rd` + 1. |
| void ldrd(Register rd, const Address& ad, Condition cond = AL) OVERRIDE; |
| void strd(Register rd, const Address& ad, Condition cond = AL) OVERRIDE; |
| |
| // Load/store register dual instructions using registers `rd` and `rd2`. |
| // Note that contrary to the ARM A1 encoding, the Thumb-2 T1 encoding |
| // does not require `rd` to be even, nor `rd2' to be equal to `rd` + 1. |
| void ldrd(Register rd, Register rd2, const Address& ad, Condition cond); |
| void strd(Register rd, Register rd2, const Address& ad, Condition cond); |
| |
| |
| void ldm(BlockAddressMode am, Register base, |
| RegList regs, Condition cond = AL) OVERRIDE; |
| void stm(BlockAddressMode am, Register base, |
| RegList regs, Condition cond = AL) OVERRIDE; |
| |
| void ldrex(Register rd, Register rn, Condition cond = AL) OVERRIDE; |
| void strex(Register rd, Register rt, Register rn, Condition cond = AL) OVERRIDE; |
| |
| void ldrex(Register rd, Register rn, uint16_t imm, Condition cond = AL); |
| void strex(Register rd, Register rt, Register rn, uint16_t imm, Condition cond = AL); |
| |
| void ldrexd(Register rt, Register rt2, Register rn, Condition cond = AL) OVERRIDE; |
| void strexd(Register rd, Register rt, Register rt2, Register rn, Condition cond = AL) OVERRIDE; |
| |
| // Miscellaneous instructions. |
| void clrex(Condition cond = AL) OVERRIDE; |
| void nop(Condition cond = AL) OVERRIDE; |
| |
| void bkpt(uint16_t imm16) OVERRIDE; |
| void svc(uint32_t imm24) OVERRIDE; |
| |
| // If-then |
| void it(Condition firstcond, ItState i1 = kItOmitted, |
| ItState i2 = kItOmitted, ItState i3 = kItOmitted) OVERRIDE; |
| |
| void cbz(Register rn, Label* target) OVERRIDE; |
| void cbnz(Register rn, Label* target) OVERRIDE; |
| |
| // Floating point instructions (VFPv3-D16 and VFPv3-D32 profiles). |
| void vmovsr(SRegister sn, Register rt, Condition cond = AL) OVERRIDE; |
| void vmovrs(Register rt, SRegister sn, Condition cond = AL) OVERRIDE; |
| void vmovsrr(SRegister sm, Register rt, Register rt2, Condition cond = AL) OVERRIDE; |
| void vmovrrs(Register rt, Register rt2, SRegister sm, Condition cond = AL) OVERRIDE; |
| void vmovdrr(DRegister dm, Register rt, Register rt2, Condition cond = AL) OVERRIDE; |
| void vmovrrd(Register rt, Register rt2, DRegister dm, Condition cond = AL) OVERRIDE; |
| void vmovs(SRegister sd, SRegister sm, Condition cond = AL) OVERRIDE; |
| void vmovd(DRegister dd, DRegister dm, Condition cond = AL) OVERRIDE; |
| |
| // Returns false if the immediate cannot be encoded. |
| bool vmovs(SRegister sd, float s_imm, Condition cond = AL) OVERRIDE; |
| bool vmovd(DRegister dd, double d_imm, Condition cond = AL) OVERRIDE; |
| |
| void vldrs(SRegister sd, const Address& ad, Condition cond = AL) OVERRIDE; |
| void vstrs(SRegister sd, const Address& ad, Condition cond = AL) OVERRIDE; |
| void vldrd(DRegister dd, const Address& ad, Condition cond = AL) OVERRIDE; |
| void vstrd(DRegister dd, const Address& ad, Condition cond = AL) OVERRIDE; |
| |
| void vadds(SRegister sd, SRegister sn, SRegister sm, Condition cond = AL) OVERRIDE; |
| void vaddd(DRegister dd, DRegister dn, DRegister dm, Condition cond = AL) OVERRIDE; |
| void vsubs(SRegister sd, SRegister sn, SRegister sm, Condition cond = AL) OVERRIDE; |
| void vsubd(DRegister dd, DRegister dn, DRegister dm, Condition cond = AL) OVERRIDE; |
| void vmuls(SRegister sd, SRegister sn, SRegister sm, Condition cond = AL) OVERRIDE; |
| void vmuld(DRegister dd, DRegister dn, DRegister dm, Condition cond = AL) OVERRIDE; |
| void vmlas(SRegister sd, SRegister sn, SRegister sm, Condition cond = AL) OVERRIDE; |
| void vmlad(DRegister dd, DRegister dn, DRegister dm, Condition cond = AL) OVERRIDE; |
| void vmlss(SRegister sd, SRegister sn, SRegister sm, Condition cond = AL) OVERRIDE; |
| void vmlsd(DRegister dd, DRegister dn, DRegister dm, Condition cond = AL) OVERRIDE; |
| void vdivs(SRegister sd, SRegister sn, SRegister sm, Condition cond = AL) OVERRIDE; |
| void vdivd(DRegister dd, DRegister dn, DRegister dm, Condition cond = AL) OVERRIDE; |
| |
| void vabss(SRegister sd, SRegister sm, Condition cond = AL) OVERRIDE; |
| void vabsd(DRegister dd, DRegister dm, Condition cond = AL) OVERRIDE; |
| void vnegs(SRegister sd, SRegister sm, Condition cond = AL) OVERRIDE; |
| void vnegd(DRegister dd, DRegister dm, Condition cond = AL) OVERRIDE; |
| void vsqrts(SRegister sd, SRegister sm, Condition cond = AL) OVERRIDE; |
| void vsqrtd(DRegister dd, DRegister dm, Condition cond = AL) OVERRIDE; |
| |
| void vcvtsd(SRegister sd, DRegister dm, Condition cond = AL) OVERRIDE; |
| void vcvtds(DRegister dd, SRegister sm, Condition cond = AL) OVERRIDE; |
| void vcvtis(SRegister sd, SRegister sm, Condition cond = AL) OVERRIDE; |
| void vcvtid(SRegister sd, DRegister dm, Condition cond = AL) OVERRIDE; |
| void vcvtsi(SRegister sd, SRegister sm, Condition cond = AL) OVERRIDE; |
| void vcvtdi(DRegister dd, SRegister sm, Condition cond = AL) OVERRIDE; |
| void vcvtus(SRegister sd, SRegister sm, Condition cond = AL) OVERRIDE; |
| void vcvtud(SRegister sd, DRegister dm, Condition cond = AL) OVERRIDE; |
| void vcvtsu(SRegister sd, SRegister sm, Condition cond = AL) OVERRIDE; |
| void vcvtdu(DRegister dd, SRegister sm, Condition cond = AL) OVERRIDE; |
| |
| void vcmps(SRegister sd, SRegister sm, Condition cond = AL) OVERRIDE; |
| void vcmpd(DRegister dd, DRegister dm, Condition cond = AL) OVERRIDE; |
| void vcmpsz(SRegister sd, Condition cond = AL) OVERRIDE; |
| void vcmpdz(DRegister dd, Condition cond = AL) OVERRIDE; |
| void vmstat(Condition cond = AL) OVERRIDE; // VMRS APSR_nzcv, FPSCR |
| |
| void vpushs(SRegister reg, int nregs, Condition cond = AL) OVERRIDE; |
| void vpushd(DRegister reg, int nregs, Condition cond = AL) OVERRIDE; |
| void vpops(SRegister reg, int nregs, Condition cond = AL) OVERRIDE; |
| void vpopd(DRegister reg, int nregs, Condition cond = AL) OVERRIDE; |
| |
| // Branch instructions. |
| void b(Label* label, Condition cond = AL); |
| void bl(Label* label, Condition cond = AL); |
| void blx(Label* label); |
| void blx(Register rm, Condition cond = AL) OVERRIDE; |
| void bx(Register rm, Condition cond = AL) OVERRIDE; |
| |
| virtual void Lsl(Register rd, Register rm, uint32_t shift_imm, |
| Condition cond = AL, SetCc set_cc = kCcDontCare) OVERRIDE; |
| virtual void Lsr(Register rd, Register rm, uint32_t shift_imm, |
| Condition cond = AL, SetCc set_cc = kCcDontCare) OVERRIDE; |
| virtual void Asr(Register rd, Register rm, uint32_t shift_imm, |
| Condition cond = AL, SetCc set_cc = kCcDontCare) OVERRIDE; |
| virtual void Ror(Register rd, Register rm, uint32_t shift_imm, |
| Condition cond = AL, SetCc set_cc = kCcDontCare) OVERRIDE; |
| virtual void Rrx(Register rd, Register rm, |
| Condition cond = AL, SetCc set_cc = kCcDontCare) OVERRIDE; |
| |
| virtual void Lsl(Register rd, Register rm, Register rn, |
| Condition cond = AL, SetCc set_cc = kCcDontCare) OVERRIDE; |
| virtual void Lsr(Register rd, Register rm, Register rn, |
| Condition cond = AL, SetCc set_cc = kCcDontCare) OVERRIDE; |
| virtual void Asr(Register rd, Register rm, Register rn, |
| Condition cond = AL, SetCc set_cc = kCcDontCare) OVERRIDE; |
| virtual void Ror(Register rd, Register rm, Register rn, |
| Condition cond = AL, SetCc set_cc = kCcDontCare) OVERRIDE; |
| |
| void Push(Register rd, Condition cond = AL) OVERRIDE; |
| void Pop(Register rd, Condition cond = AL) OVERRIDE; |
| |
| void PushList(RegList regs, Condition cond = AL) OVERRIDE; |
| void PopList(RegList regs, Condition cond = AL) OVERRIDE; |
| |
| void Mov(Register rd, Register rm, Condition cond = AL) OVERRIDE; |
| |
| void CompareAndBranchIfZero(Register r, Label* label) OVERRIDE; |
| void CompareAndBranchIfNonZero(Register r, Label* label) OVERRIDE; |
| |
| // Memory barriers. |
| void dmb(DmbOptions flavor) OVERRIDE; |
| |
| // Get the final position of a label after local fixup based on the old position |
| // recorded before FinalizeCode(). |
| uint32_t GetAdjustedPosition(uint32_t old_position) OVERRIDE; |
| |
| using ArmAssembler::NewLiteral; // Make the helper template visible. |
| |
| Literal* NewLiteral(size_t size, const uint8_t* data) OVERRIDE; |
| void LoadLiteral(Register rt, Literal* literal) OVERRIDE; |
| void LoadLiteral(Register rt, Register rt2, Literal* literal) OVERRIDE; |
| void LoadLiteral(SRegister sd, Literal* literal) OVERRIDE; |
| void LoadLiteral(DRegister dd, Literal* literal) OVERRIDE; |
| |
| // Add signed constant value to rd. May clobber IP. |
| void AddConstant(Register rd, Register rn, int32_t value, |
| Condition cond = AL, SetCc set_cc = kCcDontCare) OVERRIDE; |
| |
| void CmpConstant(Register rn, int32_t value, Condition cond = AL) OVERRIDE; |
| |
| // Load and Store. May clobber IP. |
| void LoadImmediate(Register rd, int32_t value, Condition cond = AL) OVERRIDE; |
| void MarkExceptionHandler(Label* label) OVERRIDE; |
| void LoadFromOffset(LoadOperandType type, |
| Register reg, |
| Register base, |
| int32_t offset, |
| Condition cond = AL) OVERRIDE; |
| void StoreToOffset(StoreOperandType type, |
| Register reg, |
| Register base, |
| int32_t offset, |
| Condition cond = AL) OVERRIDE; |
| void LoadSFromOffset(SRegister reg, |
| Register base, |
| int32_t offset, |
| Condition cond = AL) OVERRIDE; |
| void StoreSToOffset(SRegister reg, |
| Register base, |
| int32_t offset, |
| Condition cond = AL) OVERRIDE; |
| void LoadDFromOffset(DRegister reg, |
| Register base, |
| int32_t offset, |
| Condition cond = AL) OVERRIDE; |
| void StoreDToOffset(DRegister reg, |
| Register base, |
| int32_t offset, |
| Condition cond = AL) OVERRIDE; |
| |
| bool ShifterOperandCanHold(Register rd, |
| Register rn, |
| Opcode opcode, |
| uint32_t immediate, |
| SetCc set_cc, |
| ShifterOperand* shifter_op) OVERRIDE; |
| using ArmAssembler::ShifterOperandCanHold; // Don't hide the non-virtual override. |
| |
| bool ShifterOperandCanAlwaysHold(uint32_t immediate) OVERRIDE; |
| |
| |
| static bool IsInstructionForExceptionHandling(uintptr_t pc); |
| |
| // Emit data (e.g. encoded instruction or immediate) to the. |
| // instruction stream. |
| void Emit32(int32_t value); // Emit a 32 bit instruction in thumb format. |
| void Emit16(int16_t value); // Emit a 16 bit instruction in little endian format. |
| void Bind(Label* label) OVERRIDE; |
| |
| void MemoryBarrier(ManagedRegister scratch) OVERRIDE; |
| |
| // Force the assembler to generate 32 bit instructions. |
| void Force32Bit() { |
| force_32bit_ = true; |
| } |
| |
| // Emit an ADR (or a sequence of instructions) to load the jump table address into base_reg. This |
| // will generate a fixup. |
| JumpTable* CreateJumpTable(std::vector<Label*>&& labels, Register base_reg) OVERRIDE; |
| // Emit an ADD PC, X to dispatch a jump-table jump. This will generate a fixup. |
| void EmitJumpTableDispatch(JumpTable* jump_table, Register displacement_reg) OVERRIDE; |
| |
| private: |
| typedef uint16_t FixupId; |
| |
| // Fixup: branches and literal pool references. |
| // |
| // The thumb2 architecture allows branches to be either 16 or 32 bit instructions. This |
| // depends on both the type of branch and the offset to which it is branching. The 16-bit |
| // cbz and cbnz instructions may also need to be replaced with a separate 16-bit compare |
| // instruction and a 16- or 32-bit branch instruction. Load from a literal pool can also be |
| // 16-bit or 32-bit instruction and, if the method is large, we may need to use a sequence |
| // of instructions to make up for the limited range of load literal instructions (up to |
| // 4KiB for the 32-bit variant). When generating code for these insns we don't know the |
| // size before hand, so we assume it is the smallest available size and determine the final |
| // code offsets and sizes and emit code in FinalizeCode(). |
| // |
| // To handle this, we keep a record of every branch and literal pool load in the program. |
| // The actual instruction encoding for these is delayed until we know the final size of |
| // every instruction. When we bind a label to a branch we don't know the final location yet |
| // as some preceding instructions may need to be expanded, so we record a non-final offset. |
| // In FinalizeCode(), we expand the sizes of branches and literal loads that are out of |
| // range. With each expansion, we need to update dependent Fixups, i.e. insntructios with |
| // target on the other side of the expanded insn, as their offsets change and this may |
| // trigger further expansion. |
| // |
| // All Fixups have a 'fixup id' which is a 16 bit unsigned number used to identify the |
| // Fixup. For each unresolved label we keep a singly-linked list of all Fixups pointing |
| // to it, using the fixup ids as links. The first link is stored in the label's position |
| // (the label is linked but not bound), the following links are stored in the code buffer, |
| // in the placeholder where we will eventually emit the actual code. |
| |
| class Fixup { |
| public: |
| // Branch type. |
| enum Type : uint8_t { |
| kConditional, // B<cond>. |
| kUnconditional, // B. |
| kUnconditionalLink, // BL. |
| kUnconditionalLinkX, // BLX. |
| kCompareAndBranchXZero, // cbz/cbnz. |
| kLoadLiteralNarrow, // Load narrrow integer literal. |
| kLoadLiteralWide, // Load wide integer literal. |
| kLoadLiteralAddr, // Load address of literal (used for jump table). |
| kLoadFPLiteralSingle, // Load FP literal single. |
| kLoadFPLiteralDouble, // Load FP literal double. |
| }; |
| |
| // Calculated size of branch instruction based on type and offset. |
| enum Size : uint8_t { |
| // Branch variants. |
| kBranch16Bit, |
| kBranch32Bit, |
| // NOTE: We don't support branches which would require multiple instructions, i.e. |
| // conditinoal branches beyond +-1MiB and unconditional branches beyond +-16MiB. |
| |
| // CBZ/CBNZ variants. |
| kCbxz16Bit, // CBZ/CBNZ rX, label; X < 8; 7-bit positive offset. |
| kCbxz32Bit, // CMP rX, #0 + Bcc label; X < 8; 16-bit Bcc; +-8-bit offset. |
| kCbxz48Bit, // CMP rX, #0 + Bcc label; X < 8; 32-bit Bcc; up to +-1MiB offset. |
| |
| // Load integer literal variants. |
| // LDR rX, label; X < 8; 16-bit variant up to 1KiB offset; 2 bytes. |
| kLiteral1KiB, |
| // LDR rX, label; 32-bit variant up to 4KiB offset; 4 bytes. |
| kLiteral4KiB, |
| // MOV rX, imm16 + ADD rX, pc + LDR rX, [rX]; X < 8; up to 64KiB offset; 8 bytes. |
| kLiteral64KiB, |
| // MOV rX, modimm + ADD rX, pc + LDR rX, [rX, #imm12]; up to 1MiB offset; 10 bytes. |
| kLiteral1MiB, |
| // NOTE: We don't provide the 12-byte version of kLiteralFar below where the LDR is 16-bit. |
| // MOV rX, imm16 + MOVT rX, imm16 + ADD rX, pc + LDR rX, [rX]; any offset; 14 bytes. |
| kLiteralFar, |
| |
| // Load literal base addr. |
| // ADR rX, label; X < 8; 8 bit immediate, shifted to 10 bit. 2 bytes. |
| kLiteralAddr1KiB, |
| // ADR rX, label; 4KiB offset. 4 bytes. |
| kLiteralAddr4KiB, |
| // MOV rX, imm16 + ADD rX, pc; 64KiB offset. 6 bytes. |
| kLiteralAddr64KiB, |
| // MOV rX, imm16 + MOVT rX, imm16 + ADD rX, pc; any offset; 10 bytes. |
| kLiteralAddrFar, |
| |
| // Load long or FP literal variants. |
| // VLDR s/dX, label; 32-bit insn, up to 1KiB offset; 4 bytes. |
| kLongOrFPLiteral1KiB, |
| // MOV ip, modimm + ADD ip, pc + VLDR s/dX, [IP, #imm8*4]; up to 256KiB offset; 10 bytes. |
| kLongOrFPLiteral256KiB, |
| // MOV ip, imm16 + MOVT ip, imm16 + ADD ip, pc + VLDR s/dX, [IP]; any offset; 14 bytes. |
| kLongOrFPLiteralFar, |
| }; |
| |
| // Unresolved branch possibly with a condition. |
| static Fixup Branch(uint32_t location, Type type, Size size = kBranch16Bit, |
| Condition cond = AL) { |
| DCHECK(type == kConditional || type == kUnconditional || |
| type == kUnconditionalLink || type == kUnconditionalLinkX); |
| DCHECK(size == kBranch16Bit || size == kBranch32Bit); |
| DCHECK(size == kBranch32Bit || (type == kConditional || type == kUnconditional)); |
| return Fixup(kNoRegister, kNoRegister, kNoSRegister, kNoDRegister, |
| cond, type, size, location); |
| } |
| |
| // Unresolved compare-and-branch instruction with a register and condition (EQ or NE). |
| static Fixup CompareAndBranch(uint32_t location, Register rn, Condition cond) { |
| DCHECK(cond == EQ || cond == NE); |
| return Fixup(rn, kNoRegister, kNoSRegister, kNoDRegister, |
| cond, kCompareAndBranchXZero, kCbxz16Bit, location); |
| } |
| |
| // Load narrow literal. |
| static Fixup LoadNarrowLiteral(uint32_t location, Register rt, Size size) { |
| DCHECK(size == kLiteral1KiB || size == kLiteral4KiB || size == kLiteral64KiB || |
| size == kLiteral1MiB || size == kLiteralFar); |
| DCHECK(!IsHighRegister(rt) || (size != kLiteral1KiB && size != kLiteral64KiB)); |
| return Fixup(rt, kNoRegister, kNoSRegister, kNoDRegister, |
| AL, kLoadLiteralNarrow, size, location); |
| } |
| |
| // Load wide literal. |
| static Fixup LoadWideLiteral(uint32_t location, Register rt, Register rt2, |
| Size size = kLongOrFPLiteral1KiB) { |
| DCHECK(size == kLongOrFPLiteral1KiB || size == kLongOrFPLiteral256KiB || |
| size == kLongOrFPLiteralFar); |
| DCHECK(!IsHighRegister(rt) || (size != kLiteral1KiB && size != kLiteral64KiB)); |
| return Fixup(rt, rt2, kNoSRegister, kNoDRegister, |
| AL, kLoadLiteralWide, size, location); |
| } |
| |
| // Load FP single literal. |
| static Fixup LoadSingleLiteral(uint32_t location, SRegister sd, |
| Size size = kLongOrFPLiteral1KiB) { |
| DCHECK(size == kLongOrFPLiteral1KiB || size == kLongOrFPLiteral256KiB || |
| size == kLongOrFPLiteralFar); |
| return Fixup(kNoRegister, kNoRegister, sd, kNoDRegister, |
| AL, kLoadFPLiteralSingle, size, location); |
| } |
| |
| // Load FP double literal. |
| static Fixup LoadDoubleLiteral(uint32_t location, DRegister dd, |
| Size size = kLongOrFPLiteral1KiB) { |
| DCHECK(size == kLongOrFPLiteral1KiB || size == kLongOrFPLiteral256KiB || |
| size == kLongOrFPLiteralFar); |
| return Fixup(kNoRegister, kNoRegister, kNoSRegister, dd, |
| AL, kLoadFPLiteralDouble, size, location); |
| } |
| |
| static Fixup LoadLiteralAddress(uint32_t location, Register rt, Size size) { |
| DCHECK(size == kLiteralAddr1KiB || size == kLiteralAddr4KiB || size == kLiteralAddr64KiB || |
| size == kLiteralAddrFar); |
| DCHECK(!IsHighRegister(rt) || size != kLiteralAddr1KiB); |
| return Fixup(rt, kNoRegister, kNoSRegister, kNoDRegister, |
| AL, kLoadLiteralAddr, size, location); |
| } |
| |
| Type GetType() const { |
| return type_; |
| } |
| |
| bool IsLoadLiteral() const { |
| return GetType() >= kLoadLiteralNarrow; |
| } |
| |
| // Returns whether the Fixup can expand from the original size. |
| bool CanExpand() const { |
| switch (GetOriginalSize()) { |
| case kBranch32Bit: |
| case kCbxz48Bit: |
| case kLiteralFar: |
| case kLiteralAddrFar: |
| case kLongOrFPLiteralFar: |
| return false; |
| default: |
| return true; |
| } |
| } |
| |
| Size GetOriginalSize() const { |
| return original_size_; |
| } |
| |
| Size GetSize() const { |
| return size_; |
| } |
| |
| uint32_t GetOriginalSizeInBytes() const; |
| |
| uint32_t GetSizeInBytes() const; |
| |
| uint32_t GetLocation() const { |
| return location_; |
| } |
| |
| uint32_t GetAdjustment() const { |
| return adjustment_; |
| } |
| |
| // Prepare the assembler->fixup_dependents_ and each Fixup's dependents_start_/count_. |
| static void PrepareDependents(Thumb2Assembler* assembler); |
| |
| ArrayRef<const FixupId> Dependents(const Thumb2Assembler& assembler) const { |
| return ArrayRef<const FixupId>(assembler.fixup_dependents_).SubArray(dependents_start_, |
| dependents_count_); |
| } |
| |
| // Resolve a branch when the target is known. |
| void Resolve(uint32_t target) { |
| DCHECK_EQ(target_, kUnresolved); |
| DCHECK_NE(target, kUnresolved); |
| target_ = target; |
| } |
| |
| // Check if the current size is OK for current location_, target_ and adjustment_. |
| // If not, increase the size. Return the size increase, 0 if unchanged. |
| // If the target if after this Fixup, also add the difference to adjustment_, |
| // so that we don't need to consider forward Fixups as their own dependencies. |
| uint32_t AdjustSizeIfNeeded(uint32_t current_code_size); |
| |
| // Increase adjustments. This is called for dependents of a Fixup when its size changes. |
| void IncreaseAdjustment(uint32_t increase) { |
| adjustment_ += increase; |
| } |
| |
| // Finalize the branch with an adjustment to the location. Both location and target are updated. |
| void Finalize(uint32_t location_adjustment) { |
| DCHECK_NE(target_, kUnresolved); |
| location_ += location_adjustment; |
| target_ += location_adjustment; |
| } |
| |
| // Emit the branch instruction into the assembler buffer. This does the |
| // encoding into the thumb instruction. |
| void Emit(AssemblerBuffer* buffer, uint32_t code_size) const; |
| |
| private: |
| Fixup(Register rn, Register rt2, SRegister sd, DRegister dd, |
| Condition cond, Type type, Size size, uint32_t location) |
| : rn_(rn), |
| rt2_(rt2), |
| sd_(sd), |
| dd_(dd), |
| cond_(cond), |
| type_(type), |
| original_size_(size), size_(size), |
| location_(location), |
| target_(kUnresolved), |
| adjustment_(0u), |
| dependents_count_(0u), |
| dependents_start_(0u) { |
| } |
| |
| static size_t SizeInBytes(Size size); |
| |
| // The size of padding added before the literal pool. |
| static size_t LiteralPoolPaddingSize(uint32_t current_code_size); |
| |
| // Returns the offset from the PC-using insn to the target. |
| int32_t GetOffset(uint32_t current_code_size) const; |
| |
| size_t IncreaseSize(Size new_size); |
| |
| int32_t LoadWideOrFpEncoding(Register rbase, int32_t offset) const; |
| |
| template <typename Function> |
| static void ForExpandableDependencies(Thumb2Assembler* assembler, Function fn); |
| |
| static constexpr uint32_t kUnresolved = 0xffffffff; // Value for target_ for unresolved. |
| |
| const Register rn_; // Rn for cbnz/cbz, Rt for literal loads. |
| Register rt2_; // For kLoadLiteralWide. |
| SRegister sd_; // For kLoadFPLiteralSingle. |
| DRegister dd_; // For kLoadFPLiteralDouble. |
| const Condition cond_; |
| const Type type_; |
| Size original_size_; |
| Size size_; |
| uint32_t location_; // Offset into assembler buffer in bytes. |
| uint32_t target_; // Offset into assembler buffer in bytes. |
| uint32_t adjustment_; // The number of extra bytes inserted between location_ and target_. |
| // Fixups that require adjustment when current size changes are stored in a single |
| // array in the assembler and we store only the start index and count here. |
| uint32_t dependents_count_; |
| uint32_t dependents_start_; |
| }; |
| |
| // Emit a single 32 or 16 bit data processing instruction. |
| void EmitDataProcessing(Condition cond, |
| Opcode opcode, |
| SetCc set_cc, |
| Register rn, |
| Register rd, |
| const ShifterOperand& so); |
| |
| // Emit a single 32 bit miscellaneous instruction. |
| void Emit32Miscellaneous(uint8_t op1, |
| uint8_t op2, |
| uint32_t rest_encoding); |
| |
| // Emit reverse byte instructions: rev, rev16, revsh. |
| void EmitReverseBytes(Register rd, Register rm, uint32_t op); |
| |
| // Emit a single 16 bit miscellaneous instruction. |
| void Emit16Miscellaneous(uint32_t rest_encoding); |
| |
| // Must the instruction be 32 bits or can it possibly be encoded |
| // in 16 bits? |
| bool Is32BitDataProcessing(Condition cond, |
| Opcode opcode, |
| SetCc set_cc, |
| Register rn, |
| Register rd, |
| const ShifterOperand& so); |
| |
| // Emit a 32 bit data processing instruction. |
| void Emit32BitDataProcessing(Condition cond, |
| Opcode opcode, |
| SetCc set_cc, |
| Register rn, |
| Register rd, |
| const ShifterOperand& so); |
| |
| // Emit a 16 bit data processing instruction. |
| void Emit16BitDataProcessing(Condition cond, |
| Opcode opcode, |
| SetCc set_cc, |
| Register rn, |
| Register rd, |
| const ShifterOperand& so); |
| |
| void Emit16BitAddSub(Condition cond, |
| Opcode opcode, |
| SetCc set_cc, |
| Register rn, |
| Register rd, |
| const ShifterOperand& so); |
| |
| uint16_t EmitCompareAndBranch(Register rn, uint16_t prev, bool n); |
| |
| void EmitLoadStore(Condition cond, |
| bool load, |
| bool byte, |
| bool half, |
| bool is_signed, |
| Register rd, |
| const Address& ad); |
| |
| void EmitMemOpAddressMode3(Condition cond, |
| int32_t mode, |
| Register rd, |
| const Address& ad); |
| |
| void EmitMultiMemOp(Condition cond, |
| BlockAddressMode am, |
| bool load, |
| Register base, |
| RegList regs); |
| |
| void EmitMulOp(Condition cond, |
| int32_t opcode, |
| Register rd, |
| Register rn, |
| Register rm, |
| Register rs); |
| |
| void EmitVFPsss(Condition cond, |
| int32_t opcode, |
| SRegister sd, |
| SRegister sn, |
| SRegister sm); |
| |
| void EmitVFPddd(Condition cond, |
| int32_t opcode, |
| DRegister dd, |
| DRegister dn, |
| DRegister dm); |
| |
| void EmitVFPsd(Condition cond, |
| int32_t opcode, |
| SRegister sd, |
| DRegister dm); |
| |
| void EmitVFPds(Condition cond, |
| int32_t opcode, |
| DRegister dd, |
| SRegister sm); |
| |
| void EmitVPushPop(uint32_t reg, int nregs, bool push, bool dbl, Condition cond); |
| |
| void EmitBranch(Condition cond, Label* label, bool link, bool x); |
| static int32_t EncodeBranchOffset(int32_t offset, int32_t inst); |
| static int DecodeBranchOffset(int32_t inst); |
| void EmitShift(Register rd, Register rm, Shift shift, uint8_t amount, |
| Condition cond = AL, SetCc set_cc = kCcDontCare); |
| void EmitShift(Register rd, Register rn, Shift shift, Register rm, |
| Condition cond = AL, SetCc set_cc = kCcDontCare); |
| |
| static int32_t GetAllowedLoadOffsetBits(LoadOperandType type); |
| static int32_t GetAllowedStoreOffsetBits(StoreOperandType type); |
| bool CanSplitLoadStoreOffset(int32_t allowed_offset_bits, |
| int32_t offset, |
| /*out*/ int32_t* add_to_base, |
| /*out*/ int32_t* offset_for_load_store); |
| int32_t AdjustLoadStoreOffset(int32_t allowed_offset_bits, |
| Register temp, |
| Register base, |
| int32_t offset, |
| Condition cond); |
| |
| // Whether the assembler can relocate branches. If false, unresolved branches will be |
| // emitted on 32bits. |
| bool can_relocate_branches_; |
| |
| // Force the assembler to use 32 bit thumb2 instructions. |
| bool force_32bit_; |
| |
| // IfThen conditions. Used to check that conditional instructions match the preceding IT. |
| Condition it_conditions_[4]; |
| uint8_t it_cond_index_; |
| Condition next_condition_; |
| |
| void SetItCondition(ItState s, Condition cond, uint8_t index); |
| |
| void CheckCondition(Condition cond) { |
| CHECK_EQ(cond, next_condition_); |
| |
| // Move to the next condition if there is one. |
| if (it_cond_index_ < 3) { |
| ++it_cond_index_; |
| next_condition_ = it_conditions_[it_cond_index_]; |
| } else { |
| next_condition_ = AL; |
| } |
| } |
| |
| void CheckConditionLastIt(Condition cond) { |
| if (it_cond_index_ < 3) { |
| // Check that the next condition is AL. This means that the |
| // current condition is the last in the IT block. |
| CHECK_EQ(it_conditions_[it_cond_index_ + 1], AL); |
| } |
| CheckCondition(cond); |
| } |
| |
| FixupId AddFixup(Fixup fixup) { |
| FixupId fixup_id = static_cast<FixupId>(fixups_.size()); |
| fixups_.push_back(fixup); |
| // For iterating using FixupId, we need the next id to be representable. |
| DCHECK_EQ(static_cast<size_t>(static_cast<FixupId>(fixups_.size())), fixups_.size()); |
| return fixup_id; |
| } |
| |
| Fixup* GetFixup(FixupId fixup_id) { |
| DCHECK_LT(fixup_id, fixups_.size()); |
| return &fixups_[fixup_id]; |
| } |
| |
| void BindLabel(Label* label, uint32_t bound_pc); |
| uint32_t BindLiterals(); |
| void BindJumpTables(uint32_t code_size); |
| void AdjustFixupIfNeeded(Fixup* fixup, uint32_t* current_code_size, |
| std::deque<FixupId>* fixups_to_recalculate); |
| uint32_t AdjustFixups(); |
| void EmitFixups(uint32_t adjusted_code_size); |
| void EmitLiterals(); |
| void EmitJumpTables(); |
| void PatchCFI(); |
| |
| static int16_t BEncoding16(int32_t offset, Condition cond); |
| static int32_t BEncoding32(int32_t offset, Condition cond); |
| static int16_t CbxzEncoding16(Register rn, int32_t offset, Condition cond); |
| static int16_t CmpRnImm8Encoding16(Register rn, int32_t value); |
| static int16_t AddRdnRmEncoding16(Register rdn, Register rm); |
| static int32_t MovwEncoding32(Register rd, int32_t value); |
| static int32_t MovtEncoding32(Register rd, int32_t value); |
| static int32_t MovModImmEncoding32(Register rd, int32_t value); |
| static int16_t LdrLitEncoding16(Register rt, int32_t offset); |
| static int32_t LdrLitEncoding32(Register rt, int32_t offset); |
| static int32_t LdrdEncoding32(Register rt, Register rt2, Register rn, int32_t offset); |
| static int32_t VldrsEncoding32(SRegister sd, Register rn, int32_t offset); |
| static int32_t VldrdEncoding32(DRegister dd, Register rn, int32_t offset); |
| static int16_t LdrRtRnImm5Encoding16(Register rt, Register rn, int32_t offset); |
| static int32_t LdrRtRnImm12Encoding(Register rt, Register rn, int32_t offset); |
| static int16_t AdrEncoding16(Register rd, int32_t offset); |
| static int32_t AdrEncoding32(Register rd, int32_t offset); |
| |
| ArenaVector<Fixup> fixups_; |
| ArenaVector<FixupId> fixup_dependents_; |
| |
| // Use std::deque<> for literal labels to allow insertions at the end |
| // without invalidating pointers and references to existing elements. |
| ArenaDeque<Literal> literals_; |
| |
| // Jump table list. |
| ArenaDeque<JumpTable> jump_tables_; |
| |
| // Data for AdjustedPosition(), see the description there. |
| uint32_t last_position_adjustment_; |
| uint32_t last_old_position_; |
| FixupId last_fixup_id_; |
| }; |
| |
| } // namespace arm |
| } // namespace art |
| |
| #endif // ART_COMPILER_UTILS_ARM_ASSEMBLER_THUMB2_H_ |