1 //===-- ARMUtils.h ----------------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #ifndef lldb_ARMUtils_h_
11 #define lldb_ARMUtils_h_
13 #include "ARMDefines.h"
14 #include "InstructionUtils.h"
15 #include "llvm/Support/MathExtras.h" // for SignExtend64 template function
17 // Common utilities for the ARM/Thumb Instruction Set Architecture.
19 namespace lldb_private {
21 static inline uint32_t Align(uint32_t val, uint32_t alignment)
23 return alignment * (val / alignment);
26 static inline uint32_t DecodeImmShift(const uint32_t type, const uint32_t imm5, ARM_ShifterType &shift_t)
31 //assert(0 && "Invalid shift type");
37 return (imm5 == 0 ? 32 : imm5);
40 return (imm5 == 0 ? 32 : imm5);
53 shift_t = SRType_Invalid;
58 // A8.6.35 CMP (register) -- Encoding T3
59 // Convenience function.
60 static inline uint32_t DecodeImmShiftThumb(const uint32_t opcode, ARM_ShifterType &shift_t)
62 return DecodeImmShift(Bits32(opcode, 5, 4), Bits32(opcode, 14, 12)<<2 | Bits32(opcode, 7, 6), shift_t);
65 // A8.6.35 CMP (register) -- Encoding A1
66 // Convenience function.
67 static inline uint32_t DecodeImmShiftARM(const uint32_t opcode, ARM_ShifterType &shift_t)
69 return DecodeImmShift(Bits32(opcode, 6, 5), Bits32(opcode, 11, 7), shift_t);
72 static inline uint32_t DecodeImmShift(const ARM_ShifterType shift_t, const uint32_t imm5)
74 ARM_ShifterType dont_care;
75 return DecodeImmShift(shift_t, imm5, dont_care);
78 static inline ARM_ShifterType DecodeRegShift(const uint32_t type)
82 //assert(0 && "Invalid shift type");
83 return SRType_Invalid;
95 static inline uint32_t LSL_C(const uint32_t value, const uint32_t amount, uint32_t &carry_out, bool *success)
102 carry_out = amount <= 32 ? Bit32(value, 32 - amount) : 0;
103 return value << amount;
106 static inline uint32_t LSL(const uint32_t value, const uint32_t amount, bool *success)
112 uint32_t result = LSL_C(value, amount, dont_care, success);
119 static inline uint32_t LSR_C(const uint32_t value, const uint32_t amount, uint32_t &carry_out, bool *success)
126 carry_out = amount <= 32 ? Bit32(value, amount - 1) : 0;
127 return value >> amount;
130 static inline uint32_t LSR(const uint32_t value, const uint32_t amount, bool *success)
136 uint32_t result = LSR_C(value, amount, dont_care, success);
143 static inline uint32_t ASR_C(const uint32_t value, const uint32_t amount, uint32_t &carry_out, bool *success)
145 if (amount == 0 || amount > 32) {
150 bool negative = BitIsSet(value, 31);
153 carry_out = Bit32(value, amount - 1);
154 int64_t extended = llvm::SignExtend64<32>(value);
155 return UnsignedBits(extended, amount + 31, amount);
159 carry_out = (negative ? 1 : 0);
160 return (negative ? 0xffffffff : 0);
164 static inline uint32_t ASR(const uint32_t value, const uint32_t amount, bool *success)
170 uint32_t result = ASR_C(value, amount, dont_care, success);
177 static inline uint32_t ROR_C(const uint32_t value, const uint32_t amount, uint32_t &carry_out, bool *success)
184 uint32_t amt = amount % 32;
185 uint32_t result = Rotr32(value, amt);
186 carry_out = Bit32(value, 31);
190 static inline uint32_t ROR(const uint32_t value, const uint32_t amount, bool *success)
196 uint32_t result = ROR_C(value, amount, dont_care, success);
203 static inline uint32_t RRX_C(const uint32_t value, const uint32_t carry_in, uint32_t &carry_out, bool *success)
206 carry_out = Bit32(value, 0);
207 return Bit32(carry_in, 0) << 31 | Bits32(value, 31, 1);
210 static inline uint32_t RRX(const uint32_t value, const uint32_t carry_in, bool *success)
214 uint32_t result = RRX_C(value, carry_in, dont_care, success);
221 static inline uint32_t Shift_C(const uint32_t value, ARM_ShifterType type, const uint32_t amount,
222 const uint32_t carry_in, uint32_t &carry_out, bool *success)
224 if (type == SRType_RRX && amount != 1) {
231 carry_out = carry_in;
237 result = LSL_C(value, amount, carry_out, success);
240 result = LSR_C(value, amount, carry_out, success);
243 result = ASR_C(value, amount, carry_out, success);
246 result = ROR_C(value, amount, carry_out, success);
249 result = RRX_C(value, carry_in, carry_out, success);
261 static inline uint32_t Shift(const uint32_t value, ARM_ShifterType type, const uint32_t amount,
262 const uint32_t carry_in, bool *success)
264 // Don't care about carry out in this case.
266 uint32_t result = Shift_C(value, type, amount, carry_in, dont_care, success);
273 static inline uint32_t bits(const uint32_t val, const uint32_t msbit, const uint32_t lsbit)
275 return Bits32(val, msbit, lsbit);
278 static inline uint32_t bit(const uint32_t val, const uint32_t msbit)
280 return bits(val, msbit, msbit);
283 static uint32_t ror(uint32_t val, uint32_t N, uint32_t shift)
285 uint32_t m = shift % N;
286 return (val >> m) | (val << (N - m));
289 // (imm32, carry_out) = ARMExpandImm_C(imm12, carry_in)
290 static inline uint32_t ARMExpandImm_C(uint32_t opcode, uint32_t carry_in, uint32_t &carry_out)
292 uint32_t imm32; // the expanded result
293 uint32_t imm = bits(opcode, 7, 0); // immediate value
294 uint32_t amt = 2 * bits(opcode, 11, 8); // rotate amount
298 carry_out = carry_in;
302 imm32 = ror(imm, 32, amt);
303 carry_out = Bit32(imm32, 31);
308 static inline uint32_t ARMExpandImm(uint32_t opcode)
310 // 'carry_in' argument to following function call does not affect the imm32 result.
311 uint32_t carry_in = 0;
313 return ARMExpandImm_C(opcode, carry_in, carry_out);
316 // (imm32, carry_out) = ThumbExpandImm_C(imm12, carry_in)
317 static inline uint32_t ThumbExpandImm_C(uint32_t opcode, uint32_t carry_in, uint32_t &carry_out)
319 uint32_t imm32; // the expaned result
320 const uint32_t i = bit(opcode, 26);
321 const uint32_t imm3 = bits(opcode, 14, 12);
322 const uint32_t abcdefgh = bits(opcode, 7, 0);
323 const uint32_t imm12 = i << 11 | imm3 << 8 | abcdefgh;
325 if (bits(imm12, 11, 10) == 0)
327 switch (bits(imm12, 9, 8)) {
328 default: // Keep static analyzer happy with a default case
334 imm32 = abcdefgh << 16 | abcdefgh;
338 imm32 = abcdefgh << 24 | abcdefgh << 8;
342 imm32 = abcdefgh << 24 | abcdefgh << 16 | abcdefgh << 8 | abcdefgh;
345 carry_out = carry_in;
349 const uint32_t unrotated_value = 0x80 | bits(imm12, 6, 0);
350 imm32 = ror(unrotated_value, 32, bits(imm12, 11, 7));
351 carry_out = Bit32(imm32, 31);
356 static inline uint32_t ThumbExpandImm(uint32_t opcode)
358 // 'carry_in' argument to following function call does not affect the imm32 result.
359 uint32_t carry_in = 0;
361 return ThumbExpandImm_C(opcode, carry_in, carry_out);
364 // imm32 = ZeroExtend(i:imm3:imm8, 32)
365 static inline uint32_t ThumbImm12(uint32_t opcode)
367 const uint32_t i = bit(opcode, 26);
368 const uint32_t imm3 = bits(opcode, 14, 12);
369 const uint32_t imm8 = bits(opcode, 7, 0);
370 const uint32_t imm12 = i << 11 | imm3 << 8 | imm8;
374 // imm32 = ZeroExtend(imm7:'00', 32)
375 static inline uint32_t ThumbImm7Scaled(uint32_t opcode)
377 const uint32_t imm7 = bits(opcode, 6, 0);
381 // imm32 = ZeroExtend(imm8:'00', 32)
382 static inline uint32_t ThumbImm8Scaled(uint32_t opcode)
384 const uint32_t imm8 = bits(opcode, 7, 0);
388 // This function performs the check for the register numbers 13 and 15 that are
389 // not permitted for many Thumb register specifiers.
390 static inline bool BadReg(uint32_t n) { return n == 13 || n == 15; }
392 } // namespace lldb_private
394 #endif // lldb_ARMUtils_h_