← Back to branch summary

~ubuntu-branches/ubuntu/vivid/qemu/vivid

« back to all changes in this revision

Viewing changes to disas/libvixl/a64/instructions-a64.h

  • Committer: Package Import Robot
  • Author(s): dann frazier
  • Date: 2014-02-11 15:41:53 UTC
  • Revision ID: package-import@ubuntu.com-20140211154153-2d001tf0ium08u81
Tags: 1.7.0+dfsg-3ubuntu2
* Backport changes to enable qemu-user-static support for aarch64
* debian/control: add ppc64el to Architectures
* debian/rules: only install qemu-system-aarch64 on arm64.
  Fixes a FTBFS  when built twice in a row on non-arm64 due to a stale
  debian/qemu-system-aarch64 directory

Show diffs side-by-side

added added

removed removed

Lines of Context:
disas/libvixl/a64/instructions-a64.h
 
1
// Copyright 2013, ARM Limited
 
2
// All rights reserved.
 
3
//
 
4
// Redistribution and use in source and binary forms, with or without
 
5
// modification, are permitted provided that the following conditions are met:
 
6
//
 
7
//   * Redistributions of source code must retain the above copyright notice,
 
8
//     this list of conditions and the following disclaimer.
 
9
//   * Redistributions in binary form must reproduce the above copyright notice,
 
10
//     this list of conditions and the following disclaimer in the documentation
 
11
//     and/or other materials provided with the distribution.
 
12
//   * Neither the name of ARM Limited nor the names of its contributors may be
 
13
//     used to endorse or promote products derived from this software without
 
14
//     specific prior written permission.
 
15
//
 
16
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS CONTRIBUTORS "AS IS" AND
 
17
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 
18
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 
19
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 
20
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 
21
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 
22
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 
23
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 
24
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
25
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
26
 
 
27
#ifndef VIXL_A64_INSTRUCTIONS_A64_H_
 
28
#define VIXL_A64_INSTRUCTIONS_A64_H_
 
29
 
 
30
#include "globals.h"
 
31
#include "utils.h"
 
32
#include "a64/constants-a64.h"
 
