1/*
2 * Copyright (C) 2014 The Android Open Source Project
3 *
4 * 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#ifndef ART_COMPILER_UTILS_X86_64_CONSTANTS_X86_64_H_
18#define ART_COMPILER_UTILS_X86_64_CONSTANTS_X86_64_H_
19
20#include <iosfwd>
21
22#include "arch/x86_64/registers_x86_64.h"
23#include "base/logging.h"
24#include "base/macros.h"
25#include "globals.h"
26
27namespace art {
28namespace x86_64 {
29
30class CpuRegister {
31 public:
32  explicit CpuRegister(Register r) : reg_(r) {}
33  explicit CpuRegister(int r) : reg_(Register(r)) {}
34  Register AsRegister() const {
35    return reg_;
36  }
37  uint8_t LowBits() const {
38    return reg_ & 7;
39  }
40  bool NeedsRex() const {
41    return reg_ > 7;
42  }
43 private:
44  const Register reg_;
45};
46std::ostream& operator<<(std::ostream& os, const CpuRegister& reg);
47
48class XmmRegister {
49 public:
50  explicit XmmRegister(FloatRegister r) : reg_(r) {}
51  explicit XmmRegister(int r) : reg_(FloatRegister(r)) {}
52  FloatRegister AsFloatRegister() const {
53    return reg_;
54  }
55  uint8_t LowBits() const {
56    return reg_ & 7;
57  }
58  bool NeedsRex() const {
59    return reg_ > 7;
60  }
61 private:
62  const FloatRegister reg_;
63};
64std::ostream& operator<<(std::ostream& os, const XmmRegister& reg);
65
66enum X87Register {
67  ST0 = 0,
68  ST1 = 1,
69  ST2 = 2,
70  ST3 = 3,
71  ST4 = 4,
72  ST5 = 5,
73  ST6 = 6,
74  ST7 = 7,
75  kNumberOfX87Registers = 8,
76  kNoX87Register = -1  // Signals an illegal register.
77};
78std::ostream& operator<<(std::ostream& os, const X87Register& reg);
79
80enum ScaleFactor {
81  TIMES_1 = 0,
82  TIMES_2 = 1,
83  TIMES_4 = 2,
84  TIMES_8 = 3
85};
86
87enum Condition {
88  kOverflow     =  0,
89  kNoOverflow   =  1,
90  kBelow        =  2,
91  kAboveEqual   =  3,
92  kEqual        =  4,
93  kNotEqual     =  5,
94  kBelowEqual   =  6,
95  kAbove        =  7,
96  kSign         =  8,
97  kNotSign      =  9,
98  kParityEven   = 10,
99  kParityOdd    = 11,
100  kLess         = 12,
101  kGreaterEqual = 13,
102  kLessEqual    = 14,
103  kGreater      = 15,
104
105  kZero         = kEqual,
106  kNotZero      = kNotEqual,
107  kNegative     = kSign,
108  kPositive     = kNotSign,
109  kUnordered    = kParityEven
110};
111
112
113class Instr {
114 public:
115  static const uint8_t kHltInstruction = 0xF4;
116  // We prefer not to use the int3 instruction since it conflicts with gdb.
117  static const uint8_t kBreakPointInstruction = kHltInstruction;
118
119  bool IsBreakPoint() {
120    return (*reinterpret_cast<const uint8_t*>(this)) == kBreakPointInstruction;
121  }
122
123  // Instructions are read out of a code stream. The only way to get a
124  // reference to an instruction is to convert a pointer. There is no way
125  // to allocate or create instances of class Instr.
126  // Use the At(pc) function to create references to Instr.
127  static Instr* At(uintptr_t pc) { return reinterpret_cast<Instr*>(pc); }
128
129 private:
130  DISALLOW_IMPLICIT_CONSTRUCTORS(Instr);
131};
132
133}  // namespace x86_64
134}  // namespace art
135
136#endif  // ART_COMPILER_UTILS_X86_64_CONSTANTS_X86_64_H_
137