Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 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_OPTIMIZING_CODE_GENERATOR_X86_H_ |
| 18 | #define ART_COMPILER_OPTIMIZING_CODE_GENERATOR_X86_H_ |
| 19 | |
Mark P Mendell | 17077d8 | 2015-12-16 19:15:59 +0000 | [diff] [blame] | 20 | #include "arch/x86/instruction_set_features_x86.h" |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 21 | #include "base/enums.h" |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 22 | #include "code_generator.h" |
Andreas Gampe | 8a0128a | 2016-11-28 07:38:35 -0800 | [diff] [blame] | 23 | #include "dex_file_types.h" |
Calin Juravle | cd6dffe | 2015-01-08 17:35:35 +0000 | [diff] [blame] | 24 | #include "driver/compiler_options.h" |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 25 | #include "nodes.h" |
Nicolas Geoffray | 86dbb9a | 2014-06-04 11:12:39 +0100 | [diff] [blame] | 26 | #include "parallel_move_resolver.h" |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 27 | #include "utils/x86/assembler_x86.h" |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 28 | |
| 29 | namespace art { |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 30 | namespace x86 { |
| 31 | |
Nicolas Geoffray | 86a8d7a | 2014-11-19 08:47:18 +0000 | [diff] [blame] | 32 | // Use a local definition to prevent copying mistakes. |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 33 | static constexpr size_t kX86WordSize = static_cast<size_t>(kX86PointerSize); |
Nicolas Geoffray | 707c809 | 2014-04-04 10:50:14 +0100 | [diff] [blame] | 34 | |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 35 | class CodeGeneratorX86; |
| 36 | |
Nicolas Geoffray | a747a39 | 2014-04-17 14:56:23 +0100 | [diff] [blame] | 37 | static constexpr Register kParameterCoreRegisters[] = { ECX, EDX, EBX }; |
| 38 | static constexpr RegisterPair kParameterCorePairRegisters[] = { ECX_EDX, EDX_EBX }; |
| 39 | static constexpr size_t kParameterCoreRegistersLength = arraysize(kParameterCoreRegisters); |
Mark P Mendell | 966c3ae | 2015-01-27 15:45:27 +0000 | [diff] [blame] | 40 | static constexpr XmmRegister kParameterFpuRegisters[] = { XMM0, XMM1, XMM2, XMM3 }; |
| 41 | static constexpr size_t kParameterFpuRegistersLength = arraysize(kParameterFpuRegisters); |
Nicolas Geoffray | a747a39 | 2014-04-17 14:56:23 +0100 | [diff] [blame] | 42 | |
Nicolas Geoffray | d75948a | 2015-03-27 09:53:16 +0000 | [diff] [blame] | 43 | static constexpr Register kRuntimeParameterCoreRegisters[] = { EAX, ECX, EDX, EBX }; |
| 44 | static constexpr size_t kRuntimeParameterCoreRegistersLength = |
| 45 | arraysize(kRuntimeParameterCoreRegisters); |
| 46 | static constexpr XmmRegister kRuntimeParameterFpuRegisters[] = { XMM0, XMM1, XMM2, XMM3 }; |
| 47 | static constexpr size_t kRuntimeParameterFpuRegistersLength = |
| 48 | arraysize(kRuntimeParameterFpuRegisters); |
| 49 | |
| 50 | class InvokeRuntimeCallingConvention : public CallingConvention<Register, XmmRegister> { |
| 51 | public: |
| 52 | InvokeRuntimeCallingConvention() |
| 53 | : CallingConvention(kRuntimeParameterCoreRegisters, |
| 54 | kRuntimeParameterCoreRegistersLength, |
| 55 | kRuntimeParameterFpuRegisters, |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 56 | kRuntimeParameterFpuRegistersLength, |
| 57 | kX86PointerSize) {} |
Nicolas Geoffray | d75948a | 2015-03-27 09:53:16 +0000 | [diff] [blame] | 58 | |
| 59 | private: |
| 60 | DISALLOW_COPY_AND_ASSIGN(InvokeRuntimeCallingConvention); |
| 61 | }; |
| 62 | |
Nicolas Geoffray | 7fb49da | 2014-10-06 09:12:41 +0100 | [diff] [blame] | 63 | class InvokeDexCallingConvention : public CallingConvention<Register, XmmRegister> { |
Nicolas Geoffray | a747a39 | 2014-04-17 14:56:23 +0100 | [diff] [blame] | 64 | public: |
Nicolas Geoffray | 7fb49da | 2014-10-06 09:12:41 +0100 | [diff] [blame] | 65 | InvokeDexCallingConvention() : CallingConvention( |
| 66 | kParameterCoreRegisters, |
| 67 | kParameterCoreRegistersLength, |
| 68 | kParameterFpuRegisters, |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 69 | kParameterFpuRegistersLength, |
| 70 | kX86PointerSize) {} |
Nicolas Geoffray | a747a39 | 2014-04-17 14:56:23 +0100 | [diff] [blame] | 71 | |
| 72 | RegisterPair GetRegisterPairAt(size_t argument_index) { |
| 73 | DCHECK_LT(argument_index + 1, GetNumberOfRegisters()); |
| 74 | return kParameterCorePairRegisters[argument_index]; |
| 75 | } |
| 76 | |
| 77 | private: |
| 78 | DISALLOW_COPY_AND_ASSIGN(InvokeDexCallingConvention); |
| 79 | }; |
| 80 | |
Roland Levillain | 2d27c8e | 2015-04-28 15:48:45 +0100 | [diff] [blame] | 81 | class InvokeDexCallingConventionVisitorX86 : public InvokeDexCallingConventionVisitor { |
Nicolas Geoffray | a747a39 | 2014-04-17 14:56:23 +0100 | [diff] [blame] | 82 | public: |
Roland Levillain | 2d27c8e | 2015-04-28 15:48:45 +0100 | [diff] [blame] | 83 | InvokeDexCallingConventionVisitorX86() {} |
| 84 | virtual ~InvokeDexCallingConventionVisitorX86() {} |
Nicolas Geoffray | a747a39 | 2014-04-17 14:56:23 +0100 | [diff] [blame] | 85 | |
Roland Levillain | 2d27c8e | 2015-04-28 15:48:45 +0100 | [diff] [blame] | 86 | Location GetNextLocation(Primitive::Type type) OVERRIDE; |
Nicolas Geoffray | fd88f16 | 2015-06-03 11:23:52 +0100 | [diff] [blame] | 87 | Location GetReturnLocation(Primitive::Type type) const OVERRIDE; |
| 88 | Location GetMethodLocation() const OVERRIDE; |
Nicolas Geoffray | a747a39 | 2014-04-17 14:56:23 +0100 | [diff] [blame] | 89 | |
| 90 | private: |
| 91 | InvokeDexCallingConvention calling_convention; |
Nicolas Geoffray | a747a39 | 2014-04-17 14:56:23 +0100 | [diff] [blame] | 92 | |
Roland Levillain | 2d27c8e | 2015-04-28 15:48:45 +0100 | [diff] [blame] | 93 | DISALLOW_COPY_AND_ASSIGN(InvokeDexCallingConventionVisitorX86); |
Nicolas Geoffray | a747a39 | 2014-04-17 14:56:23 +0100 | [diff] [blame] | 94 | }; |
| 95 | |
Calin Juravle | e460d1d | 2015-09-29 04:52:17 +0100 | [diff] [blame] | 96 | class FieldAccessCallingConventionX86 : public FieldAccessCallingConvention { |
| 97 | public: |
| 98 | FieldAccessCallingConventionX86() {} |
| 99 | |
| 100 | Location GetObjectLocation() const OVERRIDE { |
| 101 | return Location::RegisterLocation(ECX); |
| 102 | } |
| 103 | Location GetFieldIndexLocation() const OVERRIDE { |
| 104 | return Location::RegisterLocation(EAX); |
| 105 | } |
| 106 | Location GetReturnLocation(Primitive::Type type) const OVERRIDE { |
| 107 | return Primitive::Is64BitType(type) |
| 108 | ? Location::RegisterPairLocation(EAX, EDX) |
| 109 | : Location::RegisterLocation(EAX); |
| 110 | } |
| 111 | Location GetSetValueLocation(Primitive::Type type, bool is_instance) const OVERRIDE { |
| 112 | return Primitive::Is64BitType(type) |
Nicolas Geoffray | 5b3c6c0 | 2017-01-19 14:22:26 +0000 | [diff] [blame] | 113 | ? (is_instance |
| 114 | ? Location::RegisterPairLocation(EDX, EBX) |
| 115 | : Location::RegisterPairLocation(ECX, EDX)) |
Calin Juravle | e460d1d | 2015-09-29 04:52:17 +0100 | [diff] [blame] | 116 | : (is_instance |
| 117 | ? Location::RegisterLocation(EDX) |
| 118 | : Location::RegisterLocation(ECX)); |
| 119 | } |
| 120 | Location GetFpuLocation(Primitive::Type type ATTRIBUTE_UNUSED) const OVERRIDE { |
| 121 | return Location::FpuRegisterLocation(XMM0); |
| 122 | } |
| 123 | |
| 124 | private: |
| 125 | DISALLOW_COPY_AND_ASSIGN(FieldAccessCallingConventionX86); |
| 126 | }; |
| 127 | |
Zheng Xu | ad4450e | 2015-04-17 18:48:56 +0800 | [diff] [blame] | 128 | class ParallelMoveResolverX86 : public ParallelMoveResolverWithSwap { |
Nicolas Geoffray | 86dbb9a | 2014-06-04 11:12:39 +0100 | [diff] [blame] | 129 | public: |
| 130 | ParallelMoveResolverX86(ArenaAllocator* allocator, CodeGeneratorX86* codegen) |
Zheng Xu | ad4450e | 2015-04-17 18:48:56 +0800 | [diff] [blame] | 131 | : ParallelMoveResolverWithSwap(allocator), codegen_(codegen) {} |
Nicolas Geoffray | 86dbb9a | 2014-06-04 11:12:39 +0100 | [diff] [blame] | 132 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 133 | void EmitMove(size_t index) OVERRIDE; |
| 134 | void EmitSwap(size_t index) OVERRIDE; |
| 135 | void SpillScratch(int reg) OVERRIDE; |
| 136 | void RestoreScratch(int reg) OVERRIDE; |
Nicolas Geoffray | 86dbb9a | 2014-06-04 11:12:39 +0100 | [diff] [blame] | 137 | |
| 138 | X86Assembler* GetAssembler() const; |
| 139 | |
| 140 | private: |
| 141 | void Exchange(Register reg, int mem); |
| 142 | void Exchange(int mem1, int mem2); |
Mark Mendell | 7c8d009 | 2015-01-26 11:21:33 -0500 | [diff] [blame] | 143 | void Exchange32(XmmRegister reg, int mem); |
| 144 | void MoveMemoryToMemory32(int dst, int src); |
| 145 | void MoveMemoryToMemory64(int dst, int src); |
Nicolas Geoffray | 86dbb9a | 2014-06-04 11:12:39 +0100 | [diff] [blame] | 146 | |
| 147 | CodeGeneratorX86* const codegen_; |
| 148 | |
| 149 | DISALLOW_COPY_AND_ASSIGN(ParallelMoveResolverX86); |
| 150 | }; |
| 151 | |
Nicolas Geoffray | bab4ed7 | 2014-03-11 17:53:17 +0000 | [diff] [blame] | 152 | class LocationsBuilderX86 : public HGraphVisitor { |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 153 | public: |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 154 | LocationsBuilderX86(HGraph* graph, CodeGeneratorX86* codegen) |
| 155 | : HGraphVisitor(graph), codegen_(codegen) {} |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 156 | |
Nicolas Geoffray | 360231a | 2014-10-08 21:07:48 +0100 | [diff] [blame] | 157 | #define DECLARE_VISIT_INSTRUCTION(name, super) \ |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 158 | void Visit##name(H##name* instr) OVERRIDE; |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 159 | |
Alexandre Rames | ef20f71 | 2015-06-09 10:29:30 +0100 | [diff] [blame] | 160 | FOR_EACH_CONCRETE_INSTRUCTION_COMMON(DECLARE_VISIT_INSTRUCTION) |
| 161 | FOR_EACH_CONCRETE_INSTRUCTION_X86(DECLARE_VISIT_INSTRUCTION) |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 162 | |
| 163 | #undef DECLARE_VISIT_INSTRUCTION |
| 164 | |
Alexandre Rames | ef20f71 | 2015-06-09 10:29:30 +0100 | [diff] [blame] | 165 | void VisitInstruction(HInstruction* instruction) OVERRIDE { |
| 166 | LOG(FATAL) << "Unreachable instruction " << instruction->DebugName() |
| 167 | << " (id " << instruction->GetId() << ")"; |
| 168 | } |
| 169 | |
Nicolas Geoffray | 9574c4b | 2014-11-12 13:19:37 +0000 | [diff] [blame] | 170 | private: |
| 171 | void HandleBitwiseOperation(HBinaryOperation* instruction); |
Nicolas Geoffray | e982f0b | 2014-08-13 02:11:24 +0100 | [diff] [blame] | 172 | void HandleInvoke(HInvoke* invoke); |
Vladimir Marko | 5f7b58e | 2015-11-23 19:49:34 +0000 | [diff] [blame] | 173 | void HandleCondition(HCondition* condition); |
Calin Juravle | 9aec02f | 2014-11-18 23:06:35 +0000 | [diff] [blame] | 174 | void HandleShift(HBinaryOperation* instruction); |
Calin Juravle | 52c4896 | 2014-12-16 17:02:57 +0000 | [diff] [blame] | 175 | void HandleFieldSet(HInstruction* instruction, const FieldInfo& field_info); |
| 176 | void HandleFieldGet(HInstruction* instruction, const FieldInfo& field_info); |
Nicolas Geoffray | e982f0b | 2014-08-13 02:11:24 +0100 | [diff] [blame] | 177 | |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 178 | CodeGeneratorX86* const codegen_; |
Roland Levillain | 2d27c8e | 2015-04-28 15:48:45 +0100 | [diff] [blame] | 179 | InvokeDexCallingConventionVisitorX86 parameter_visitor_; |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 180 | |
Nicolas Geoffray | bab4ed7 | 2014-03-11 17:53:17 +0000 | [diff] [blame] | 181 | DISALLOW_COPY_AND_ASSIGN(LocationsBuilderX86); |
| 182 | }; |
| 183 | |
Aart Bik | 42249c3 | 2016-01-07 15:33:50 -0800 | [diff] [blame] | 184 | class InstructionCodeGeneratorX86 : public InstructionCodeGenerator { |
Nicolas Geoffray | bab4ed7 | 2014-03-11 17:53:17 +0000 | [diff] [blame] | 185 | public: |
Nicolas Geoffray | 4a34a42 | 2014-04-03 10:38:37 +0100 | [diff] [blame] | 186 | InstructionCodeGeneratorX86(HGraph* graph, CodeGeneratorX86* codegen); |
Nicolas Geoffray | bab4ed7 | 2014-03-11 17:53:17 +0000 | [diff] [blame] | 187 | |
Nicolas Geoffray | 360231a | 2014-10-08 21:07:48 +0100 | [diff] [blame] | 188 | #define DECLARE_VISIT_INSTRUCTION(name, super) \ |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 189 | void Visit##name(H##name* instr) OVERRIDE; |
Nicolas Geoffray | bab4ed7 | 2014-03-11 17:53:17 +0000 | [diff] [blame] | 190 | |
Alexandre Rames | ef20f71 | 2015-06-09 10:29:30 +0100 | [diff] [blame] | 191 | FOR_EACH_CONCRETE_INSTRUCTION_COMMON(DECLARE_VISIT_INSTRUCTION) |
| 192 | FOR_EACH_CONCRETE_INSTRUCTION_X86(DECLARE_VISIT_INSTRUCTION) |
Nicolas Geoffray | bab4ed7 | 2014-03-11 17:53:17 +0000 | [diff] [blame] | 193 | |
| 194 | #undef DECLARE_VISIT_INSTRUCTION |
| 195 | |
Alexandre Rames | ef20f71 | 2015-06-09 10:29:30 +0100 | [diff] [blame] | 196 | void VisitInstruction(HInstruction* instruction) OVERRIDE { |
| 197 | LOG(FATAL) << "Unreachable instruction " << instruction->DebugName() |
| 198 | << " (id " << instruction->GetId() << ")"; |
| 199 | } |
| 200 | |
Nicolas Geoffray | 4a34a42 | 2014-04-03 10:38:37 +0100 | [diff] [blame] | 201 | X86Assembler* GetAssembler() const { return assembler_; } |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 202 | |
Vladimir Marko | f3e0ee2 | 2015-12-17 15:23:13 +0000 | [diff] [blame] | 203 | // The compare/jump sequence will generate about (1.5 * num_entries) instructions. A jump |
| 204 | // table version generates 7 instructions and num_entries literals. Compare/jump sequence will |
| 205 | // generates less code/data with a small num_entries. |
| 206 | static constexpr uint32_t kPackedSwitchJumpTableThreshold = 5; |
| 207 | |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 208 | private: |
Nicolas Geoffray | 3c04974 | 2014-09-24 18:10:46 +0100 | [diff] [blame] | 209 | // Generate code for the given suspend check. If not null, `successor` |
| 210 | // is the block to branch to if the suspend check is not needed, and after |
| 211 | // the suspend call. |
| 212 | void GenerateSuspendCheck(HSuspendCheck* check, HBasicBlock* successor); |
Andreas Gampe | 85b62f2 | 2015-09-09 13:15:38 -0700 | [diff] [blame] | 213 | void GenerateClassInitializationCheck(SlowPathCode* slow_path, Register class_reg); |
Nicolas Geoffray | 9574c4b | 2014-11-12 13:19:37 +0000 | [diff] [blame] | 214 | void HandleBitwiseOperation(HBinaryOperation* instruction); |
Calin Juravle | bacfec3 | 2014-11-14 15:54:36 +0000 | [diff] [blame] | 215 | void GenerateDivRemIntegral(HBinaryOperation* instruction); |
Guillaume Sanchez | 0f88e87 | 2015-03-30 17:55:45 +0100 | [diff] [blame] | 216 | void DivRemOneOrMinusOne(HBinaryOperation* instruction); |
Guillaume Sanchez | b19930c | 2015-04-09 21:12:15 +0100 | [diff] [blame] | 217 | void DivByPowerOfTwo(HDiv* instruction); |
Guillaume Sanchez | 0f88e87 | 2015-03-30 17:55:45 +0100 | [diff] [blame] | 218 | void GenerateDivRemWithAnyConstant(HBinaryOperation* instruction); |
Mark Mendell | c470193 | 2015-04-10 13:18:51 -0400 | [diff] [blame] | 219 | void GenerateRemFP(HRem* rem); |
Vladimir Marko | 5f7b58e | 2015-11-23 19:49:34 +0000 | [diff] [blame] | 220 | void HandleCondition(HCondition* condition); |
Calin Juravle | 9aec02f | 2014-11-18 23:06:35 +0000 | [diff] [blame] | 221 | void HandleShift(HBinaryOperation* instruction); |
| 222 | void GenerateShlLong(const Location& loc, Register shifter); |
| 223 | void GenerateShrLong(const Location& loc, Register shifter); |
| 224 | void GenerateUShrLong(const Location& loc, Register shifter); |
Mark P Mendell | 7394569 | 2015-04-29 14:56:17 +0000 | [diff] [blame] | 225 | void GenerateShlLong(const Location& loc, int shift); |
| 226 | void GenerateShrLong(const Location& loc, int shift); |
| 227 | void GenerateUShrLong(const Location& loc, int shift); |
Roland Levillain | 7c1559a | 2015-12-15 10:55:36 +0000 | [diff] [blame] | 228 | |
Nicolas Geoffray | 07276db | 2015-05-18 14:22:09 +0100 | [diff] [blame] | 229 | void HandleFieldSet(HInstruction* instruction, |
| 230 | const FieldInfo& field_info, |
| 231 | bool value_can_be_null); |
Calin Juravle | 52c4896 | 2014-12-16 17:02:57 +0000 | [diff] [blame] | 232 | void HandleFieldGet(HInstruction* instruction, const FieldInfo& field_info); |
Roland Levillain | 7c1559a | 2015-12-15 10:55:36 +0000 | [diff] [blame] | 233 | |
| 234 | // Generate a heap reference load using one register `out`: |
| 235 | // |
| 236 | // out <- *(out + offset) |
| 237 | // |
| 238 | // while honoring heap poisoning and/or read barriers (if any). |
Roland Levillain | 95e7ffc | 2016-01-22 11:57:25 +0000 | [diff] [blame] | 239 | // |
| 240 | // Location `maybe_temp` is used when generating a read barrier and |
| 241 | // shall be a register in that case; it may be an invalid location |
| 242 | // otherwise. |
Roland Levillain | 7c1559a | 2015-12-15 10:55:36 +0000 | [diff] [blame] | 243 | void GenerateReferenceLoadOneRegister(HInstruction* instruction, |
| 244 | Location out, |
| 245 | uint32_t offset, |
Mathieu Chartier | aa474eb | 2016-11-09 15:18:27 -0800 | [diff] [blame] | 246 | Location maybe_temp, |
Mathieu Chartier | 3af00dc | 2016-11-10 11:25:57 -0800 | [diff] [blame] | 247 | ReadBarrierOption read_barrier_option); |
Roland Levillain | 7c1559a | 2015-12-15 10:55:36 +0000 | [diff] [blame] | 248 | // Generate a heap reference load using two different registers |
| 249 | // `out` and `obj`: |
| 250 | // |
| 251 | // out <- *(obj + offset) |
| 252 | // |
| 253 | // while honoring heap poisoning and/or read barriers (if any). |
Roland Levillain | 95e7ffc | 2016-01-22 11:57:25 +0000 | [diff] [blame] | 254 | // |
| 255 | // Location `maybe_temp` is used when generating a Baker's (fast |
| 256 | // path) read barrier and shall be a register in that case; it may |
| 257 | // be an invalid location otherwise. |
Roland Levillain | 7c1559a | 2015-12-15 10:55:36 +0000 | [diff] [blame] | 258 | void GenerateReferenceLoadTwoRegisters(HInstruction* instruction, |
| 259 | Location out, |
| 260 | Location obj, |
Mathieu Chartier | 5c44c1b | 2016-11-04 18:13:04 -0700 | [diff] [blame] | 261 | uint32_t offset, |
Mathieu Chartier | 3af00dc | 2016-11-10 11:25:57 -0800 | [diff] [blame] | 262 | ReadBarrierOption read_barrier_option); |
Roland Levillain | 7c1559a | 2015-12-15 10:55:36 +0000 | [diff] [blame] | 263 | // Generate a GC root reference load: |
| 264 | // |
Vladimir Marko | cac5a7e | 2016-02-22 10:39:50 +0000 | [diff] [blame] | 265 | // root <- *address |
Roland Levillain | 7c1559a | 2015-12-15 10:55:36 +0000 | [diff] [blame] | 266 | // |
Mathieu Chartier | 3af00dc | 2016-11-10 11:25:57 -0800 | [diff] [blame] | 267 | // while honoring read barriers based on read_barrier_option. |
Roland Levillain | 7c1559a | 2015-12-15 10:55:36 +0000 | [diff] [blame] | 268 | void GenerateGcRootFieldLoad(HInstruction* instruction, |
| 269 | Location root, |
Vladimir Marko | cac5a7e | 2016-02-22 10:39:50 +0000 | [diff] [blame] | 270 | const Address& address, |
Roland Levillain | 00468f3 | 2016-10-27 18:02:48 +0100 | [diff] [blame] | 271 | Label* fixup_label, |
Mathieu Chartier | 3af00dc | 2016-11-10 11:25:57 -0800 | [diff] [blame] | 272 | ReadBarrierOption read_barrier_option); |
Roland Levillain | 7c1559a | 2015-12-15 10:55:36 +0000 | [diff] [blame] | 273 | |
Roland Levillain | 232ade0 | 2015-04-20 15:14:36 +0100 | [diff] [blame] | 274 | // Push value to FPU stack. `is_fp` specifies whether the value is floating point or not. |
| 275 | // `is_wide` specifies whether it is long/double or not. |
Mark Mendell | 24f2dfa | 2015-01-14 19:51:45 -0500 | [diff] [blame] | 276 | void PushOntoFPStack(Location source, uint32_t temp_offset, |
Roland Levillain | 232ade0 | 2015-04-20 15:14:36 +0100 | [diff] [blame] | 277 | uint32_t stack_adjustment, bool is_fp, bool is_wide); |
Nicolas Geoffray | 3c04974 | 2014-09-24 18:10:46 +0100 | [diff] [blame] | 278 | |
Mark Mendell | 152408f | 2015-12-31 12:28:50 -0500 | [diff] [blame] | 279 | template<class LabelType> |
Mingyao Yang | d43b3ac | 2015-04-01 14:03:04 -0700 | [diff] [blame] | 280 | void GenerateTestAndBranch(HInstruction* instruction, |
David Brazdil | 0debae7 | 2015-11-12 18:37:00 +0000 | [diff] [blame] | 281 | size_t condition_input_index, |
Mark Mendell | 152408f | 2015-12-31 12:28:50 -0500 | [diff] [blame] | 282 | LabelType* true_target, |
| 283 | LabelType* false_target); |
| 284 | template<class LabelType> |
David Brazdil | 0debae7 | 2015-11-12 18:37:00 +0000 | [diff] [blame] | 285 | void GenerateCompareTestAndBranch(HCondition* condition, |
Mark Mendell | 152408f | 2015-12-31 12:28:50 -0500 | [diff] [blame] | 286 | LabelType* true_target, |
| 287 | LabelType* false_target); |
| 288 | template<class LabelType> |
| 289 | void GenerateFPJumps(HCondition* cond, LabelType* true_label, LabelType* false_label); |
| 290 | template<class LabelType> |
| 291 | void GenerateLongComparesAndJumps(HCondition* cond, |
| 292 | LabelType* true_label, |
| 293 | LabelType* false_label); |
| 294 | |
David Brazdil | fc6a86a | 2015-06-26 10:33:45 +0000 | [diff] [blame] | 295 | void HandleGoto(HInstruction* got, HBasicBlock* successor); |
Vladimir Marko | f3e0ee2 | 2015-12-17 15:23:13 +0000 | [diff] [blame] | 296 | void GenPackedSwitchWithCompares(Register value_reg, |
| 297 | int32_t lower_bound, |
| 298 | uint32_t num_entries, |
| 299 | HBasicBlock* switch_block, |
| 300 | HBasicBlock* default_block); |
Calin Juravle | cd6dffe | 2015-01-08 17:35:35 +0000 | [diff] [blame] | 301 | |
Mark P Mendell | 2f10a5f | 2016-01-25 14:47:50 +0000 | [diff] [blame] | 302 | void GenerateFPCompare(Location lhs, Location rhs, HInstruction* insn, bool is_double); |
| 303 | |
Nicolas Geoffray | 4a34a42 | 2014-04-03 10:38:37 +0100 | [diff] [blame] | 304 | X86Assembler* const assembler_; |
| 305 | CodeGeneratorX86* const codegen_; |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 306 | |
| 307 | DISALLOW_COPY_AND_ASSIGN(InstructionCodeGeneratorX86); |
| 308 | }; |
| 309 | |
Mark Mendell | 805b3b5 | 2015-09-18 14:10:29 -0400 | [diff] [blame] | 310 | class JumpTableRIPFixup; |
| 311 | |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 312 | class CodeGeneratorX86 : public CodeGenerator { |
| 313 | public: |
Mark Mendell | fb8d279 | 2015-03-31 22:16:59 -0400 | [diff] [blame] | 314 | CodeGeneratorX86(HGraph* graph, |
| 315 | const X86InstructionSetFeatures& isa_features, |
Serban Constantinescu | ecc4366 | 2015-08-13 13:33:12 +0100 | [diff] [blame] | 316 | const CompilerOptions& compiler_options, |
| 317 | OptimizingCompilerStats* stats = nullptr); |
Nicolas Geoffray | f12feb8 | 2014-07-17 18:32:41 +0100 | [diff] [blame] | 318 | virtual ~CodeGeneratorX86() {} |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 319 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 320 | void GenerateFrameEntry() OVERRIDE; |
| 321 | void GenerateFrameExit() OVERRIDE; |
| 322 | void Bind(HBasicBlock* block) OVERRIDE; |
Calin Juravle | 175dc73 | 2015-08-25 15:42:32 +0100 | [diff] [blame] | 323 | void MoveConstant(Location destination, int32_t value) OVERRIDE; |
Calin Juravle | e460d1d | 2015-09-29 04:52:17 +0100 | [diff] [blame] | 324 | void MoveLocation(Location dst, Location src, Primitive::Type dst_type) OVERRIDE; |
| 325 | void AddLocationAsTemp(Location location, LocationSummary* locations) OVERRIDE; |
| 326 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 327 | size_t SaveCoreRegister(size_t stack_index, uint32_t reg_id) OVERRIDE; |
| 328 | size_t RestoreCoreRegister(size_t stack_index, uint32_t reg_id) OVERRIDE; |
Mark Mendell | 7c8d009 | 2015-01-26 11:21:33 -0500 | [diff] [blame] | 329 | size_t SaveFloatingPointRegister(size_t stack_index, uint32_t reg_id) OVERRIDE; |
| 330 | size_t RestoreFloatingPointRegister(size_t stack_index, uint32_t reg_id) OVERRIDE; |
Nicolas Geoffray | bab4ed7 | 2014-03-11 17:53:17 +0000 | [diff] [blame] | 331 | |
Alexandre Rames | 8158f28 | 2015-08-07 10:26:17 +0100 | [diff] [blame] | 332 | // Generate code to invoke a runtime entry point. |
Calin Juravle | 175dc73 | 2015-08-25 15:42:32 +0100 | [diff] [blame] | 333 | void InvokeRuntime(QuickEntrypointEnum entrypoint, |
| 334 | HInstruction* instruction, |
| 335 | uint32_t dex_pc, |
Serban Constantinescu | ba45db0 | 2016-07-12 22:53:02 +0100 | [diff] [blame] | 336 | SlowPathCode* slow_path = nullptr) OVERRIDE; |
Alexandre Rames | 8158f28 | 2015-08-07 10:26:17 +0100 | [diff] [blame] | 337 | |
Roland Levillain | dec8f63 | 2016-07-22 17:10:06 +0100 | [diff] [blame] | 338 | // Generate code to invoke a runtime entry point, but do not record |
| 339 | // PC-related information in a stack map. |
| 340 | void InvokeRuntimeWithoutRecordingPcInfo(int32_t entry_point_offset, |
| 341 | HInstruction* instruction, |
| 342 | SlowPathCode* slow_path); |
| 343 | |
Serban Constantinescu | ba45db0 | 2016-07-12 22:53:02 +0100 | [diff] [blame] | 344 | void GenerateInvokeRuntime(int32_t entry_point_offset); |
| 345 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 346 | size_t GetWordSize() const OVERRIDE { |
Nicolas Geoffray | 707c809 | 2014-04-04 10:50:14 +0100 | [diff] [blame] | 347 | return kX86WordSize; |
| 348 | } |
| 349 | |
Mark Mendell | f85a9ca | 2015-01-13 09:20:58 -0500 | [diff] [blame] | 350 | size_t GetFloatingPointSpillSlotSize() const OVERRIDE { |
Aart Bik | b13c65b | 2017-03-21 20:14:07 -0700 | [diff] [blame] | 351 | return GetGraph()->HasSIMD() |
| 352 | ? 4 * kX86WordSize // 16 bytes == 4 words for each spill |
| 353 | : 2 * kX86WordSize; // 8 bytes == 2 words for each spill |
Mark Mendell | f85a9ca | 2015-01-13 09:20:58 -0500 | [diff] [blame] | 354 | } |
| 355 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 356 | HGraphVisitor* GetLocationBuilder() OVERRIDE { |
Nicolas Geoffray | bab4ed7 | 2014-03-11 17:53:17 +0000 | [diff] [blame] | 357 | return &location_builder_; |
| 358 | } |
| 359 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 360 | HGraphVisitor* GetInstructionVisitor() OVERRIDE { |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 361 | return &instruction_visitor_; |
| 362 | } |
| 363 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 364 | X86Assembler* GetAssembler() OVERRIDE { |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 365 | return &assembler_; |
| 366 | } |
| 367 | |
Alexandre Rames | eb7b739 | 2015-06-19 14:47:01 +0100 | [diff] [blame] | 368 | const X86Assembler& GetAssembler() const OVERRIDE { |
| 369 | return assembler_; |
| 370 | } |
| 371 | |
Alexandre Rames | c01a664 | 2016-04-15 11:54:06 +0100 | [diff] [blame] | 372 | uintptr_t GetAddressOf(HBasicBlock* block) OVERRIDE { |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 373 | return GetLabelOf(block)->Position(); |
| 374 | } |
Calin Juravle | 34bacdf | 2014-10-07 20:23:36 +0100 | [diff] [blame] | 375 | |
David Brazdil | 58282f4 | 2016-01-14 12:45:10 +0000 | [diff] [blame] | 376 | void SetupBlockedRegisters() const OVERRIDE; |
Nicolas Geoffray | 4a34a42 | 2014-04-03 10:38:37 +0100 | [diff] [blame] | 377 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 378 | void DumpCoreRegister(std::ostream& stream, int reg) const OVERRIDE; |
| 379 | void DumpFloatingPointRegister(std::ostream& stream, int reg) const OVERRIDE; |
Nicolas Geoffray | a7062e0 | 2014-05-22 12:50:17 +0100 | [diff] [blame] | 380 | |
Nicolas Geoffray | f0e3937 | 2014-11-12 17:50:07 +0000 | [diff] [blame] | 381 | ParallelMoveResolverX86* GetMoveResolver() OVERRIDE { |
Nicolas Geoffray | 86dbb9a | 2014-06-04 11:12:39 +0100 | [diff] [blame] | 382 | return &move_resolver_; |
| 383 | } |
| 384 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 385 | InstructionSet GetInstructionSet() const OVERRIDE { |
Nicolas Geoffray | 412f10c | 2014-06-19 10:00:34 +0100 | [diff] [blame] | 386 | return InstructionSet::kX86; |
| 387 | } |
| 388 | |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 389 | // Helper method to move a 32bits value between two locations. |
| 390 | void Move32(Location destination, Location source); |
| 391 | // Helper method to move a 64bits value between two locations. |
| 392 | void Move64(Location destination, Location source); |
| 393 | |
Vladimir Marko | cac5a7e | 2016-02-22 10:39:50 +0000 | [diff] [blame] | 394 | // Check if the desired_string_load_kind is supported. If it is, return it, |
| 395 | // otherwise return a fall-back kind that should be used instead. |
| 396 | HLoadString::LoadKind GetSupportedLoadStringKind( |
| 397 | HLoadString::LoadKind desired_string_load_kind) OVERRIDE; |
| 398 | |
Vladimir Marko | dbb7f5b | 2016-03-30 13:23:58 +0100 | [diff] [blame] | 399 | // Check if the desired_class_load_kind is supported. If it is, return it, |
| 400 | // otherwise return a fall-back kind that should be used instead. |
| 401 | HLoadClass::LoadKind GetSupportedLoadClassKind( |
| 402 | HLoadClass::LoadKind desired_class_load_kind) OVERRIDE; |
| 403 | |
Vladimir Marko | dc151b2 | 2015-10-15 18:02:30 +0100 | [diff] [blame] | 404 | // Check if the desired_dispatch_info is supported. If it is, return it, |
| 405 | // otherwise return a fall-back info that should be used instead. |
| 406 | HInvokeStaticOrDirect::DispatchInfo GetSupportedInvokeStaticOrDirectDispatch( |
| 407 | const HInvokeStaticOrDirect::DispatchInfo& desired_dispatch_info, |
Nicolas Geoffray | 5e4e11e | 2016-09-22 13:17:41 +0100 | [diff] [blame] | 408 | HInvokeStaticOrDirect* invoke) OVERRIDE; |
Vladimir Marko | dc151b2 | 2015-10-15 18:02:30 +0100 | [diff] [blame] | 409 | |
Mark Mendell | 09ed1a3 | 2015-03-25 08:30:06 -0400 | [diff] [blame] | 410 | // Generate a call to a static or direct method. |
Vladimir Marko | e7197bf | 2017-06-02 17:00:23 +0100 | [diff] [blame^] | 411 | void GenerateStaticOrDirectCall( |
| 412 | HInvokeStaticOrDirect* invoke, Location temp, SlowPathCode* slow_path = nullptr) OVERRIDE; |
Andreas Gampe | bfb5ba9 | 2015-09-01 15:45:02 +0000 | [diff] [blame] | 413 | // Generate a call to a virtual method. |
Vladimir Marko | e7197bf | 2017-06-02 17:00:23 +0100 | [diff] [blame^] | 414 | void GenerateVirtualCall( |
| 415 | HInvokeVirtual* invoke, Location temp, SlowPathCode* slow_path = nullptr) OVERRIDE; |
Andreas Gampe | 85b62f2 | 2015-09-09 13:15:38 -0700 | [diff] [blame] | 416 | |
Vladimir Marko | 6597946 | 2017-05-19 17:25:12 +0100 | [diff] [blame] | 417 | void RecordBootMethodPatch(HInvokeStaticOrDirect* invoke); |
Vladimir Marko | 1998cd0 | 2017-01-13 13:02:58 +0000 | [diff] [blame] | 418 | void RecordBootTypePatch(HLoadClass* load_class); |
Vladimir Marko | 6bec91c | 2017-01-09 15:03:12 +0000 | [diff] [blame] | 419 | Label* NewTypeBssEntryPatch(HLoadClass* load_class); |
Vladimir Marko | 6597946 | 2017-05-19 17:25:12 +0100 | [diff] [blame] | 420 | void RecordBootStringPatch(HLoadString* load_string); |
Vladimir Marko | aad75c6 | 2016-10-03 08:46:48 +0000 | [diff] [blame] | 421 | Label* NewStringBssEntryPatch(HLoadString* load_string); |
Nicolas Geoffray | 133719e | 2017-01-22 15:44:39 +0000 | [diff] [blame] | 422 | Label* NewPcRelativeDexCacheArrayPatch(HX86ComputeBaseMethodAddress* method_address, |
| 423 | const DexFile& dex_file, |
| 424 | uint32_t element_offset); |
Nicolas Geoffray | f0acfe7 | 2017-01-09 20:54:52 +0000 | [diff] [blame] | 425 | Label* NewJitRootStringPatch(const DexFile& dex_file, |
| 426 | dex::StringIndex dex_index, |
| 427 | Handle<mirror::String> handle); |
Nicolas Geoffray | 5247c08 | 2017-01-13 14:17:29 +0000 | [diff] [blame] | 428 | Label* NewJitRootClassPatch(const DexFile& dex_file, |
| 429 | dex::TypeIndex dex_index, |
| 430 | Handle<mirror::Class> handle); |
Vladimir Marko | cac5a7e | 2016-02-22 10:39:50 +0000 | [diff] [blame] | 431 | |
Andreas Gampe | 85b62f2 | 2015-09-09 13:15:38 -0700 | [diff] [blame] | 432 | void MoveFromReturnRegister(Location trg, Primitive::Type type) OVERRIDE; |
Mark Mendell | 09ed1a3 | 2015-03-25 08:30:06 -0400 | [diff] [blame] | 433 | |
Vladimir Marko | 5815501 | 2015-08-19 12:49:41 +0000 | [diff] [blame] | 434 | // Emit linker patches. |
| 435 | void EmitLinkerPatches(ArenaVector<LinkerPatch>* linker_patches) OVERRIDE; |
| 436 | |
Nicolas Geoffray | 22384ae | 2016-12-12 22:33:36 +0000 | [diff] [blame] | 437 | void PatchJitRootUse(uint8_t* code, |
| 438 | const uint8_t* roots_data, |
| 439 | const PatchInfo<Label>& info, |
| 440 | uint64_t index_in_table) const; |
Nicolas Geoffray | 132d836 | 2016-11-16 09:19:42 +0000 | [diff] [blame] | 441 | void EmitJitRootPatches(uint8_t* code, const uint8_t* roots_data) OVERRIDE; |
| 442 | |
Nicolas Geoffray | 3c7bb98 | 2014-07-23 16:04:16 +0100 | [diff] [blame] | 443 | // Emit a write barrier. |
Nicolas Geoffray | 07276db | 2015-05-18 14:22:09 +0100 | [diff] [blame] | 444 | void MarkGCCard(Register temp, |
| 445 | Register card, |
| 446 | Register object, |
| 447 | Register value, |
| 448 | bool value_can_be_null); |
Nicolas Geoffray | 3c7bb98 | 2014-07-23 16:04:16 +0100 | [diff] [blame] | 449 | |
Roland Levillain | 7c1559a | 2015-12-15 10:55:36 +0000 | [diff] [blame] | 450 | void GenerateMemoryBarrier(MemBarrierKind kind); |
| 451 | |
Nicolas Geoffray | 92a73ae | 2014-10-16 11:12:52 +0100 | [diff] [blame] | 452 | Label* GetLabelOf(HBasicBlock* block) const { |
Vladimir Marko | 225b646 | 2015-09-28 12:17:40 +0100 | [diff] [blame] | 453 | return CommonGetLabelOf<Label>(block_labels_, block); |
Nicolas Geoffray | 92a73ae | 2014-10-16 11:12:52 +0100 | [diff] [blame] | 454 | } |
| 455 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 456 | void Initialize() OVERRIDE { |
Vladimir Marko | 225b646 | 2015-09-28 12:17:40 +0100 | [diff] [blame] | 457 | block_labels_ = CommonInitializeLabels<Label>(); |
Nicolas Geoffray | 92a73ae | 2014-10-16 11:12:52 +0100 | [diff] [blame] | 458 | } |
| 459 | |
Nicolas Geoffray | 840e546 | 2015-01-07 16:01:24 +0000 | [diff] [blame] | 460 | bool NeedsTwoRegisters(Primitive::Type type) const OVERRIDE { |
| 461 | return type == Primitive::kPrimLong; |
| 462 | } |
| 463 | |
Nicolas Geoffray | 234d69d | 2015-03-09 10:28:50 +0000 | [diff] [blame] | 464 | bool ShouldSplitLongMoves() const OVERRIDE { return true; } |
| 465 | |
Nicolas Geoffray | 1cf9528 | 2014-12-12 19:22:03 +0000 | [diff] [blame] | 466 | Label* GetFrameEntryLabel() { return &frame_entry_label_; } |
| 467 | |
Mark Mendell | fb8d279 | 2015-03-31 22:16:59 -0400 | [diff] [blame] | 468 | const X86InstructionSetFeatures& GetInstructionSetFeatures() const { |
| 469 | return isa_features_; |
| 470 | } |
| 471 | |
Nicolas Geoffray | 133719e | 2017-01-22 15:44:39 +0000 | [diff] [blame] | 472 | void AddMethodAddressOffset(HX86ComputeBaseMethodAddress* method_base, int32_t offset) { |
| 473 | method_address_offset_.Put(method_base->GetId(), offset); |
Mark Mendell | 0616ae0 | 2015-04-17 12:49:27 -0400 | [diff] [blame] | 474 | } |
| 475 | |
Nicolas Geoffray | 133719e | 2017-01-22 15:44:39 +0000 | [diff] [blame] | 476 | int32_t GetMethodAddressOffset(HX86ComputeBaseMethodAddress* method_base) const { |
| 477 | return method_address_offset_.Get(method_base->GetId()); |
Mark Mendell | 0616ae0 | 2015-04-17 12:49:27 -0400 | [diff] [blame] | 478 | } |
| 479 | |
| 480 | int32_t ConstantAreaStart() const { |
| 481 | return constant_area_start_; |
| 482 | } |
| 483 | |
Nicolas Geoffray | 133719e | 2017-01-22 15:44:39 +0000 | [diff] [blame] | 484 | Address LiteralDoubleAddress(double v, HX86ComputeBaseMethodAddress* method_base, Register reg); |
| 485 | Address LiteralFloatAddress(float v, HX86ComputeBaseMethodAddress* method_base, Register reg); |
| 486 | Address LiteralInt32Address(int32_t v, HX86ComputeBaseMethodAddress* method_base, Register reg); |
| 487 | Address LiteralInt64Address(int64_t v, HX86ComputeBaseMethodAddress* method_base, Register reg); |
Mark Mendell | 0616ae0 | 2015-04-17 12:49:27 -0400 | [diff] [blame] | 488 | |
Aart Bik | a19616e | 2016-02-01 18:57:58 -0800 | [diff] [blame] | 489 | // Load a 32-bit value into a register in the most efficient manner. |
| 490 | void Load32BitValue(Register dest, int32_t value); |
| 491 | |
| 492 | // Compare a register with a 32-bit value in the most efficient manner. |
| 493 | void Compare32BitValue(Register dest, int32_t value); |
| 494 | |
Vladimir Marko | 56f4bdd | 2016-09-16 11:32:36 +0100 | [diff] [blame] | 495 | // Compare int values. Supports only register locations for `lhs`. |
| 496 | void GenerateIntCompare(Location lhs, Location rhs); |
jessicahandojo | 4877b79 | 2016-09-08 19:49:13 -0700 | [diff] [blame] | 497 | void GenerateIntCompare(Register lhs, Location rhs); |
Vladimir Marko | 56f4bdd | 2016-09-16 11:32:36 +0100 | [diff] [blame] | 498 | |
| 499 | // Construct address for array access. |
| 500 | static Address ArrayAddress(Register obj, |
| 501 | Location index, |
| 502 | ScaleFactor scale, |
| 503 | uint32_t data_offset); |
| 504 | |
Mark Mendell | 805b3b5 | 2015-09-18 14:10:29 -0400 | [diff] [blame] | 505 | Address LiteralCaseTable(HX86PackedSwitch* switch_instr, Register reg, Register value); |
| 506 | |
Mark Mendell | 0616ae0 | 2015-04-17 12:49:27 -0400 | [diff] [blame] | 507 | void Finalize(CodeAllocator* allocator) OVERRIDE; |
| 508 | |
Roland Levillain | 7c1559a | 2015-12-15 10:55:36 +0000 | [diff] [blame] | 509 | // Fast path implementation of ReadBarrier::Barrier for a heap |
| 510 | // reference field load when Baker's read barriers are used. |
| 511 | void GenerateFieldLoadWithBakerReadBarrier(HInstruction* instruction, |
Roland Levillain | e3f43ac | 2016-01-19 15:07:47 +0000 | [diff] [blame] | 512 | Location ref, |
Roland Levillain | 7c1559a | 2015-12-15 10:55:36 +0000 | [diff] [blame] | 513 | Register obj, |
| 514 | uint32_t offset, |
Roland Levillain | 7c1559a | 2015-12-15 10:55:36 +0000 | [diff] [blame] | 515 | bool needs_null_check); |
| 516 | // Fast path implementation of ReadBarrier::Barrier for a heap |
| 517 | // reference array load when Baker's read barriers are used. |
| 518 | void GenerateArrayLoadWithBakerReadBarrier(HInstruction* instruction, |
Roland Levillain | e3f43ac | 2016-01-19 15:07:47 +0000 | [diff] [blame] | 519 | Location ref, |
Roland Levillain | 7c1559a | 2015-12-15 10:55:36 +0000 | [diff] [blame] | 520 | Register obj, |
| 521 | uint32_t data_offset, |
| 522 | Location index, |
Roland Levillain | 7c1559a | 2015-12-15 10:55:36 +0000 | [diff] [blame] | 523 | bool needs_null_check); |
Roland Levillain | a1aa3b1 | 2016-10-26 13:03:38 +0100 | [diff] [blame] | 524 | // Factored implementation, used by GenerateFieldLoadWithBakerReadBarrier, |
| 525 | // GenerateArrayLoadWithBakerReadBarrier and some intrinsics. |
| 526 | // |
| 527 | // Load the object reference located at address `src`, held by |
| 528 | // object `obj`, into `ref`, and mark it if needed. The base of |
| 529 | // address `src` must be `obj`. |
| 530 | // |
| 531 | // If `always_update_field` is true, the value of the reference is |
| 532 | // atomically updated in the holder (`obj`). This operation |
| 533 | // requires a temporary register, which must be provided as a |
| 534 | // non-null pointer (`temp`). |
Sang, Chunlei | 0fcd2b8 | 2016-04-05 17:12:59 +0800 | [diff] [blame] | 535 | void GenerateReferenceLoadWithBakerReadBarrier(HInstruction* instruction, |
| 536 | Location ref, |
| 537 | Register obj, |
| 538 | const Address& src, |
Roland Levillain | a1aa3b1 | 2016-10-26 13:03:38 +0100 | [diff] [blame] | 539 | bool needs_null_check, |
| 540 | bool always_update_field = false, |
| 541 | Register* temp = nullptr); |
Roland Levillain | 7c1559a | 2015-12-15 10:55:36 +0000 | [diff] [blame] | 542 | |
| 543 | // Generate a read barrier for a heap reference within `instruction` |
| 544 | // using a slow path. |
Roland Levillain | 0d5a281 | 2015-11-13 10:07:31 +0000 | [diff] [blame] | 545 | // |
| 546 | // A read barrier for an object reference read from the heap is |
| 547 | // implemented as a call to the artReadBarrierSlow runtime entry |
| 548 | // point, which is passed the values in locations `ref`, `obj`, and |
| 549 | // `offset`: |
| 550 | // |
| 551 | // mirror::Object* artReadBarrierSlow(mirror::Object* ref, |
| 552 | // mirror::Object* obj, |
| 553 | // uint32_t offset); |
| 554 | // |
| 555 | // The `out` location contains the value returned by |
| 556 | // artReadBarrierSlow. |
| 557 | // |
| 558 | // When `index` is provided (i.e. for array accesses), the offset |
| 559 | // value passed to artReadBarrierSlow is adjusted to take `index` |
| 560 | // into account. |
Roland Levillain | 7c1559a | 2015-12-15 10:55:36 +0000 | [diff] [blame] | 561 | void GenerateReadBarrierSlow(HInstruction* instruction, |
| 562 | Location out, |
| 563 | Location ref, |
| 564 | Location obj, |
| 565 | uint32_t offset, |
| 566 | Location index = Location::NoLocation()); |
Roland Levillain | 0d5a281 | 2015-11-13 10:07:31 +0000 | [diff] [blame] | 567 | |
Roland Levillain | 7c1559a | 2015-12-15 10:55:36 +0000 | [diff] [blame] | 568 | // If read barriers are enabled, generate a read barrier for a heap |
| 569 | // reference using a slow path. If heap poisoning is enabled, also |
| 570 | // unpoison the reference in `out`. |
| 571 | void MaybeGenerateReadBarrierSlow(HInstruction* instruction, |
| 572 | Location out, |
| 573 | Location ref, |
| 574 | Location obj, |
| 575 | uint32_t offset, |
| 576 | Location index = Location::NoLocation()); |
Roland Levillain | 0d5a281 | 2015-11-13 10:07:31 +0000 | [diff] [blame] | 577 | |
Roland Levillain | 7c1559a | 2015-12-15 10:55:36 +0000 | [diff] [blame] | 578 | // Generate a read barrier for a GC root within `instruction` using |
| 579 | // a slow path. |
Roland Levillain | 0d5a281 | 2015-11-13 10:07:31 +0000 | [diff] [blame] | 580 | // |
| 581 | // A read barrier for an object reference GC root is implemented as |
| 582 | // a call to the artReadBarrierForRootSlow runtime entry point, |
| 583 | // which is passed the value in location `root`: |
| 584 | // |
| 585 | // mirror::Object* artReadBarrierForRootSlow(GcRoot<mirror::Object>* root); |
| 586 | // |
| 587 | // The `out` location contains the value returned by |
| 588 | // artReadBarrierForRootSlow. |
Roland Levillain | 7c1559a | 2015-12-15 10:55:36 +0000 | [diff] [blame] | 589 | void GenerateReadBarrierForRootSlow(HInstruction* instruction, Location out, Location root); |
Roland Levillain | 0d5a281 | 2015-11-13 10:07:31 +0000 | [diff] [blame] | 590 | |
Mark P Mendell | 17077d8 | 2015-12-16 19:15:59 +0000 | [diff] [blame] | 591 | // Ensure that prior stores complete to memory before subsequent loads. |
| 592 | // The locked add implementation will avoid serializing device memory, but will |
| 593 | // touch (but not change) the top of the stack. |
| 594 | // The 'non_temporal' parameter should be used to ensure ordering of non-temporal stores. |
| 595 | void MemoryFence(bool non_temporal = false) { |
Mark Mendell | 7aa04a1 | 2016-01-27 22:39:07 -0500 | [diff] [blame] | 596 | if (!non_temporal) { |
Mark P Mendell | 17077d8 | 2015-12-16 19:15:59 +0000 | [diff] [blame] | 597 | assembler_.lock()->addl(Address(ESP, 0), Immediate(0)); |
| 598 | } else { |
| 599 | assembler_.mfence(); |
| 600 | } |
| 601 | } |
| 602 | |
Roland Levillain | f41f956 | 2016-09-14 19:26:48 +0100 | [diff] [blame] | 603 | void GenerateNop() OVERRIDE; |
| 604 | void GenerateImplicitNullCheck(HNullCheck* instruction) OVERRIDE; |
| 605 | void GenerateExplicitNullCheck(HNullCheck* instruction) OVERRIDE; |
Mark P Mendell | 17077d8 | 2015-12-16 19:15:59 +0000 | [diff] [blame] | 606 | |
Vladimir Marko | cac5a7e | 2016-02-22 10:39:50 +0000 | [diff] [blame] | 607 | // When we don't know the proper offset for the value, we use kDummy32BitOffset. |
| 608 | // The correct value will be inserted when processing Assembler fixups. |
| 609 | static constexpr int32_t kDummy32BitOffset = 256; |
| 610 | |
Nicolas Geoffray | 3c7bb98 | 2014-07-23 16:04:16 +0100 | [diff] [blame] | 611 | private: |
Nicolas Geoffray | 133719e | 2017-01-22 15:44:39 +0000 | [diff] [blame] | 612 | struct X86PcRelativePatchInfo : PatchInfo<Label> { |
| 613 | X86PcRelativePatchInfo(HX86ComputeBaseMethodAddress* address, |
| 614 | const DexFile& target_dex_file, |
| 615 | uint32_t target_index) |
| 616 | : PatchInfo(target_dex_file, target_index), |
| 617 | method_address(address) {} |
| 618 | HX86ComputeBaseMethodAddress* method_address; |
| 619 | }; |
Vladimir Marko | 0f7dca4 | 2015-11-02 14:36:43 +0000 | [diff] [blame] | 620 | |
Vladimir Marko | aad75c6 | 2016-10-03 08:46:48 +0000 | [diff] [blame] | 621 | template <LinkerPatch (*Factory)(size_t, const DexFile*, uint32_t, uint32_t)> |
Nicolas Geoffray | 133719e | 2017-01-22 15:44:39 +0000 | [diff] [blame] | 622 | void EmitPcRelativeLinkerPatches(const ArenaDeque<X86PcRelativePatchInfo>& infos, |
Vladimir Marko | aad75c6 | 2016-10-03 08:46:48 +0000 | [diff] [blame] | 623 | ArenaVector<LinkerPatch>* linker_patches); |
Vladimir Marko | 0f7dca4 | 2015-11-02 14:36:43 +0000 | [diff] [blame] | 624 | |
Nicolas Geoffray | 133719e | 2017-01-22 15:44:39 +0000 | [diff] [blame] | 625 | Register GetInvokeStaticOrDirectExtraParameter(HInvokeStaticOrDirect* invoke, Register temp); |
| 626 | |
Nicolas Geoffray | 92a73ae | 2014-10-16 11:12:52 +0100 | [diff] [blame] | 627 | // Labels for each block that will be compiled. |
Vladimir Marko | 225b646 | 2015-09-28 12:17:40 +0100 | [diff] [blame] | 628 | Label* block_labels_; // Indexed by block id. |
Nicolas Geoffray | 1cf9528 | 2014-12-12 19:22:03 +0000 | [diff] [blame] | 629 | Label frame_entry_label_; |
Nicolas Geoffray | bab4ed7 | 2014-03-11 17:53:17 +0000 | [diff] [blame] | 630 | LocationsBuilderX86 location_builder_; |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 631 | InstructionCodeGeneratorX86 instruction_visitor_; |
Nicolas Geoffray | 86dbb9a | 2014-06-04 11:12:39 +0100 | [diff] [blame] | 632 | ParallelMoveResolverX86 move_resolver_; |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 633 | X86Assembler assembler_; |
Mark Mendell | fb8d279 | 2015-03-31 22:16:59 -0400 | [diff] [blame] | 634 | const X86InstructionSetFeatures& isa_features_; |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 635 | |
Vladimir Marko | 0f7dca4 | 2015-11-02 14:36:43 +0000 | [diff] [blame] | 636 | // PC-relative DexCache access info. |
Nicolas Geoffray | 133719e | 2017-01-22 15:44:39 +0000 | [diff] [blame] | 637 | ArenaDeque<X86PcRelativePatchInfo> pc_relative_dex_cache_patches_; |
Vladimir Marko | 6597946 | 2017-05-19 17:25:12 +0100 | [diff] [blame] | 638 | // PC-relative method patch info for kBootImageLinkTimePcRelative. |
| 639 | ArenaDeque<X86PcRelativePatchInfo> boot_image_method_patches_; |
Vladimir Marko | 764d454 | 2017-05-16 10:31:41 +0100 | [diff] [blame] | 640 | // PC-relative type patch info for kBootImageLinkTimePcRelative. |
Nicolas Geoffray | 133719e | 2017-01-22 15:44:39 +0000 | [diff] [blame] | 641 | ArenaDeque<X86PcRelativePatchInfo> boot_image_type_patches_; |
Vladimir Marko | 1998cd0 | 2017-01-13 13:02:58 +0000 | [diff] [blame] | 642 | // Type patch locations for kBssEntry. |
Nicolas Geoffray | 133719e | 2017-01-22 15:44:39 +0000 | [diff] [blame] | 643 | ArenaDeque<X86PcRelativePatchInfo> type_bss_entry_patches_; |
Vladimir Marko | 6597946 | 2017-05-19 17:25:12 +0100 | [diff] [blame] | 644 | // String patch locations; type depends on configuration (app .bss or boot image). |
| 645 | ArenaDeque<X86PcRelativePatchInfo> string_patches_; |
Vladimir Marko | 5815501 | 2015-08-19 12:49:41 +0000 | [diff] [blame] | 646 | |
Nicolas Geoffray | 132d836 | 2016-11-16 09:19:42 +0000 | [diff] [blame] | 647 | // Patches for string root accesses in JIT compiled code. |
| 648 | ArenaDeque<PatchInfo<Label>> jit_string_patches_; |
Nicolas Geoffray | 22384ae | 2016-12-12 22:33:36 +0000 | [diff] [blame] | 649 | // Patches for class root accesses in JIT compiled code. |
| 650 | ArenaDeque<PatchInfo<Label>> jit_class_patches_; |
| 651 | |
Mark Mendell | 0616ae0 | 2015-04-17 12:49:27 -0400 | [diff] [blame] | 652 | // Offset to the start of the constant area in the assembled code. |
| 653 | // Used for fixups to the constant area. |
| 654 | int32_t constant_area_start_; |
| 655 | |
Mark Mendell | 805b3b5 | 2015-09-18 14:10:29 -0400 | [diff] [blame] | 656 | // Fixups for jump tables that need to be patched after the constant table is generated. |
| 657 | ArenaVector<JumpTableRIPFixup*> fixups_to_jump_tables_; |
| 658 | |
Nicolas Geoffray | 133719e | 2017-01-22 15:44:39 +0000 | [diff] [blame] | 659 | // Maps a HX86ComputeBaseMethodAddress instruction id, to its offset in the |
| 660 | // compiled code. |
| 661 | ArenaSafeMap<uint32_t, int32_t> method_address_offset_; |
Mark Mendell | 0616ae0 | 2015-04-17 12:49:27 -0400 | [diff] [blame] | 662 | |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 663 | DISALLOW_COPY_AND_ASSIGN(CodeGeneratorX86); |
| 664 | }; |
| 665 | |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 666 | } // namespace x86 |
| 667 | } // namespace art |
| 668 | |
| 669 | #endif // ART_COMPILER_OPTIMIZING_CODE_GENERATOR_X86_H_ |