33
 
 
34
namespace vixl {
 
35
// ISA constants. --------------------------------------------------------------
 
36
 
 
37
typedef uint32_t Instr;
 
38
const unsigned kInstructionSize = 4;
 
39
const unsigned kInstructionSizeLog2 = 2;
 
40
const unsigned kLiteralEntrySize = 4;
 
41
const unsigned kLiteralEntrySizeLog2 = 2;
 
42
const unsigned kMaxLoadLiteralRange = 1 * MBytes;
 
43
 
 
44
const unsigned kWRegSize = 32;
 
45
const unsigned kWRegSizeLog2 = 5;
 
46
const unsigned kWRegSizeInBytes = kWRegSize / 8;
 
47
const unsigned kXRegSize = 64;
 
48
const unsigned kXRegSizeLog2 = 6;
 
49
const unsigned kXRegSizeInBytes = kXRegSize / 8;
 
50
const unsigned kSRegSize = 32;
 
51
const unsigned kSRegSizeLog2 = 5;
 
52
const unsigned kSRegSizeInBytes = kSRegSize / 8;
 
53
const unsigned kDRegSize = 64;
 
54
const unsigned kDRegSizeLog2 = 6;
 
55
const unsigned kDRegSizeInBytes = kDRegSize / 8;
 
56
const int64_t kWRegMask = 0x00000000ffffffffLL;
 
57
const int64_t kXRegMask = 0xffffffffffffffffLL;
 
58
const int64_t kSRegMask = 0x00000000ffffffffLL;
 
59
const int64_t kDRegMask = 0xffffffffffffffffLL;
 
60
const int64_t kXSignMask = 0x1LL << 63;
 
61
const int64_t kWSignMask = 0x1LL << 31;
 
62
const int64_t kByteMask = 0xffL;
 
63
const int64_t kHalfWordMask = 0xffffL;
 
64
const int64_t kWordMask = 0xffffffffLL;
 
65
const uint64_t kXMaxUInt = 0xffffffffffffffffULL;
 
66
const uint64_t kWMaxUInt = 0xffffffffULL;
 
67
const int64_t kXMaxInt = 0x7fffffffffffffffLL;
 
68
const int64_t kXMinInt = 0x8000000000000000LL;
 
69
const int32_t kWMaxInt = 0x7fffffff;
 
70
const int32_t kWMinInt = 0x80000000;
 
71
const unsigned kLinkRegCode = 30;
 
72
const unsigned kZeroRegCode = 31;
 
73
const unsigned kSPRegInternalCode = 63;
 
74
const unsigned kRegCodeMask = 0x1f;
 
75
 
 
76
// AArch64 floating-point specifics. These match IEEE-754.
 
77
const unsigned kDoubleMantissaBits = 52;
 
78
const unsigned kDoubleExponentBits = 11;
 
79
const unsigned kFloatMantissaBits = 23;
 
80
const unsigned kFloatExponentBits = 8;
 
81
 
 
82
const float kFP32PositiveInfinity = rawbits_to_float(0x7f800000);
 
83
const float kFP32NegativeInfinity = rawbits_to_float(0xff800000);
 
84
const double kFP64PositiveInfinity = rawbits_to_double(0x7ff0000000000000ULL);
 
85
const double kFP64NegativeInfinity = rawbits_to_double(0xfff0000000000000ULL);
 
86
 
 
87
// This value is a signalling NaN as both a double and as a float (taking the
 
88
// least-significant word).
 
89
static const double kFP64SignallingNaN = rawbits_to_double(0x7ff000007f800001ULL);
 
90
static const float kFP32SignallingNaN = rawbits_to_float(0x7f800001);
 
91
 
 
92
// A similar value, but as a quiet NaN.
 
93
static const double kFP64QuietNaN = rawbits_to_double(0x7ff800007fc00001ULL);
 
94
static const float kFP32QuietNaN = rawbits_to_float(0x7fc00001);
 
95
 
 
96
enum LSDataSize {
 
97
  LSByte        = 0,
 
98
  LSHalfword    = 1,
 
99
  LSWord        = 2,
 
100
  LSDoubleWord  = 3
 
101
};
 
102
 
 
103
LSDataSize CalcLSPairDataSize(LoadStorePairOp op);
 
104
 
 
105
enum ImmBranchType {
 
106
  UnknownBranchType = 0,
 
107
  CondBranchType    = 1,
 
108
  UncondBranchType  = 2,
 
109
  CompareBranchType = 3,
 
110
  TestBranchType    = 4
 
111
};
 
112
 
 
113
enum AddrMode {
 
114
  Offset,
 
115
  PreIndex,
 
116
  PostIndex
 
117
};
 
118
 
 
119
enum FPRounding {
 
120
  // The first four values are encodable directly by FPCR<RMode>.
 
121
  FPTieEven = 0x0,
 
122
  FPPositiveInfinity = 0x1,
 
123
  FPNegativeInfinity = 0x2,
 
124
  FPZero = 0x3,
 
125
 
 
126
  // The final rounding mode is only available when explicitly specified by the
 
127
  // instruction (such as with fcvta). It cannot be set in FPCR.
 
128
  FPTieAway
 
129
};
 
130
 
 
131
enum Reg31Mode {
 
132
  Reg31IsStackPointer,
 
133
  Reg31IsZeroRegister
 
134
};
 
135
 
 
136
// Instructions. ---------------------------------------------------------------
 
137
 
 
138
class Instruction {
 
139
 public:
 
140
  inline Instr InstructionBits() const {
 
141
    return *(reinterpret_cast<const Instr*>(this));
 
142
  }
 
143
 
 
144
  inline void SetInstructionBits(Instr new_instr) {
 
145
    *(reinterpret_cast<Instr*>(this)) = new_instr;
 
146
  }
 
147
 
 
148
  inline int Bit(int pos) const {
 
149
    return (InstructionBits() >> pos) & 1;
 
150
  }
 
151
 
 
152
  inline uint32_t Bits(int msb, int lsb) const {
 
153
    return unsigned_bitextract_32(msb, lsb, InstructionBits());
 
154
  }
 
155
 
 
156
  inline int32_t SignedBits(int msb, int lsb) const {
 
157
    int32_t bits = *(reinterpret_cast<const int32_t*>(this));
 
158
    return signed_bitextract_32(msb, lsb, bits);
 
159
  }
 
160
 
 
161
  inline Instr Mask(uint32_t mask) const {
 
162
    return InstructionBits() & mask;
 
163
  }
 
164
 
 
165
  #define DEFINE_GETTER(Name, HighBit, LowBit, Func)             \
 
166
  inline int64_t Name() const { return Func(HighBit, LowBit); }
 
167
  INSTRUCTION_FIELDS_LIST(DEFINE_GETTER)
 
168
  #undef DEFINE_GETTER
 
169
 
 
170
  // ImmPCRel is a compound field (not present in INSTRUCTION_FIELDS_LIST),
 
171
  // formed from ImmPCRelLo and ImmPCRelHi.
 
172
  int ImmPCRel() const {
 
173
    int const offset = ((ImmPCRelHi() << ImmPCRelLo_width) | ImmPCRelLo());
 
174
    int const width = ImmPCRelLo_width + ImmPCRelHi_width;
 
175
    return signed_bitextract_32(width-1, 0, offset);
 
176
  }
 
177
 
 
178
  uint64_t ImmLogical();
 
179
  float ImmFP32();
 
180
  double ImmFP64();
 
181
 
 
182
  inline LSDataSize SizeLSPair() const {
 
183
    return CalcLSPairDataSize(
 
184
             static_cast<LoadStorePairOp>(Mask(LoadStorePairMask)));
 
185
  }
 
186
 
 
187
  // Helpers.
 
188
  inline bool IsCondBranchImm() const {
 
189
    return Mask(ConditionalBranchFMask) == ConditionalBranchFixed;
 
190
  }
 
191
 
 
192
  inline bool IsUncondBranchImm() const {
 
193
    return Mask(UnconditionalBranchFMask) == UnconditionalBranchFixed;
 
194
  }
 
195
 
 
196
  inline bool IsCompareBranch() const {
 
197
    return Mask(CompareBranchFMask) == CompareBranchFixed;
 
198
  }
 
199
 
 
200
  inline bool IsTestBranch() const {
 
201
    return Mask(TestBranchFMask) == TestBranchFixed;
 
202
  }
 
203
 
 
204
  inline bool IsPCRelAddressing() const {
 
205
    return Mask(PCRelAddressingFMask) == PCRelAddressingFixed;
 
206
  }
 
207
 
 
208
  inline bool IsLogicalImmediate() const {
 
209
    return Mask(LogicalImmediateFMask) == LogicalImmediateFixed;
 
210
  }
 
211
 
 
212
  inline bool IsAddSubImmediate() const {
 
213
    return Mask(AddSubImmediateFMask) == AddSubImmediateFixed;
 
214
  }
 
215
 
 
216
  inline bool IsAddSubExtended() const {
 
217
    return Mask(AddSubExtendedFMask) == AddSubExtendedFixed;
 
218
  }
 
219
 
 
220
  inline bool IsLoadOrStore() const {
 
221
    return Mask(LoadStoreAnyFMask) == LoadStoreAnyFixed;
 
222
  }
 
223
 
 
224
  inline bool IsMovn() const {
 
225
    return (Mask(MoveWideImmediateMask) == MOVN_x) ||
 
226
           (Mask(MoveWideImmediateMask) == MOVN_w);
 
227
  }
 
228
 
 
229
  // Indicate whether Rd can be the stack pointer or the zero register. This
 
230
  // does not check that the instruction actually has an Rd field.
 
231
  inline Reg31Mode RdMode() const {
 
232
    // The following instructions use sp or wsp as Rd:
 
233
    //  Add/sub (immediate) when not setting the flags.
 
234
    //  Add/sub (extended) when not setting the flags.
 
235
    //  Logical (immediate) when not setting the flags.
 
236
    // Otherwise, r31 is the zero register.
 
237
    if (IsAddSubImmediate() || IsAddSubExtended()) {
 
238
      if (Mask(AddSubSetFlagsBit)) {
 
239
        return Reg31IsZeroRegister;
 
240
      } else {
 
241
        return Reg31IsStackPointer;
 
242
      }
 
243
    }
 
244
    if (IsLogicalImmediate()) {
 
245
      // Of the logical (immediate) instructions, only ANDS (and its aliases)
 
246
      // can set the flags. The others can all write into sp.
 
247
      // Note that some logical operations are not available to
 
248
      // immediate-operand instructions, so we have to combine two masks here.
 
249
      if (Mask(LogicalImmediateMask & LogicalOpMask) == ANDS) {
 
250
        return Reg31IsZeroRegister;
 
251
      } else {
 
252
        return Reg31IsStackPointer;
 
253
      }
 
254
    }
 
255
    return Reg31IsZeroRegister;
 
256
  }
 
257
 
 
258
  // Indicate whether Rn can be the stack pointer or the zero register. This
 
259
  // does not check that the instruction actually has an Rn field.
 
260
  inline Reg31Mode RnMode() const {
 
261
    // The following instructions use sp or wsp as Rn:
 
262
    //  All loads and stores.
 
263
    //  Add/sub (immediate).
 
264
    //  Add/sub (extended).
 
265
    // Otherwise, r31 is the zero register.
 
266
    if (IsLoadOrStore() || IsAddSubImmediate() || IsAddSubExtended()) {
 
267
      return Reg31IsStackPointer;
 
268
    }
 
269
    return Reg31IsZeroRegister;
 
270
  }
 
271
 
 
272
  inline ImmBranchType BranchType() const {
 
273
    if (IsCondBranchImm()) {
 
274
      return CondBranchType;
 
275
    } else if (IsUncondBranchImm()) {
 
276
      return UncondBranchType;
 
277
    } else if (IsCompareBranch()) {
 
278
      return CompareBranchType;
 
279
    } else if (IsTestBranch()) {
 
280
      return TestBranchType;
 
281
    } else {
 
282
      return UnknownBranchType;
 
283
    }
 
284
  }
 
285
 
 
286
  // Find the target of this instruction. 'this' may be a branch or a
 
287
  // PC-relative addressing instruction.
 
288
  Instruction* ImmPCOffsetTarget();
 
289
 
 
290
  // Patch a PC-relative offset to refer to 'target'. 'this' may be a branch or
 
291
  // a PC-relative addressing instruction.
 
292
  void SetImmPCOffsetTarget(Instruction* target);
 
293
  // Patch a literal load instruction to load from 'source'.
 
294
  void SetImmLLiteral(Instruction* source);
 
295
 
 
296
  inline uint8_t* LiteralAddress() {
 
297
    int offset = ImmLLiteral() << kLiteralEntrySizeLog2;
 
298
    return reinterpret_cast<uint8_t*>(this) + offset;
 
299
  }
 
300
 
 
301
  inline uint32_t Literal32() {
 
302
    uint32_t literal;
 
303
    memcpy(&literal, LiteralAddress(), sizeof(literal));
 
304
 
 
305
    return literal;
 
306
  }
 
307
 
 
308
  inline uint64_t Literal64() {
 
309
    uint64_t literal;
 
310
    memcpy(&literal, LiteralAddress(), sizeof(literal));
 
311
 
 
312
    return literal;
 
313
  }
 
314
 
 
315
  inline float LiteralFP32() {
 
316
    return rawbits_to_float(Literal32());
 
317
  }
 
318
 
 
319
  inline double LiteralFP64() {
 
320
    return rawbits_to_double(Literal64());
 
321
  }
 
322
 
 
323
  inline Instruction* NextInstruction() {
 
324
    return this + kInstructionSize;
 
325
  }
 
326
 
 
327
  inline Instruction* InstructionAtOffset(int64_t offset) {
 
328
    ASSERT(IsWordAligned(this + offset));
 
329
    return this + offset;
 
330
  }
 
331
 
 
332
  template<typename T> static inline Instruction* Cast(T src) {
 
333
    return reinterpret_cast<Instruction*>(src);
 
334
  }
 
335
 
 
336
 private:
 
337
  inline int ImmBranch() const;
 
338
 
 
339
  void SetPCRelImmTarget(Instruction* target);
 
340
  void SetBranchImmTarget(Instruction* target);
 
341
};
 
342
}  // namespace vixl
 
343
 
 
344
#endif  // VIXL_A64_INSTRUCTIONS_A64_H_