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 27 namespace art { 28 namespace x86_64 { 29 30 class CpuRegister { 31 public: CpuRegister(Register r)32 explicit CpuRegister(Register r) : reg_(r) {} CpuRegister(int r)33 explicit CpuRegister(int r) : reg_(Register(r)) {} AsRegister()34 Register AsRegister() const { 35 return reg_; 36 } LowBits()37 uint8_t LowBits() const { 38 return reg_ & 7; 39 } NeedsRex()40 bool NeedsRex() const { 41 return reg_ > 7; 42 } 43 private: 44 const Register reg_; 45 }; 46 std::ostream& operator<<(std::ostream& os, const CpuRegister& reg); 47 48 class XmmRegister { 49 public: XmmRegister(FloatRegister r)50 explicit XmmRegister(FloatRegister r) : reg_(r) {} XmmRegister(int r)51 explicit XmmRegister(int r) : reg_(FloatRegister(r)) {} AsFloatRegister()52 FloatRegister AsFloatRegister() const { 53 return reg_; 54 } LowBits()55 uint8_t LowBits() const { 56 return reg_ & 7; 57 } NeedsRex()58 bool NeedsRex() const { 59 return reg_ > 7; 60 } 61 private: 62 const FloatRegister reg_; 63 }; 64 std::ostream& operator<<(std::ostream& os, const XmmRegister& reg); 65 66 enum 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 }; 78 std::ostream& operator<<(std::ostream& os, const X87Register& reg); 79 80 enum ScaleFactor { 81 TIMES_1 = 0, 82 TIMES_2 = 1, 83 TIMES_4 = 2, 84 TIMES_8 = 3 85 }; 86 87 enum 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 113 class 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 IsBreakPoint()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. At(uintptr_t pc)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