OLD | NEW |
1 // Copyright 2014 the V8 project authors. All rights reserved. | 1 // Copyright 2014 the V8 project authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "src/base/adapters.h" | 5 #include "src/base/adapters.h" |
6 #include "src/base/bits.h" | 6 #include "src/base/bits.h" |
7 #include "src/compiler/instruction-selector-impl.h" | 7 #include "src/compiler/instruction-selector-impl.h" |
8 #include "src/compiler/node-matchers.h" | 8 #include "src/compiler/node-matchers.h" |
9 #include "src/compiler/node-properties.h" | 9 #include "src/compiler/node-properties.h" |
10 | 10 |
(...skipping 160 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
171 } | 171 } |
172 | 172 |
173 | 173 |
174 void InstructionSelector::VisitStore(Node* node) { | 174 void InstructionSelector::VisitStore(Node* node) { |
175 MipsOperandGenerator g(this); | 175 MipsOperandGenerator g(this); |
176 Node* base = node->InputAt(0); | 176 Node* base = node->InputAt(0); |
177 Node* index = node->InputAt(1); | 177 Node* index = node->InputAt(1); |
178 Node* value = node->InputAt(2); | 178 Node* value = node->InputAt(2); |
179 | 179 |
180 StoreRepresentation store_rep = OpParameter<StoreRepresentation>(node); | 180 StoreRepresentation store_rep = OpParameter<StoreRepresentation>(node); |
| 181 WriteBarrierKind write_barrier_kind = store_rep.write_barrier_kind(); |
181 MachineType rep = RepresentationOf(store_rep.machine_type()); | 182 MachineType rep = RepresentationOf(store_rep.machine_type()); |
182 if (store_rep.write_barrier_kind() == kFullWriteBarrier) { | |
183 DCHECK(rep == kRepTagged); | |
184 // TODO(dcarney): refactor RecordWrite function to take temp registers | |
185 // and pass them here instead of using fixed regs | |
186 // TODO(dcarney): handle immediate indices. | |
187 InstructionOperand temps[] = {g.TempRegister(t1), g.TempRegister(t2)}; | |
188 Emit(kMipsStoreWriteBarrier, g.NoOutput(), g.UseFixed(base, t0), | |
189 g.UseFixed(index, t1), g.UseFixed(value, t2), arraysize(temps), temps); | |
190 return; | |
191 } | |
192 DCHECK_EQ(kNoWriteBarrier, store_rep.write_barrier_kind()); | |
193 | 183 |
194 ArchOpcode opcode; | 184 ArchOpcode opcode; |
195 switch (rep) { | 185 switch (rep) { |
196 case kRepFloat32: | 186 case kRepFloat32: |
197 opcode = kMipsSwc1; | 187 opcode = kMipsSwc1; |
198 break; | 188 break; |
199 case kRepFloat64: | 189 case kRepFloat64: |
200 opcode = kMipsSdc1; | 190 opcode = kMipsSdc1; |
201 break; | 191 break; |
202 case kRepBit: // Fall through. | 192 case kRepBit: // Fall through. |
(...skipping 16 matching lines...) Expand all Loading... |
219 Emit(opcode | AddressingModeField::encode(kMode_MRI), g.NoOutput(), | 209 Emit(opcode | AddressingModeField::encode(kMode_MRI), g.NoOutput(), |
220 g.UseRegister(base), g.UseImmediate(index), g.UseRegister(value)); | 210 g.UseRegister(base), g.UseImmediate(index), g.UseRegister(value)); |
221 } else { | 211 } else { |
222 InstructionOperand addr_reg = g.TempRegister(); | 212 InstructionOperand addr_reg = g.TempRegister(); |
223 Emit(kMipsAdd | AddressingModeField::encode(kMode_None), addr_reg, | 213 Emit(kMipsAdd | AddressingModeField::encode(kMode_None), addr_reg, |
224 g.UseRegister(index), g.UseRegister(base)); | 214 g.UseRegister(index), g.UseRegister(base)); |
225 // Emit desired store opcode, using temp addr_reg. | 215 // Emit desired store opcode, using temp addr_reg. |
226 Emit(opcode | AddressingModeField::encode(kMode_MRI), g.NoOutput(), | 216 Emit(opcode | AddressingModeField::encode(kMode_MRI), g.NoOutput(), |
227 addr_reg, g.TempImmediate(0), g.UseRegister(value)); | 217 addr_reg, g.TempImmediate(0), g.UseRegister(value)); |
228 } | 218 } |
| 219 |
| 220 // TODO(mips): I guess this could be done in a better way. |
| 221 if (write_barrier_kind != kNoWriteBarrier) { |
| 222 DCHECK_EQ(kRepTagged, rep); |
| 223 InstructionOperand inputs[3]; |
| 224 size_t input_count = 0; |
| 225 inputs[input_count++] = g.UseUniqueRegister(base); |
| 226 inputs[input_count++] = g.UseUniqueRegister(index); |
| 227 RecordWriteMode record_write_mode; |
| 228 switch (write_barrier_kind) { |
| 229 case kNoWriteBarrier: |
| 230 UNREACHABLE(); |
| 231 break; |
| 232 case kMapWriteBarrier: |
| 233 record_write_mode = RecordWriteMode::kValueIsMap; |
| 234 break; |
| 235 case kPointerWriteBarrier: |
| 236 inputs[input_count++] = g.UseUniqueRegister(value); |
| 237 record_write_mode = RecordWriteMode::kValueIsPointer; |
| 238 break; |
| 239 case kFullWriteBarrier: |
| 240 inputs[input_count++] = g.UseUniqueRegister(value); |
| 241 record_write_mode = RecordWriteMode::kValueIsAny; |
| 242 break; |
| 243 } |
| 244 InstructionOperand temps[] = {g.TempRegister(), g.TempRegister()}; |
| 245 size_t const temp_count = arraysize(temps); |
| 246 InstructionCode code = kArchRecordWrite; |
| 247 code |= MiscField::encode(static_cast<int>(record_write_mode)); |
| 248 Emit(code, 0, nullptr, input_count, inputs, temp_count, temps); |
| 249 } |
229 } | 250 } |
230 | 251 |
231 | 252 |
232 void InstructionSelector::VisitWord32And(Node* node) { | 253 void InstructionSelector::VisitWord32And(Node* node) { |
233 VisitBinop(this, node, kMipsAnd); | 254 VisitBinop(this, node, kMipsAnd); |
234 } | 255 } |
235 | 256 |
236 | 257 |
237 void InstructionSelector::VisitWord32Or(Node* node) { | 258 void InstructionSelector::VisitWord32Or(Node* node) { |
238 VisitBinop(this, node, kMipsOr); | 259 VisitBinop(this, node, kMipsOr); |
(...skipping 845 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1084 } | 1105 } |
1085 return flags | MachineOperatorBuilder::kFloat64Min | | 1106 return flags | MachineOperatorBuilder::kFloat64Min | |
1086 MachineOperatorBuilder::kFloat64Max | | 1107 MachineOperatorBuilder::kFloat64Max | |
1087 MachineOperatorBuilder::kFloat32Min | | 1108 MachineOperatorBuilder::kFloat32Min | |
1088 MachineOperatorBuilder::kFloat32Max; | 1109 MachineOperatorBuilder::kFloat32Max; |
1089 } | 1110 } |
1090 | 1111 |
1091 } // namespace compiler | 1112 } // namespace compiler |
1092 } // namespace internal | 1113 } // namespace internal |
1093 } // namespace v8 | 1114 } // namespace v8 |
OLD | NEW |